AlgAdapt.cxx

Go to the documentation of this file.

// $Id: AlgAdapt.cxx,v 1.7 2008/01/17 18:09:03 rustem Exp $

// C/C++
#include <cassert>
#include <iomanip>
#include <iostream>

// MINOS
#include "Registry/Registry.h"
#include "Util/UtilString.h"

// Local
#include "AlgAdapt.h"

using namespace std;

//---------------------------------------------------------------------------------
Anp::AlgAdapt::AlgAdapt()
{
}

//---------------------------------------------------------------------------------
Anp::AlgAdapt::~AlgAdapt()
{
}

//------------------------------------------------------------------------------------------
long double Anp::AlgAdapt::GetPT() const
{
   if(fCurPar.size() != fDefPar.size() || fCurPar.size() != fDefErr.size())
   {
      cerr << "AlgAdapt::GetPT - parameter and/or error vectors have different size" << endl;
      return 0.0;
   }

   long double pterm = 0.0;

   for(unsigned int ipar = 0; ipar < fCurPar.size(); ++ipar)
   {
      const double cur_par = fCurPar[ipar];
      const double def_par = fDefPar[ipar];
      const double def_err = fDefErr[ipar];

      if(def_err > 0.0)
      {
         pterm += (cur_par - def_par)*(cur_par - def_par)/(def_err*def_err);
      }
      else
      {
         cerr << "AlgAdapt::GetPT - default error values are not positive" << endl;
      }      
   }

   return pterm;
}

//---------------------------------------------------------------------------------
const vector<double>& Anp::AlgAdapt::Get(const string &key) const
{
   if(key == "CurErr")
   {
      return fCurErr;
   }
   else if(key == "CurPar")
   {
      return fCurPar;
   }
   else if(key == "DefErr")
   {
      return fDefErr;
   }
   else if(key == "DefPar")
   {
      return fDefPar;
   }
   
   cerr << "AlgAdapt::Get - unknown key: " << key << endl;
   
   assert(false && "unknown key");

   return fCurPar;
}

//---------------------------------------------------------------------------------
void Anp::AlgAdapt::Set(const vector<double> &dvec, const string &key)
{
   if(dvec.size() != GetNPar())
   {
      cerr << "AlgAdapt::Set - number of parameters and size of input vector do not match: " 
           << " GetNPar() = " << GetNPar() << " and dvec.size() = " << dvec.size() << endl;
      return;
   }

   if(key == "CurErr")
   {
      fCurErr = dvec;
      return;
   }
   else if(key == "CurPar")
   {
      fCurPar = dvec;
      return;
   }
   else if(key == "DefErr")
   {
      fDefErr = dvec;
      return;
   }
   else if(key == "DefPar")
   {
      fDefPar = dvec;
      return;
   }
   
   cerr << "AlgAdapt::Set - unknown key: " << key << endl;

   assert(false && "unknown key");
}

//---------------------------------------------------------------------------------
void Anp::AlgAdapt::ReadVec(const string &prefix, const Registry &reg)
{
   //
   // Read in default and and current error and parameter vectors from
   // Registry, if these keys exist in Registry. Use virtual functions Set()
   // to set parameter values.
   //

   const vector<double> pvec = GetVec(prefix + "Par", reg);
   if(!pvec.empty())
   {
      Set(pvec, "CurPar");
   }

   const vector<double> evec = GetVec(prefix + "Err", reg);
   if(!evec.empty())
   {
      Set(evec, "CurErr");
   }

   const vector<double> evec_def = GetVec(prefix + "DefErr", reg);
   if(!evec_def.empty())
   {
      Set(evec_def, "DefErr");
   }

   const vector<double> pvec_def = GetVec(prefix + "DefPar", reg);
   if(!pvec_def.empty())
   {
      Set(pvec_def, "DefPar");
   }

   const vector<double> pvec_cur = GetVec(prefix + "CurPar", reg);
   if(!pvec_cur.empty())
   {
      Set(pvec_cur, "CurPar");
   }

   const vector<double> evec_cur = GetVec(prefix + "CurErr", reg);
   if(!evec_cur.empty())
   {
      Set(evec_cur, "CurErr");
   }
}

//---------------------------------------------------------------------------------
const vector<double> Anp::AlgAdapt::GetVec(const string &key, const Registry &reg) const
{
   //
   // Extract Registry value stored at key and convert string numbers separated by
   // " " or "," or both to vector of doubles.
   //
 
   vector<double> dvec;
   
   const char *value_char = 0;
   if(!reg.Get(key.c_str(), value_char) || !value_char)
   {
      return dvec;
   }

   vector<string> svec;

   UtilString::StringTok(svec, string(value_char), ", ");
   
   dvec = vector<double>(svec.size(), 0.0);

   for(unsigned int i = 0; i < svec.size(); ++i)
   {
      if(!svec[i].empty())
      {
         dvec[i] = std::atof(svec[i].c_str());
      }
   }

   return dvec;
}

//------------------------------------------------------------------------------------------
void Anp::AlgAdapt::PrintVec(std::ostream &o, const int w, const int p) const
{
   if(!fCurPar.empty())
   {
      o << "   CurPar = ";
      PrintVec(fCurPar, o, w, p);
   }
   
   if(!fCurErr.empty())
   {
      o << "   CurErr = ";
      PrintVec(fCurErr, o, w, p);
   }
   
   if(!fDefPar.empty())
   {
      o << "   DefPar = ";
      PrintVec(fDefPar, o, w, p);
   }
   
   if(!fDefErr.empty())
   {
      o << "   DefErr = ";
      PrintVec(fDefErr, o, w, p);
   }
}

//---------------------------------------------------------------------------------
void Anp::AlgAdapt::PrintVec(const vector<double> &v, ostream &o, const int w, const int p) const
{
   for(unsigned int i = 0; i < v.size(); ++i)
   {
      if(i == 0)
      {
         o << "(";
      }
      else
      {
         o << ", ";
      }
      
      if(p > 0)
      {
         o << setprecision(p);
      }
      if(w > 0)
      {
         o << setw(w);
      }

      o << v[i];
      
      if(i + 1 == v.size())
      {
         o << ")";
      }
   }

   o << endl;
}

//---------------------------------------------------------------------------------
void Anp::AlgAdapt::Print(std::ostream &os) const
{
   os << "AlgAdapt::Print - this function is not implemented for this class" << endl;
}

---