User Manual, Developers Guide and API Documentation

DataTransmission.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 5, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

#ifndef WNS_SERVICE_PHY_OFDMA_DATATRANSMISSION_HPP
#define WNS_SERVICE_PHY_OFDMA_DATATRANSMISSION_HPP

#include <WNS/node/Interface.hpp>
#include <WNS/CandI.hpp>
#include <WNS/service/Service.hpp>
#include <WNS/service/phy/ofdma/Pattern.hpp>
#include <WNS/service/phy/phymode/PhyModeInterface.hpp>
#include <WNS/osi/PDU.hpp>
#include <WNS/SmartPtr.hpp>
#include <WNS/PowerRatio.hpp>
#include <map>

namespace wns { namespace service { namespace phy { namespace ofdma {

    struct Tune
    {
        double frequency;
        double bandwidth;
        int numberOfSubCarrier;

        bool operator==(const wns::service::phy::ofdma::Tune& other) const{
            return ( (frequency == other.frequency) &&
                     (bandwidth == other.bandwidth) &&
                     (numberOfSubCarrier == other.numberOfSubCarrier));
        }

        Tune& operator=(const wns::service::phy::ofdma::Tune& other){
            this->frequency = other.frequency;
            this->bandwidth = other.bandwidth;
            this->numberOfSubCarrier = other.numberOfSubCarrier;
            return (*this);
        }
    };

    struct BFIdu
    {
        osi::PDUPtr pdu;
        node::Interface* recipient;
        int subBand;
        PatternPtr pattern;
    };

    class TransmissionBase :
        public virtual service::Service
    {
    public:
        virtual
        ~TransmissionBase(){}

        virtual void
        stopTransmission(osi::PDUPtr pdu, int subBand) = 0;

        virtual bool
        isReceiving() const = 0;

        virtual std::string
        printActiveTransmissions() const = 0;
    };

    class NonBFTransmission :
        public virtual TransmissionBase
    {
    public:
        virtual
        ~NonBFTransmission(){}

        virtual void
        startUnicast(osi::PDUPtr pdu,
                     wns::node::Interface* recipient,
                     int subBand,
                     wns::Power requestedTxPower,
                     int numberOfSpatialStreams) = 0;

        virtual void
        startUnicast(osi::PDUPtr pdu,
                     wns::node::Interface* recipient,
                     int subBand,
                     wns::Power requestedTxPower,
                     wns::service::phy::phymode::PhyModeInterfacePtr phyModePtr) = 0;

        virtual void
        startBroadcast(osi::PDUPtr pdu,
                       int subBand,
                       wns::Power requestedTxPower,
                       int numberOfSpatialStreams) = 0;
        virtual void
        startBroadcast(osi::PDUPtr pdu,
                       int subBand,
                       wns::Power requestedTxPower,
                       wns::service::phy::phymode::PhyModeInterfacePtr phyModePtr) = 0;
    };

    class BFTransmission :
        public virtual  TransmissionBase
    {
    public:
        virtual
        ~BFTransmission(){}

        virtual void
        startTransmission(wns::osi::PDUPtr pdu,
                          wns::node::Interface* recipient,
                          int subBand,
                          PatternPtr pattern,
                          wns::Power requestedTxPower,
                          int numberOfSpatialStreams) = 0;

        virtual void
        startTransmission(wns::osi::PDUPtr pdu,
                          wns::node::Interface* recipient,
                          int subBand,
                          PatternPtr pattern,
                          wns::Power requestedTxPower,
                          wns::service::phy::phymode::PhyModeInterfacePtr phyModePtr) = 0;

    };

    class RFSettings :
        public virtual service::Service
    {
    public:
        virtual
        ~RFSettings(){}

        virtual void
        setTxTune(const Tune& txTune) = 0;

        virtual void
        setRxTune(const Tune& rxTune) = 0;

        virtual Tune
        getRxTune() const = 0;

        virtual Tune
        getTxTune() const = 0;

        virtual wns::Power
        getMaxPowerPerSubband() const = 0;

        virtual wns::Power
        getMaxOutputPower() const = 0;

        virtual bool
        isEIRPLimited() const = 0;

        virtual void
        setTxRxSwap(bool reverse) = 0;
    };

    class SINREstimation :
        public virtual service::Service
    {
    public:
        virtual
        ~SINREstimation(){}

        virtual std::map<wns::node::Interface*, wns::Ratio>
        calculateSINRsRx(const std::vector<node::Interface*>& combination,
                 wns::Power Iinter) = 0;

        virtual std::map<wns::node::Interface*, wns::Ratio>
        calculateSINRsTx(const std::map<wns::node::Interface*, wns::Power>& Station2NoisePlusIintercell,
                 wns::Power x_friendlyness,
                 wns::Power txPower) = 0;

        virtual std::map<wns::node::Interface*, wns::CandI>
        calculateCandIsRx(const std::vector<node::Interface*>& /* combination */,
                  wns::Power /* Iinter */) = 0;

        virtual std::map<wns::node::Interface*, wns::CandI>
        calculateCandIsTx(const std::map<wns::node::Interface*, wns::Power>& /* Station2NoisePlusIintercell */,
                  wns::Power /* x_friendlyness */,
                  wns::Power /* txPower */) = 0;

        virtual void
        setPowerReceivedForStation(wns::node::Interface* stack, wns::Power _rxPower) = 0;

        virtual void
        setTxPowerForStation(wns::node::Interface* stack, wns::Power _txPower) = 0;
    };

    class BeamForming :
        public virtual service::Service
    {
    public:
        virtual
        ~BeamForming(){}

        virtual PatternPtr
        calculateAndSetBeam(wns::node::Interface *id,
                    const std::vector<node::Interface*>& undesired,
                    wns::Power IinterPlusNoise) = 0;
        virtual double
        estimateDoA(wns::node::Interface *id) = 0;

        virtual void
        setCurrentReceivePatterns(std::map<wns::node::Interface*, PatternPtr>) = 0;

        virtual void
        insertReceivePattern(wns::node::Interface*, PatternPtr) = 0;

        virtual void
        removeReceivePattern(wns::node::Interface*) = 0;
    };

    class BFInterface :
        public virtual BFTransmission,
        public virtual SINREstimation,
        public virtual BeamForming,
        public virtual RFSettings
    {
    public:
        virtual
        ~BFInterface(){}
        //
    };

    class NonBFInterface :
        public virtual NonBFTransmission,
        public virtual RFSettings
    {
    public:
        virtual
        ~NonBFInterface(){}
        //
    };

    class DataTransmission :
        public virtual BFInterface,
        public virtual NonBFInterface
    {
    public:
        virtual
        ~DataTransmission(){}
    };

} // ofdma
} // phy
} // service
} // wns


#endif // WNS_SERVICE_PHY_OFDMA_DATATRANSMISSION

---