allocJammer.hpp

#ifndef RIDE_ALLOC_JAMMER_HPP
#define RIDE_ALLOC_JAMMER_HPP

#include <list>
#include <vector>
#include "ride/trajectory.hpp"
#include "ride/threat.hpp"
#include "ride/interval.hpp"
//#include "kernel/jafarException.hpp"
//#include "ride/rideException.hpp"


namespace jafar {

    namespace ride {

        class Alloc {
            private :
                // threats vector must be in the correct order
                std::vector<Threat> threats;
            public :
                Alloc();
                Alloc(std::vector<Threat> threats_);
                Alloc(std::vector<Threat>::iterator const& itb,
                        std::vector<Threat>::iterator const& ite);
                ~Alloc();
                bool operator == (Alloc const& a) const;
                std::vector<Threat> getThreats() const;
                std::vector<int> getThreatsId() const;
                bool isInAlloc(int id) const;
                Vect getDirection2D(Vect const& pos) const;
                Vect getDirection3D(Vect const& pos) const;
                double getAperture(Vect const& pos) const;
                double getCost(Vect const& pos) const;
                bool isValid(posTraj const& pos,
                        std::list<Threat> const& ewList,
                        std::list<Threat> const& visited,
                        double apertureMax) const;
        };

        typedef std::list<Alloc> localAlloc;

        struct rangeAlloc {
            double start,end;
            localAlloc alloc;
        };

        class GlobalAlloc {
            private :
                std::list<rangeAlloc> globalAlloc;
            public :
                GlobalAlloc();
                ~GlobalAlloc();
                void addLocalAlloc(localAlloc local, double start, double end);
                std::list<rangeAlloc> getGlobalAlloc() const;
                localAlloc getLocalAlloc(double dist) const;
                std::list<rangeAlloc> getNextLocalAlloc(double dist, double anticip) const;
        };

        GlobalAlloc computeAlloc(
                Formation const& form,
                Trajectory const& traj,
                GlobalThreat & threats);

        std::pair<std::list<Slot>,std::list<Alloc> > getJamEWSlotList(
                posTraj const& pos,
                Formation const& form,
                GlobalAlloc const& alloc,
                Interval const& inter,
                GlobalThreat & threats);

        struct unprotectedSlot {
            int uavId;
            int threatId;
        };

        std::list<unprotectedSlot> setDefensiveJamming(
                posTraj const& pos,
                Formation & form,
                std::list<Threat> const& threats,
                Interval const& inter);

    }

}


#endif