Antenna.hpp

Go to the documentation of this file.

#pragma ident "$Id: Antenna.hpp 1769 2009-03-04 08:03:19Z architest $"

#ifndef GPSTK_ANTENNA_HPP
#define GPSTK_ANTENNA_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk 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 GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  Dagoberto Salazar - gAGE ( http://www.gage.es ). 2009
//
//============================================================================


#include <cmath>
#include <vector>
#include <map>
#include <string>

#include "Exception.hpp"
#include "DayTime.hpp"
#include "Triple.hpp"



namespace gpstk
{


   class Antenna
   {
   public:

      enum frequencyType
      {
         G01,                    
         G02,                    
         G05,                    
         R01,                    
         R02,                    
         E01,                    
         E05,                    
         E07,                    
         E08,                    
         E06                     
      };


      enum AntennaDataType
      {
         antennaType,         
         antennaRadome,       
         serial,              
         cnnn,                
         cosparID,            
         calMethod,           
         agency,              
         numAntennas,         
         date,                
         sinexCode            
      };


         // Handy type definitions

      typedef std::map< AntennaDataType, std::string > AntennaDataMap;

      typedef std::map< frequencyType, Triple > AntennaEccDataMap;

      typedef std::map< frequencyType, std::vector<double> > NoAziDataMap;

      typedef std::map< double, std::vector<double> > AzimuthDataMap;

      typedef std::map< frequencyType, AzimuthDataMap > PCDataMap;



      Antenna() {};


      Antenna( const Triple& eccL1,
               const Triple& eccL2 );


      Antenna( double NorthEccL1,
               double EastEccL1,
               double UpEccL1,
               double NorthEccL2,
               double EastEccL2,
               double UpEccL2 );


      Triple getAntennaEccentricity( frequencyType freq ) const
         throw(InvalidRequest);


      Triple getAntennaPCVariation( frequencyType freq,
                                    double elevation ) const
         throw(InvalidRequest);


      Triple getAntennaPCVariation( frequencyType freq,
                                    double elevation,
                                    double azimuth ) const
         throw(InvalidRequest);


      std::string getAntennaData( AntennaDataType dataType ) const
         throw(InvalidRequest);


      Antenna setAntennaData( AntennaDataType dataType,
                              const std::string& data )
      { antennaData[dataType] = data; return (*this); };


      std::string getAntennaType() const
         throw(InvalidRequest)
      { return getAntennaData( antennaType ); };


      Antenna setAntennaType( const std::string& type )
      { return setAntennaData( antennaType, type ); };


      std::string getAntennaRadome() const
         throw(InvalidRequest)
      { return getAntennaData( antennaRadome ); };


      Antenna setAntennaRadome( const std::string& radome )
      { return setAntennaData( antennaRadome, radome ); };


      std::string getAntennaSerial() const
         throw(InvalidRequest)
      { return getAntennaData(serial); };


      Antenna setAntennaSerial( const std::string& sn )
      { return setAntennaData( serial, sn ); };


      std::string getAntennaCalMethod() const
         throw(InvalidRequest)
      { return getAntennaData(calMethod); };


      Antenna setAntennaCalMethod( const std::string& method )
      { return setAntennaData( calMethod, method ); };


      DayTime getAntennaValidFrom() const
      { return validFrom; };


      Antenna setAntennaValidFrom( const DayTime& valFrom )
      { validFrom = valFrom; return (*this); };


      DayTime getAntennaValidUntil() const
      { return validUntil; };


      Antenna setAntennaValidUntil( const DayTime& valUntil )
      { validUntil = valUntil; return (*this); };


      double getDazi() const
      { return dazi; };


      Antenna setDazi( double daz )
      { dazi = daz; return (*this); };


      double getZen1() const
      { return zen1; };


      Antenna setZen1( double z1 )
      { zen1 = z1; return (*this); };


      double getZen2() const
      { return zen2; };


      Antenna setZen2( double z2 )
      { zen2 = z2; return (*this); };


      double getDzen() const
      { return dzen; };


      Antenna setDzen( double dz )
      { dzen = dz; return (*this); };


      int getNumFreq() const
      { return numFreq; };


      Antenna setNumFreq( int nFreq )
      { numFreq = nFreq; return (*this); };


      AntennaDataMap getAntennaDataMap() const
      { return antennaData; };


      Antenna setAntennaDataMap( const AntennaDataMap& dataMap )
      { antennaData = dataMap; return (*this); };


      std::vector<std::string> getAntennaComments() const
      { return commentList; };


      Antenna setAntennaComments( const std::vector<std::string>& comments )
      { commentList = comments; return (*this); };


      Antenna addAntennaComments( std::string comments )
      { commentList.push_back(comments); return (*this); };


      AntennaEccDataMap getAntennaEccMap() const
      { return antennaEccMap; };


      Antenna setAntennaEccMap( const AntennaEccDataMap& eccMap )
      { antennaEccMap = eccMap; return (*this); };


      Antenna addAntennaEcc( frequencyType freq,
                             const Triple& trEcc )
      { antennaEccMap[freq] = trEcc; return (*this); };


      Antenna addAntennaEcc( frequencyType freq,
                              double northEcc,
                              double eastEcc,
                              double upEcc );


      AntennaEccDataMap getAntennaRMSEccMap() const
      { return antennaRMSEccMap; };


      Antenna setAntennaRMSEccMap(const AntennaEccDataMap& eccRMSMap)
      { antennaRMSEccMap = eccRMSMap; return (*this); };


      Antenna addAntennaRMSEcc( frequencyType freq,
                                double northRMS,
                                double eastRMS,
                                double upRMS );


      NoAziDataMap getAntennaNoAziMap() const
      { return noAziMap; };


      Antenna setAntennaNoAziMap( const NoAziDataMap& naMap )
      { noAziMap = naMap; return (*this); };


      Antenna addAntennaNoAziPattern( frequencyType freq,
                                      const std::vector<double>& pcVec )
      { noAziMap[freq] = pcVec; return (*this); };


      PCDataMap getAntennaPCMap() const
      { return pcMap; };


      Antenna setAntennaPCMap( const PCDataMap& pMap )
      { pcMap = pMap; return (*this); };


      Antenna addAntennaPattern( frequencyType freq,
                                 double azi,
                                 const std::vector<double>& pcVec )
      { pcMap[freq][azi] = pcVec; return (*this); };


      NoAziDataMap getAntennaNoAziRMSMap() const
      { return noAziRMSMap; };


      Antenna setAntennaNoAziRMSMap( const NoAziDataMap& naRMSMap )
      { noAziRMSMap = naRMSMap; return (*this); };


      Antenna addAntennaNoAziRMS( frequencyType freq,
                                  const std::vector<double>& pcRMS )
      { noAziRMSMap[freq] = pcRMS; return (*this); };


      PCDataMap getAntennaPCRMSMap() const
      { return pcRMSMap; };


      Antenna setAntennaPCRMSMap( const PCDataMap& pRMSMap )
      { pcRMSMap = pRMSMap; return (*this); };


      Antenna addAntennaPatternRMS( frequencyType freq,
                                    double azi,
                                    const std::vector<double>& pcRMSVec )
      { pcRMSMap[freq][azi] = pcRMSVec; return (*this); };


      int getAntennaDataSize() const
      { return antennaData.size(); };


      int getAntennaEccMapSize() const
      { return antennaEccMap.size(); };


      int getNoAziMapSize() const
      { return noAziMap.size(); };


      int getPCMapSize() const
      { return pcMap.size(); };


      bool isValid() const;


      virtual ~Antenna() {};


   private:


      AntennaDataMap antennaData;


      double dazi;                     

      double zen1;                     
      double zen2;                     
      double dzen;                     

      int numFreq;                     

      DayTime validFrom;               
      DayTime validUntil;              

      std::vector<std::string> commentList;      


      AntennaEccDataMap antennaEccMap;


      NoAziDataMap noAziMap;


      PCDataMap pcMap;


      AntennaEccDataMap antennaRMSEccMap;


      NoAziDataMap noAziRMSMap;


      PCDataMap pcRMSMap;


      double linearInterpol( const std::vector<double>& dataVector,
                             double normalizedAngle ) const;


   }; // End of class 'Antenna'



}  // End of namespace gpstk

#endif   // GPSTK_ANTENNA_HPP

---