Equation.hpp

Go to the documentation of this file.

#pragma ident "$Id: Equation.hpp 3140 2012-06-18 15:03:02Z susancummins $"

#ifndef GPSTK_EQUATION_HPP
#define GPSTK_EQUATION_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., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  Dagoberto Salazar - gAGE ( http://www.gage.es ). 2007, 2008, 2009, 2011
//
//============================================================================



#include "DataStructures.hpp"
#include "StochasticModel.hpp"
#include "Variable.hpp"


namespace gpstk
{



   struct equationHeader
   {

      SourceID equationSource;


      SatID equationSat;


      std::set<SourceID> equationSourceSet;
      

      std::set<SatID> equationSatSet;


      Variable indTerm;


      double constWeight;


      equationHeader()
         : equationSource(Variable::allSources), equationSat(Variable::allSats),
           constWeight(1.0) {};


      equationHeader( const SourceID& source,
                      const SatID& sat,
                      const Variable indep,
                      const double& cweight )
         : equationSource(source), equationSat(sat), indTerm(indep),
           constWeight(cweight) {};


      equationHeader(const Variable& indep)
         : equationSource(Variable::allSources), equationSat(Variable::allSats),
           indTerm(indep), constWeight(1.0) {};


      virtual equationHeader& operator=(const equationHeader& right);


      virtual equationHeader& operator=(const Variable& indep)
      { indTerm = indep; return (*this); };


      virtual ~equationHeader() {};


   }; // End of struct 'equationHeader'



   struct Equation : gnssData<equationHeader, VariableSet>
   {

      Equation();


      Equation( const equationHeader& head )
      { header = head; };


      Equation( const Variable& indep );


      Equation( const TypeID& type );


      Equation( const gnssEquationDefinition& gnssEq );


      virtual Variable getIndependentTerm() const
      { return header.indTerm; };


      virtual Equation& setIndependentTerm(const Variable& var)
      { header = var; return (*this); };


      virtual double getWeight() const
      { return header.constWeight; };


      virtual Equation& setWeight(const double& cweight)
      { header.constWeight = cweight; return (*this); };


      virtual Equation& addVariable(const Variable& var)
      { body.insert(var); return (*this); };


      virtual Equation& addVariable( const TypeID& type,
                                     StochasticModel* pModel   =
                                                      &Variable::defaultModel,
                                     bool sourceIndexed        = true,
                                     bool satIndexed           = false,
                                     double variance           = 4.0e14,
                                     double coef               = 1.0 );


      virtual Equation& removeVariable(const Variable& var)
      { body.erase(var); return (*this); };


      virtual Equation& clear()
      { body.clear(); return (*this); };


      SourceID getEquationSource() const
      { return header.equationSource; };

      SatID getEquationSat() const
      { return header.equationSat; };


      std::set<SourceID> getSourceSet() const
      { return header.equationSourceSet; };
      

      std::set<SatID> getSatSet() const
      { return header.equationSatSet; };


      Equation& addSource2Set( const SourceID& source )
      { header.equationSourceSet.insert(source); return (*this); };

      
      Equation& addSat2Set( const SatID& sat )
      { header.equationSatSet.insert(sat); return (*this); };


      Equation& clearSourceSet()
      { header.equationSourceSet.clear(); return (*this); };


      Equation& clearSatSet()
      { header.equationSatSet.clear(); return (*this); };


      virtual bool operator<(const Equation& right) const
      { return (header.indTerm < right.header.indTerm); };


      virtual ~Equation() {};


   }; // End of struct 'Equation'


   namespace StringUtils
   {
      inline std::string asString(const VariableSet& vset)
      {
         std::ostringstream oss;
         for( VariableSet::const_iterator it = vset.begin();
              it != vset.end();
              ++it )
         {
            oss << it->getType() << "   "
                << it->getSource() << "   "
                << it->getSatellite() << "   "
                << it->getTypeIndexed() << " "
                << it->getSourceIndexed() << " "
                << it->getSatIndexed()<< std::endl;
         }
         
         return oss.str();
      }
   }


}  // End of namespace gpstk

#endif   // GPSTK_EQUATION_HPP

---