User Manual, Developers Guide and API Documentation

InterferenceCache.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 DLL_SERVICES_MANAGEMENT_INTERFERENCECACHE_HPP
#define DLL_SERVICES_MANAGEMENT_INTERFERENCECACHE_HPP

#include <map>
#include <set>
#include <WNS/ldk/ldk.hpp>
#include <WNS/PowerRatio.hpp>
#include <WNS/pyconfig/View.hpp>
#include <WNS/ldk/ManagementServiceInterface.hpp>
#include <WNS/logger/Logger.hpp>
#include <WNS/node/Interface.hpp>
#include <WNS/ldk/PyConfigCreator.hpp>
#include <WNS/service/phy/power/PowerMeasurement.hpp>

namespace wns {
    namespace ldk {
        class ManagementServiceRegistry;
    }
}

namespace dll { namespace services { namespace management {


    class InterferenceCache :
        public wns::ldk::ManagementService
    {
    public:
        class NotFoundStrategy
        {
        public:
            virtual ~NotFoundStrategy() {}

            virtual wns::Power notFoundAverageCarrier() = 0;

            virtual wns::Power notFoundAverageInterference() = 0;

            virtual wns::Ratio notFoundAveragePathloss() = 0;

            virtual wns::Power notFoundDeviationCarrier() = 0;

            virtual wns::Power notFoundDeviationInterference() = 0;
        };

        typedef wns::ldk::PyConfigCreator<NotFoundStrategy> NotFoundStrategyCreator;
        typedef wns::StaticFactory<NotFoundStrategyCreator> NotFoundStrategyFactory;


        class ConstantValue :
            public NotFoundStrategy
        {
        public:

            ConstantValue( const wns::pyconfig::View& );

            wns::Power notFoundAverageCarrier()
            {
                return averageCarrier;
            }

            wns::Power notFoundAverageInterference()
            {
                return averageInterference;
            }

            wns::Ratio notFoundAveragePathloss()
            {
                return averagePathloss;
            }

            wns::Power notFoundDeviationCarrier()
            {
                return deviationCarrier;
            }

            wns::Power notFoundDeviationInterference()
            {
                return deviationInterference;
            }

        private:
            wns::Power averageCarrier;
            wns::Power averageInterference;
            wns::Power deviationCarrier;
            wns::Power deviationInterference;
            wns::Ratio averagePathloss;
        };

        class Complain :
            public virtual NotFoundStrategy
        {
        public:
            Complain(const wns::pyconfig::View&)
            {}

            wns::Power notFoundAverageCarrier()
            {
                throw wns::Exception("Average Carrier value not found");
                return wns::Power();
            }

            wns::Power notFoundAverageInterference()
            {
                throw wns::Exception("Average Interference value not found");
                return wns::Power();
            }

            wns::Ratio notFoundAveragePathloss()
            {
                throw wns::Exception("Average Pathloss value not found");
                return wns::Ratio();
            }

            wns::Power notFoundDeviationCarrier()
            {
                throw wns::Exception("Carrier value deviation not found");
                return wns::Power();
            }

            wns::Power notFoundDeviationInterference()
            {
                throw wns::Exception("Interference calue deviation not found");
                return wns::Power();
            }
        };


        InterferenceCache( wns::ldk::ManagementServiceRegistry*, const wns::pyconfig::View& config );

        virtual ~InterferenceCache(){}

        virtual void
        onMSRCreated();

        enum ValueOrigin {
            Local,
            Remote
        };

        void storeMeasurements( wns::node::Interface* node, wns::service::phy::power::PowerMeasurementPtr rxPowerMeasurement, ValueOrigin origin, int subBand = 0);

        void storeCarrier( wns::node::Interface* node, const wns::Power& carrier, ValueOrigin origin, int subBand = 0);


        void storeInterference( wns::node::Interface* node, const wns::Power& interference, ValueOrigin origin, int subBand = 0);

        void storePathloss( wns::node::Interface* node, const wns::Ratio& pathloss, ValueOrigin origin, int subBand = 0);

        wns::Power getAveragedCarrier( wns::node::Interface* node, int subBand = 0 ) const;

        wns::Power getAveragedInterference( wns::node::Interface* node, int subBand = 0 ) const;

        wns::Ratio getAveragedPathloss( wns::node::Interface* node, int subBand = 0 ) const;

        wns::Power getPerSCAveragedCarrier( wns::node::Interface* node) const;

        wns::Power getPerSCAveragedInterference( wns::node::Interface* node) const;

        wns::Ratio getPerSCAveragedPathloss( wns::node::Interface* node) const;
        wns::Ratio 
        getAverageEmittedInterferencePathloss(wns::node::Interface* node) const;

        wns::Power getCarrierDeviation( wns::node::Interface*, int subBand = 0 ) const;

        wns::Power getInterferenceDeviation( wns::node::Interface*, int subBand = 0 ) const;


    private:
        class InterferenceCacheKey :
            public std::binary_function<const InterferenceCacheKey, const InterferenceCacheKey, bool>
        {
        public:
            InterferenceCacheKey(wns::node::Interface* node, int subBand) :
                node_(node),
                subBand_(subBand)
            {}

            bool operator<(const InterferenceCacheKey& rhs) const
            {
                if ( node_->getNodeID() == rhs.node_->getNodeID() )
                    return subBand_ < rhs.subBand_;
                return node_->getNodeID() < rhs.node_->getNodeID();
            }
        private:
            wns::node::Interface* node_;
            int subBand_;
        };

        typedef std::map<InterferenceCacheKey, wns::Power> Node2Power;
        typedef std::map<InterferenceCacheKey, double> Node2Double;

        Node2Power node2CarrierAverage_;
        Node2Power node2InterferenceAverage_;
        Node2Double node2CarrierSqExp_;
        Node2Double node2InterferenceSqExp_;
        Node2Double node2pathloss;
        double alphaLocal_;
        double alphaRemote_;
        mutable bool initialized_;
        mutable std::list<InterferenceCache*> remoteBSCaches_;
        std::map<int, std::set<int> > userSubbands_;
        std::string serviceName_;

        wns::logger::Logger logger;

        std::auto_ptr<NotFoundStrategy> notFoundStrategy;
    };
}}}
#endif // NOT DEFINED DLL_SERVICES_MANAGEMENT_INTERFERENCECACHE_HPP

---