MonitorSystem.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_MONITORSYSTEM_H 
#define CARMA_MONITOR_MONITORSYSTEM_H

#include <string>
#include <vector>
#include <iomanip>
#include <ios>

#include "carma/monitor/MonitorSubsystem.h"
// To get the default queueDepth...
#include "carma/monitor/SubsystemFrameBuffer.h"

namespace carma {
    namespace monitor {

// Forward class declarations
class AntennaCommon;
class AstroSubsystem;
class BimaSubsystem;
class C3gMax8PipelineSubsystem;
class C3gMax23PipelineSubsystem;
class CarmaSlcBandSubsystem;
class Carma3GBandSubsystem;
class CentralIfSubsystem;
class ControlSubsystem;
class DataflowSubsystem;
class DelayEngineSubsystem;
class FaultSubsystem;
class ImrSubsystem;
class AlarmSubsystem;
class LineLengthSubsystem;
class LoberotatorSubsystem;
class LoRefSubsystem;
class MasterClockSubsystem;
class OpacityMonitorSubsystem;
class OvroSubsystem;
class PhaseMonitorSubsystem;
class ProjectDatabaseManagerSubsystem;
class SignalPathSubsystem;
class SldcSubsystem;
class SlPipelineSubsystem;
class SystemStatusSubsystem;
class SzaSubsystem;
class TestSubsystem;
class VlbiSubsystem;
class WbdcSubsystem;
class WbcBandSubsystem;
class WbPipelineSubsystem;
class WeatherSubsystem;
class WbDataflowSubsystem;
class SlDataflowSubsystem;
class C3gDataflowSubsystem;
class WbRemapperSubsystem;
class SlRemapperSubsystem;
class C3gRemapperSubsystem;

class SystemFrameBuffer;
class SubsystemFrame;

class MonitorSystem : public MonitorSystemContainer {
public:

    MonitorSystem(const std::string& systemName, long nSubsystems, 
                    long nMonitorPoints, long nSamples,
                    int queueDepth=SubsystemFrameBuffer::kDefaultQueueDepth);

    virtual ~MonitorSystem() ;
        
     AntennaCommon& antennaCommon( int index ) const;

    AstroSubsystem& astro( ) const { return astro_; }

    BimaSubsystem& bima(int index) const { return *(bimas_.at( index )); }

    C3gMax8PipelineSubsystem& c3gMax8Pipeline( ) const { return c3gMax8Pipeline_; } 
    
    C3gMax23PipelineSubsystem& c3gMax23Pipeline( ) const { return c3gMax23Pipeline_; } 

    CentralIfSubsystem& centralIf() const { return centralIf_; }

    ControlSubsystem& control() const { return control_; }

    DataflowSubsystem& dataflow() const { return dataflow_; }
    
    DelayEngineSubsystem& delay() const { return delayEngine_; }
    
    FaultSubsystem & fault( ) const;

    ImrSubsystem& imr() const { return imr_; };

    AlarmSubsystem& alarm() const { return alarm_; }
    
    LineLengthSubsystem& lineLength() const { return lineLength_; }
    
    LoberotatorSubsystem& loberotator() const { return loberotator_; }
    
    LoRefSubsystem& loRef() const { return loRef_; }
    
    MasterClockSubsystem& masterclock() const { return masterclock_; }
    
    OpacityMonitorSubsystem& opacityMonitor() const { return opacityMonitor_; }
    
    OvroSubsystem& ovro(int index) const { return *(ovros_.at( index )); }
    
    PhaseMonitorSubsystem& phaseMonitor() const { return phaseMonitor_; }

    ProjectDatabaseManagerSubsystem& projectDatabaseManager()
        const { return projectDatabaseManager_; }

    SignalPathSubsystem & signalPath() const { return signalPath_; };

    CarmaSlcBandSubsystem & carmaSlcBand( const int index ) const {
        return *(carmaSlcBands_.at( index ));
    }

    int getCarmaSlcBandCount() const ;

    Carma3GBandSubsystem & carma3gBand( const int index ) const {
        return *(carma3gBands_.at( index ));
    }

    int getCarma3gBandCount() const ;

    SldcSubsystem& sldc() const { return sldc_; }

    SlPipelineSubsystem& slPipeline() const { return slPipeline_; }

    SystemStatusSubsystem& systemStatus() const { return systemStatus_; }

    SzaSubsystem& sza(int index) const { return *(szas_.at( index )); }
    
    WbcBandSubsystem & wbcBand( const int index ) const {
        return *(wbcBands_.at(index));
    }

    int getWbcBandCount() const ;
    
    WbdcSubsystem& wbdc() const { return wbdc_; }

    WbPipelineSubsystem& wbPipeline() const { return wbPipeline_; }

    WeatherSubsystem& weather() const { return weather_; }
    
    TestSubsystem& test() const { return test_; }    
    
    VlbiSubsystem& vlbi() const { return vlbi_; }
    
    WbDataflowSubsystem & wbDataflow(const int index) const 
    { 
        return *( wbDataflow_.at(index) ); 
    }

    WbRemapperSubsystem & wbRemapper(const int index) const 
    { 
        return *( wbRemapper_.at(index) ); 
    }

    SlDataflowSubsystem & slDataflow(const int index) const 
    { 
        return *( slDataflow_.at(index) );
    }

    C3gDataflowSubsystem & c3gDataflow(const int index) const 
    { 
        return *( c3gDataflow_.at(index) );
    }

    SlRemapperSubsystem & slRemapper(const int index) const 
    { 
        return *( slRemapper_.at(index) ); 
    }

    C3gRemapperSubsystem & c3gRemapper(const int index) const 
    { 
        return *( c3gRemapper_.at(index) ); 
    }

    SystemFrameBuffer& systemFrameBuffer() const { return systemFrameBuffer_; }

    virtual std::string transportStatisticsToString (bool canonical = false) const;

    std::string addTransportTimesAsString (std::ostringstream o) const ;

    bool isCurrent () const;

    long getNumValidSubsystems () const;

    void resetQueue () ;

    /*
     * Overridden methods of abstract MonitorSystemContainer methods.
     * Documentation supplied by base class.
     */
    virtual unsigned int read();
    virtual bool readNewest();
    virtual bool readNewestIfStale();
    virtual bool readNewestConditionalCopy();
    virtual void write();
    virtual int getFrameCount() const;

    double getCollatorWriteDelay() const;

    double getCollatorWriteTime() const;
               
    void setRawReadTime( double mjdTimestamp );
    void setRawReadTime( );
               
    double getRawReadTime() const;
               
    void setFinalWriteTime( double mjdTimestamp );
    void setFinalWriteTime( );
               
    double getFinalWriteTime() const;
               
    void   resetTimes ();

   long    getTotalNumSubsystems() const;

   long    getTotalNumMonitorPoints() const;

   long    getTotalNumMonitorSamples() const;

   size_t    getTotalMonitorSystemSize() const;

   long    getMaxNumMonitorPoints() const;

   long    getMaxNumMonitorSamples() const;

   size_t    getMaxMonitorSystemSize() const;

   long    getActualNumSubsystems() const;

   long    getActualNumMonitorPoints() const;

   long    getActualNumMonitorPoints (const MonitorValueType type) const;

   long    getActualNumMultiSampleMonitorPoints() const;

   long    getActualNumMonitorSamples() const;

   long    getActualNumMonitorSamples (MonitorValueType type) const;

   size_t    getActualMonitorSystemSize() const;

   long    getAllocatedNumSubsystems() const;

   long    getAllocatedNumMonitorPoints() const;

   long    getAllocatedNumMonitorSamples() const;

   size_t    getAllocatedMonitorSystemSize() const;

   long    getCountedNumMonitorPoints() const;

   long    getCountedNumMonitorSamples() const;

   size_t    getCountedMonitorSystemSize() const;

   SystemFrameBuffer&    getSystemFrameBuffer() const;

   MonitorSubsystem & getChildSubsystem( int index ) const;

protected:

    SubsystemFrame & getChildSubsystemFrame( int index ) const;

private:
    /* Storage
     * Order of construction is critical - storage (in the form of
     * SystemFrameBuffer) must be constructed first, or the subsystems
     * will not have space to exist, and construction of all 
     * subsequent members will fail.
     * The order of storage intialization is determined by the order
     * of declaration below, *not* by the order of the constructor
     * initialization list.
     */
    SystemFrameBuffer&      systemFrameBuffer_;
        
    // Subsystems
    AstroSubsystem&             astro_;
    std::vector<BimaSubsystem*> bimas_;
    C3gMax8PipelineSubsystem&   c3gMax8Pipeline_;  
    C3gMax23PipelineSubsystem&  c3gMax23Pipeline_;  
    CentralIfSubsystem&         centralIf_;
    ControlSubsystem&           control_;
    DataflowSubsystem&          dataflow_;
    DelayEngineSubsystem&       delayEngine_;
    ImrSubsystem&               imr_;
    AlarmSubsystem&             alarm_;
    LineLengthSubsystem&        lineLength_;
    LoberotatorSubsystem&       loberotator_;
    LoRefSubsystem&             loRef_;
    MasterClockSubsystem&       masterclock_;
    OpacityMonitorSubsystem&    opacityMonitor_;
    std::vector<OvroSubsystem*> ovros_;
    PhaseMonitorSubsystem&   phaseMonitor_;
    ProjectDatabaseManagerSubsystem& projectDatabaseManager_;
    ::std::vector< CarmaSlcBandSubsystem * > carmaSlcBands_;
    ::std::vector< Carma3GBandSubsystem * > carma3gBands_;
    SignalPathSubsystem &    signalPath_;
    SldcSubsystem&           sldc_;
    SlPipelineSubsystem&     slPipeline_;
    SystemStatusSubsystem&   systemStatus_;
    ::std::vector< SzaSubsystem * > szas_;
    TestSubsystem&           test_;
    VlbiSubsystem&           vlbi_;
    ::std::vector< WbcBandSubsystem * > wbcBands_;
    WbdcSubsystem&           wbdc_;
    WbPipelineSubsystem&     wbPipeline_;
    WeatherSubsystem&        weather_;
    FaultSubsystem &         fault_;
    ::std::vector< WbDataflowSubsystem * > wbDataflow_;
    ::std::vector< SlDataflowSubsystem * > slDataflow_;
    ::std::vector< C3gDataflowSubsystem * > c3gDataflow_;
    ::std::vector< WbRemapperSubsystem * > wbRemapper_;
    ::std::vector< SlRemapperSubsystem * > slRemapper_;
    ::std::vector< C3gRemapperSubsystem * > c3gRemapper_;
};


//------------------------------------------------------------------


class RawCarmaMonitorSystem;

class CarmaMonitorSystem : public MonitorSystem {
protected:

    CarmaMonitorSystem( std::string name,
                        int queueDepth );

public:

    CarmaMonitorSystem( );


    explicit CarmaMonitorSystem(const RawCarmaMonitorSystem& raw) ;

    void   synchronize (const CarmaMonitorSystem& src) ;

};

class RawCarmaMonitorSystem : public CarmaMonitorSystem {

public:

    RawCarmaMonitorSystem( );

};

class FinalCarmaMonitorSystem : public CarmaMonitorSystem {
public:

    FinalCarmaMonitorSystem( );
};




} }  // End namespace carma::monitor  


inline carma::monitor::FaultSubsystem &
carma::monitor::MonitorSystem::fault( ) const
{
    return fault_;
}


#endif