CorrelatorBaseline.h

Go to the documentation of this file.

#ifndef CORRELATORBASELINE_H
#define CORRELATORBASELINE_H

#include <vector>
#include "carma/util/Serializable.h"
#include "carma/monitor/MonitorPoint.h"
#include "carma/correlator/lib/CorrelatorSideband.h"
#include "carma/correlator/lib/CorrelatorPolarization.h"

namespace carma {
  namespace correlator {
    namespace lib {

      class CorrelatorBaseline;

      typedef ::std::vector< CorrelatorBaseline > BaselineVector;

      class CorrelatorBaseline : public carma::util::Serializable {
      public:

        explicit CorrelatorBaseline();

        CorrelatorBaseline( const CorrelatorBaseline & rhs );

        virtual ~CorrelatorBaseline();

        void swap( CorrelatorBaseline & rhs );

        void mySerialize( char * byteArray, int * offset ) const;

        void deserializeVer0( const char * byteArray, 
                              int * offset, 
                              int byteArraySize );

        void deserializeVer1( const char * byteArray, 
                              int * offset, 
                              int byteArraySize );

        void deserializeSwapVer0( const char * byteArray, 
                                  int * offset,
                                  int byteArraySize );

        void deserializeSwapVer1( const char * byteArray, 
                                  int * offset,
                                  int byteArraySize );

        void normalize();

        int getSizeInBytes() const;

        void setInput1Number(int i1num);

        void setAnt1Number(int a1num);
        int getInput1Number() const;

        int getAnt1Number() const;

        void setInput2Number(int i2num);

        void setAnt2Number(int a2num);

        int getInput2Number() const;

        int getAnt2Number() const;

        void setBoardId(int boardId);

        int getBoardId() const;

        void setBoardSN(int boardSN);

        int getBoardSN() const;

        int getNumberOfSidebands() const;

        void addSideband(const carma::correlator::lib::CorrelatorSideband & sb);

        const carma::correlator::lib::CorrelatorSideband &
          getUpperSideband() const;

        const carma::correlator::lib::CorrelatorSideband &
          getLowerSideband() const;

        const carma::correlator::lib::CorrelatorSideband &
          getAutoSideband() const;

        const std::vector<carma::correlator::lib::CorrelatorSideband> &
          getSidebands() const;

        std::vector<carma::correlator::lib::CorrelatorSideband> &
          getSidebands();

        void flagData( unsigned int reason );

        void blankData( unsigned int reason );

        // Deprecated - underlying data is no longer set.
        carma::monitor::MonitorPoint::BLANKING_FLAGGING
          getBlankFlagStatusDEPRECATED() const;

        bool isValid( ) const;


        friend bool operator==( const CorrelatorBaseline & lhs,
                                const CorrelatorBaseline & rhs ) {
          return (lhs.getInput1Number() == rhs.getInput1Number() &&
                  lhs.getInput2Number() == rhs.getInput2Number());
        }

        CorrelatorBaseline & operator=( const CorrelatorBaseline & rhs );

        void addIn( const CorrelatorBaseline & rhs );

        void setAntPol1( int antNum, carma::correlator::lib::Polarization polarization );

        void setAntPol2( int antNum, carma::correlator::lib::Polarization polarization );

        Polarization getPolarization1() const;

        Polarization getPolarization2() const;

        std::string getPolarization1String() const;

        std::string getPolarization2String() const;

        std::string getPolarization() const;

    AntNoPolPair getAntPol1() const;
    AntNoPolPair getAntPol2() const;

    std::string getSummary() const;
    

    bool containsSideband( CorrelatorSideband::Flavor flavor ) const;
      
private:
        carma::correlator::lib::CorrelatorSideband & 
        getSideband( CorrelatorSideband::Flavor flavor );

        void packSidebands( char * byteArray, int * offset ) const;
        void assign(const CorrelatorBaseline& cb);

        void setPolarization1( const carma::correlator::lib::Polarization polarization );

        void setPolarization2( const carma::correlator::lib::Polarization polarization );

        int                                      ant1Number_;
        int                                      ant2Number_;
        int                                      input1Number_;
        int                                      input2Number_;
        int                                      boardId_;
        int                                      boardSN_;
        carma::correlator::lib::Polarization     polarization1_;
        carma::correlator::lib::Polarization     polarization2_;

        monitor::MonitorPoint::BLANKING_FLAGGING bfStatusObsolete_;
        ::std::vector< CorrelatorSideband >    sidebands_;
      }; // End class CorrelatorBaseline

    } // End namespace lib
  } // End namespace correlator
} // End namespace carma


inline
carma::correlator::lib::CorrelatorBaseline::CorrelatorBaseline( ) :
ant1Number_( -1 ),
ant2Number_( -1 ),
input1Number_( 0 ),
input2Number_( 0 ),
boardId_( 0 ),
boardSN_( 0 ),
polarization1_(RIGHT_POL),
polarization2_(RIGHT_POL),
bfStatusObsolete_( monitor::MonitorPoint::OK ),
sidebands_()
{
}


inline void
carma::correlator::lib::CorrelatorBaseline::swap( CorrelatorBaseline & rhs )
{
    ::std::swap( ant1Number_, rhs.ant1Number_ );
    ::std::swap( ant2Number_, rhs.ant2Number_ );
    ::std::swap( input1Number_, rhs.input1Number_ );
    ::std::swap( input2Number_, rhs.input2Number_ );
    ::std::swap( boardId_, rhs.boardId_ );
    ::std::swap( boardSN_, rhs.boardSN_ );
    ::std::swap( bfStatusObsolete_, rhs.bfStatusObsolete_ );
    sidebands_.swap( rhs.sidebands_ );
    ::std::swap( polarization1_, rhs.polarization1_ );
    ::std::swap( polarization2_, rhs.polarization2_ );
}


inline int
carma::correlator::lib::CorrelatorBaseline::getInput1Number( ) const
{
    return input1Number_;
}

inline int
carma::correlator::lib::CorrelatorBaseline::getAnt1Number( ) const
{
    return ant1Number_;
}

inline int
carma::correlator::lib::CorrelatorBaseline::getInput2Number( ) const
{
    return input2Number_;
}

inline int
carma::correlator::lib::CorrelatorBaseline::getAnt2Number( ) const
{
    return ant2Number_;
}

inline int
carma::correlator::lib::CorrelatorBaseline::getBoardId( ) const
{
    return boardId_;
}


inline int
carma::correlator::lib::CorrelatorBaseline::getBoardSN( ) const
{
    return boardSN_;
}


inline int
carma::correlator::lib::CorrelatorBaseline::getNumberOfSidebands( ) const
{
    return sidebands_.size();
}

inline carma::monitor::MonitorPoint::BLANKING_FLAGGING
carma::correlator::lib::CorrelatorBaseline::getBlankFlagStatusDEPRECATED( ) const
{
    return bfStatusObsolete_;
}

inline const ::std::vector< carma::correlator::lib::CorrelatorSideband > &
carma::correlator::lib::CorrelatorBaseline::getSidebands( ) const
{
    return sidebands_;
}


inline ::std::vector< carma::correlator::lib::CorrelatorSideband > &
carma::correlator::lib::CorrelatorBaseline::getSidebands( )
{
    return sidebands_;
}


inline void
carma::correlator::lib::CorrelatorBaseline::setInput1Number( const int i1num )
{
    input1Number_ = i1num;
}

inline void
carma::correlator::lib::CorrelatorBaseline::setAnt1Number( const int a1num )
{
    ant1Number_ = a1num;
}

inline void
carma::correlator::lib::CorrelatorBaseline::setInput2Number( const int i2num )
{
    input2Number_ = i2num;
}

inline void
carma::correlator::lib::CorrelatorBaseline::setAnt2Number( const int a2num )
{
    ant2Number_ = a2num;
}

inline void
carma::correlator::lib::CorrelatorBaseline::setBoardId( const int boardId )
{
    boardId_ = boardId;
}

inline void
carma::correlator::lib::CorrelatorBaseline::setBoardSN( const int boardSN )
{
    boardSN_ = boardSN;
}

inline void 
carma::correlator::lib::CorrelatorBaseline::flagData( unsigned int reason )
{
    for( unsigned int i = 0; i < sidebands_.size(); i++ ) {
        sidebands_.at(i).flagData( reason );
    }
}

inline void 
carma::correlator::lib::CorrelatorBaseline::blankData( unsigned int reason )
{
    for( unsigned int i = 0; i < sidebands_.size(); i++ ) {
        sidebands_.at(i).blankData( reason );
    }
}

inline void
carma::correlator::lib::CorrelatorBaseline::setPolarization1(
    const carma::correlator::lib::Polarization polarization)
{
  polarization1_ = polarization;
}

inline void
carma::correlator::lib::CorrelatorBaseline::setPolarization2(
    const carma::correlator::lib::Polarization polarization)
{
  polarization2_ = polarization;
}

inline void 
carma::correlator::lib::CorrelatorBaseline::setAntPol1(
           const int antNum, const carma::correlator::lib::Polarization polarization ){
  setAnt1Number(antNum);
  setPolarization1(polarization);
}

inline void 
carma::correlator::lib::CorrelatorBaseline::setAntPol2(
           const int antNum, const carma::correlator::lib::Polarization polarization ){
  setAnt2Number(antNum);
  setPolarization2(polarization);
}

inline carma::correlator::lib::Polarization
carma::correlator::lib::CorrelatorBaseline::getPolarization1( ) const
{
  return polarization1_;
}


inline carma::correlator::lib::Polarization
carma::correlator::lib::CorrelatorBaseline::getPolarization2( ) const
{
  return polarization2_;
}

inline carma::correlator::lib::AntNoPolPair
carma::correlator::lib::CorrelatorBaseline::getAntPol1( ) const
{
    return AntNoPolPair( ant1Number_, polarization1_ );
}

inline carma::correlator::lib::AntNoPolPair
carma::correlator::lib::CorrelatorBaseline::getAntPol2( ) const
{
    return AntNoPolPair( ant2Number_, polarization2_ );
}

inline std::string
carma::correlator::lib::CorrelatorBaseline::getPolarization1String( ) const
{
  if(polarization1_ == LEFT_POL){
    return "L";
  }
  else if(polarization1_ == RIGHT_POL){
    return "R";
  }
  else if(polarization1_ == HORIZONTAL_POL){
    return "X";
  }
  else if(polarization1_ == VERTICAL_POL){
    return "Y";
  }
  return "NONE";
}

inline std::string
carma::correlator::lib::CorrelatorBaseline::getPolarization2String( ) const
{
  if(polarization2_ == LEFT_POL){
    return "L";
  }
  else if(polarization2_ == RIGHT_POL){
    return "R";
  }
  else if(polarization2_ == HORIZONTAL_POL){
    return "X";
  }
  else if(polarization2_ == VERTICAL_POL){
    return "Y";
  }
  return "NONE";
}

inline std::string
carma::correlator::lib::CorrelatorBaseline::getPolarization( ) const
{
  std::string output = "";
  if(polarization1_ == LEFT_POL){
    output += "L";
  }
  else if(polarization1_ == RIGHT_POL){
    output += "R";
  }
  else if(polarization1_ == HORIZONTAL_POL){
    output += "X";
  }
  else if(polarization1_ == VERTICAL_POL){
    output += "Y";
  }
  else{
    return "NONE";
  }
  if(polarization2_ == LEFT_POL){
    output += "L";
  }
  else if(polarization2_ == RIGHT_POL){
    output += "R";
  }
  else if(polarization2_ == HORIZONTAL_POL){
    output += "X";
  }
  else if(polarization2_ == VERTICAL_POL){
    output += "Y";
  }
  else{
    return "NONE";
  }
  return output;
}

#endif