PipelineMonitorInput.h

#ifndef CARMA_MONITOR_PIPELINE_MONITOR_INPUT_H
#define CARMA_MONITOR_PIPELINE_MONITOR_INPUT_H

#include "carma/util/types.h"

#include "carma/monitor/CorrDesignation.h"
#include "carma/monitor/MonitorSystem.h"
#include "carma/monitor/SignalPathSubsystem.h"
#include "carma/util/types.h"

#include <map>
#include <vector>
#include <set>


namespace carma {
namespace monitor {

class MonitorSystem;
class AntennaCommon;
class ControlBandPoints;
class MonitorPointFloat;
class NoiseStatusMonitorPointEnum;

typedef PolarizationMonitorPointEnum PolMPE;
typedef PolarizationMonitorPointEnum::POLARIZATION PolType;
typedef std::pair< int, PolType > AntPolPair;
typedef std::pair< int, PolType > BandPolPair;
typedef std::pair< int, int > BandInputPair;

class PipelineMonitorInput {
public:

    PipelineMonitorInput( MonitorCorrelatorDesignation corrDes );
    
    ~PipelineMonitorInput( );

    bool waitForInput( carma::util::frameType frame );

    std::vector< int > getMappedAstroBandNumbers( ) const;

    std::set< int > getMappedAntennaNumbers( ) const;

    std::set< int > getMappedInputNumbers( ) const;

    std::set< PolType > getMappedPols( int astroBandNo ) const;

    std::vector< AntPolPair > getMappedAntPolPairs( int astroBandNo ) const;

    std::vector< BandPolPair > getMappedBandPolPairs( ) const;

    std::vector< BandInputPair > 
    getMappedAstroBandInputPairs( int carmaAntNo ) const;

    bool signalPathMapped( int astroBandNo ) const;
    
    bool signalPathMapped( int astroBandNo, const AntPolPair & antPol ) const;

    AntPolPair getAntPolPair( int astroBandNo, int astroInputNo ) const;

    int getAstroInputNo( int astroBandNo, const AntPolPair & antPol ) const;

    carma::util::frameType frameCount( ) const;

    std::pair< bool, bool > isRxInSideband( int astroBandNo, 
                                            const AntPolPair & antPol,
                                            bool usb ) const; 

    const AntennaCommon & antennaCommon( int carmaAntNo ) const; 
    const ControlBandPoints & controlBandPoints( int astroBandNo ) const;
    const MonitorPointFloat & totalPower( int astroBandNo, 
                                          const AntPolPair & antPol) const;
    const NoiseStatusMonitorPointEnum & noiseStatus( 
        MonitorCorrelatorDesignation corrDes ) const;
    const MonitorPointByte & blankStatus(
        int astroBandNo,
        const AntPolPair & antPol ) const;

    const WeatherSubsystem & weather( ) const;
    const ControlSubsystem & control( ) const;
    BandInputPair getCorrBandInputPair( int astroBandNo, 
                                        const AntPolPair & antPol ) const;

    MonitorCorrelatorDesignation getAntCorrDes( int carmaAntNo ) const;

    MonitorCorrelatorDesignation getAntSubarrayCorrDes( int carmaAntNo ) const;

    int getExpectedChannels( int astroBandNo ) const;

    bool astroBandOnline( int astroBandNo ) const;

    void getCorrInfo(int astroBandNo, int astroBandInput, 
                     MonitorCorrelatorDesignation& corrDes, int& corrBandNo, int& corrBandInputNo);

    bool isManuallyFlagged(int astroBandNo, int astroBandInput1, int astroBandInput2);

    const carma::monitor::CarmaMonitorSystem & getCarmaMonitorSystem() const;

private:

    struct MapDetails;

    // Too many different maps here - consolidate this into the SPM class.
    typedef std::map< int, MapDetails > AstroInputMap;
    typedef std::map< int, AstroInputMap > AstroBandInputMap;
    
    // This is a reverse multimap to get fast lookups on ant/pol
    // This can go away if we modify the above to be pure input based.
    typedef std::multimap< AntPolPair, int > AntPolInputMultimap;
    typedef std::map< int, AntPolInputMultimap > AstroBandAntPolInputMap;

    // Keyed on absolute carma antenna number.
    typedef std::map< int, std::vector< BandInputPair > > AntAstroPairs;

    void internalSpmUpdate();
    void internalAstrobandUpdate( 
        const SignalPathSubsystem::Astroband & astroband,
        const int astroBandNo );

    void flagInputs(MonitorCorrelatorDesignation corrDes, int bandNo, int inputNo1, int inputNo2, int nMaxBand);
    void rebuildControlMap(MonitorCorrelatorDesignation corrDes) ;
    void rebuildControlMaps() ;
    void clearControlMap(MonitorCorrelatorDesignation corrDes);
    void clearControlMaps() ;
    void internalControlUpdate(); 

    const MapDetails & getMapDetails( int astroBandNo, 
                                      const AntPolPair & antPol ) const;
    
    const MapDetails & getMapDetails( int astroBandNo,  
                                      int astroInputNo ) const;

    AstroBandInputMap astroMapping_;   
    AstroBandAntPolInputMap antPolMapping_;
    std::map< int, std::set< PolType > > astroBandPolMapping_;
    std::set< int > mappedAnts_;
    std::set< int > mappedInputs_;
    AntAstroPairs mappedAntAstroPairs_;
    
    typedef std::map< int, std::set< int > > AstroBandCorrBandMap;
    AstroBandCorrBandMap astroBandCorrBands_;

    int lastMappingUpdate_;

    const MonitorCorrelatorDesignation corrDes_; 

    mutable carma::monitor::CarmaMonitorSystem cms_;

    std::map<MonitorCorrelatorDesignation, std::map<int, std::map<int, std::map<int, bool> > > > flagMap_;
};

}} // namespace carma::monitor
#endif