Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

Anp::AlgAdapt Class Reference

#include <AlgAdapt.h>

Inheritance diagram for Anp::AlgAdapt:

Anp::Base List of all members.

Public Member Functions

 AlgAdapt ()
virtual ~AlgAdapt ()
virtual bool Init ()=0
virtual long double GetPT () const
virtual unsigned int GetNPar () const =0
virtual void InitReco (RecoNu &) const
virtual void InitTrue (TrueNu &) const
virtual double GetWeight (const TrueNu &) const
virtual void Vary (RecoNu &, const TrueNu &) const
virtual const std::vector<
double > & 		Get (const std::string &key) const
virtual void Set (const std::vector< double > &dvec, const std::string &key)
virtual const std::vector<
std::string > & 		GetParName () const
virtual void Config (const Registry &)=0
virtual void Print (std::ostream &os=std::cout) const
virtual void Read (const std::string &fname)
virtual void Save (const std::string &fname)

Protected Member Functions

void ReadVec (const std::string &prefix, const Registry &reg)
const std::vector< double > GetVec (const std::string &key, const Registry &reg) const
void PrintVec (std::ostream &o, int w=7, int p=5) const
void PrintVec (const std::vector< double > &v, std::ostream &o, int w=7, int p=5) const

Protected Attributes

std::vector< double > fCurErr
std::vector< double > fCurPar
std::vector< double > fDefErr
std::vector< double > fDefPar
std::vector< std::string > fParName

Constructor & Destructor Documentation

Anp::AlgAdapt::AlgAdapt (   ) 
 

Definition at line 19 of file AlgAdapt.cxx.

00020 {
00021 }

Anp::AlgAdapt::~AlgAdapt (   )  [virtual]
 

Definition at line 24 of file AlgAdapt.cxx.

00025 {
00026 }

Member Function Documentation

virtual void Anp::AlgAdapt::Config (  const Registry &   )  [pure virtual]
 

const vector< double > & Anp::AlgAdapt::Get (  const std::string &  key  )  const [virtual]
 

Definition at line 59 of file AlgAdapt.cxx.

00060 {
00061    if(key == "CurErr")
00062    {
00063       return fCurErr;
00064    }
00065    else if(key == "CurPar")
00066    {
00067       return fCurPar;
00068    }
00069    else if(key == "DefErr")
00070    {
00071       return fDefErr;
00072    }
00073    else if(key == "DefPar")
00074    {
00075       return fDefPar;
00076    }
00077    
00078    cerr << "AlgAdapt::Get - unknown key: " << key << endl;
00079    
00080    assert(false && "unknown key");
00081 
00082    return fCurPar;
00083 }

virtual unsigned int Anp::AlgAdapt::GetNPar (   )  const [pure virtual]
 

Referenced by Set().

const std::vector< std::string > & Anp::AlgAdapt::GetParName (   )  const [inline, virtual]
 

Definition at line 101 of file AlgAdapt.h.

00102    {
00103       return fParName;
00104    }

long double Anp::AlgAdapt::GetPT (   )  const [virtual]
 

Definition at line 29 of file AlgAdapt.cxx.

References fCurPar, fDefErr, and fDefPar.

00030 {
00031    if(fCurPar.size() != fDefPar.size() || fCurPar.size() != fDefErr.size())
00032    {
00033       cerr << "AlgAdapt::GetPT - parameter and/or error vectors have different size" << endl;
00034       return 0.0;
00035    }
00036 
00037    long double pterm = 0.0;
00038 
00039    for(unsigned int ipar = 0; ipar < fCurPar.size(); ++ipar)
00040    {
00041       const double cur_par = fCurPar[ipar];
00042       const double def_par = fDefPar[ipar];
00043       const double def_err = fDefErr[ipar];
00044 
00045       if(def_err > 0.0)
00046       {
00047          pterm += (cur_par - def_par)*(cur_par - def_par)/(def_err*def_err);
00048       }
00049       else
00050       {
00051          cerr << "AlgAdapt::GetPT - default error values are not positive" << endl;
00052       }      
00053    }
00054 
00055    return pterm;
00056 }

const vector< double > Anp::AlgAdapt::GetVec (  const std::string &  key,
const Registry &  reg
)  const [protected]
 

Definition at line 168 of file AlgAdapt.cxx.

References Registry::Get(), and UtilString::StringTok().

Referenced by ReadVec().

00169 {
00170    //
00171    // Extract Registry value stored at key and convert string numbers separated by
00172    // " " or "," or both to vector of doubles.
00173    //
00174  
00175    vector<double> dvec;
00176    
00177    const char *value_char = 0;
00178    if(!reg.Get(key.c_str(), value_char) || !value_char)
00179    {
00180       return dvec;
00181    }
00182 
00183    vector<string> svec;
00184    UtilString::StringTok(svec, string(value_char), ", ");
00185    
00186    dvec = vector<double>(svec.size(), 0.0);
00187 
00188    for(unsigned int i = 0; i < svec.size(); ++i)
00189    {
00190       if(!svec[i].empty())
00191       {
00192          dvec[i] = std::atof(svec[i].c_str());
00193       }
00194    }
00195 
00196    return dvec;
00197 }

double Anp::AlgAdapt::GetWeight (  const TrueNu &   )  const [inline, virtual]
 

Definition at line 109 of file AlgAdapt.h.

00109 { return 1.0; }

virtual bool Anp::AlgAdapt::Init (   )  [pure virtual]
 

void Anp::AlgAdapt::InitReco (  RecoNu &   )  const [inline, virtual]
 

Definition at line 106 of file AlgAdapt.h.

00106 {}

void Anp::AlgAdapt::InitTrue (  TrueNu &   )  const [inline, virtual]
 

Definition at line 107 of file AlgAdapt.h.

00107 {}

void Anp::AlgAdapt::Print (  std::ostream &  os = std::cout  )  const [virtual]
 

Definition at line 262 of file AlgAdapt.cxx.

00263 {
00264    os << "AlgAdapt::Print - this function is not implemented for this class" << endl;
00265 }

void Anp::AlgAdapt::PrintVec (  const std::vector< double > &  v,
std::ostream &  o,
int  w = 7,
int  p = 5
)  const [protected]
 

Definition at line 228 of file AlgAdapt.cxx.

00229 {
00230    for(unsigned int i = 0; i < v.size(); ++i)
00231    {
00232       if(i == 0)
00233       {
00234          o << "(";
00235       }
00236       else
00237       {
00238          o << ", ";
00239       }
00240       
00241       if(p > 0)
00242       {
00243          o << setprecision(p);
00244       }
00245       if(w > 0)
00246       {
00247          o << setw(w);
00248       }
00249 
00250       o << v[i];
00251       
00252       if(i + 1 == v.size())
00253       {
00254          o << ")";
00255       }
00256    }
00257 
00258    o << endl;
00259 }

void Anp::AlgAdapt::PrintVec (  std::ostream &  o,
int  w = 7,
int  p = 5
)  const [protected]
 

Definition at line 200 of file AlgAdapt.cxx.

References fCurErr, fCurPar, fDefErr, and fDefPar.

00201 {
00202    if(!fCurPar.empty())
00203    {
00204       o << "   CurPar = ";
00205       PrintVec(fCurPar, o, w, p);
00206    }
00207    
00208    if(!fCurErr.empty())
00209    {
00210       o << "   CurErr = ";
00211       PrintVec(fCurErr, o, w, p);
00212    }
00213    
00214    if(!fDefPar.empty())
00215    {
00216       o << "   DefPar = ";
00217       PrintVec(fDefPar, o, w, p);
00218    }
00219    
00220    if(!fDefErr.empty())
00221    {
00222       o << "   DefErr = ";
00223       PrintVec(fDefErr, o, w, p);
00224    }
00225 }

void Anp::AlgAdapt::Read (  const std::string &  fname  )  [virtual]
 

Definition at line 292 of file AlgAdapt.cxx.

References Anp::ConvertString2Vector(), infile, and Set().

00293 {
00294    std::ifstream infile(fname.c_str());
00295    if(!infile.is_open())
00296    {
00297       cerr << "AlgAdapt::Read - failed to open input file:\n   " << fname << endl;
00298       return;
00299    }
00300 
00301    vector<double> cur_err, cur_par, def_err, def_par;
00302 
00303    while(!infile.eof())
00304    {
00305       std::string line;
00306       std::getline(infile, line);
00307       
00308       if(line.empty())
00309       {
00310          continue;
00311       }
00312 
00313       const std::size_t ipos = line.find_last_of("=");
00314       if(ipos == string::npos)
00315       {
00316          cerr << "AlgAdapt::Read - failed to find equal sign:" << endl << line << endl;
00317          continue;
00318       }
00319 
00320       const string name = line.substr(0, ipos - 1);
00321       const string data = line.substr(ipos + 1);
00322 
00323       if     (name == "CurErr") cur_err = Anp::ConvertString2Vector(data);
00324       else if(name == "CurPar") cur_par = Anp::ConvertString2Vector(data);
00325       else if(name == "DefErr") def_err = Anp::ConvertString2Vector(data);
00326       else if(name == "DefPar") def_par = Anp::ConvertString2Vector(data);
00327    }
00328    
00329    if(cur_err.size() != cur_par.size() || 
00330       cur_err.size() != def_err.size() || 
00331       cur_err.size() != def_par.size() || cur_err.empty())
00332    {
00333       cerr << "AlgAdapt::Read - input vectors do not match" << endl;
00334       return;
00335    }
00336 
00337    Set(cur_err, "CurErr");
00338    Set(cur_par, "CurPar");
00339    Set(def_par, "DefErr");
00340    Set(def_par, "DefPar");
00341 }

void Anp::AlgAdapt::ReadVec (  const std::string &  prefix,
const Registry &  reg
)  [protected]
 

Definition at line 122 of file AlgAdapt.cxx.

References GetVec(), and Set().

00123 {
00124    //
00125    // Read in default and and current error and parameter vectors from
00126    // Registry, if these keys exist in Registry. Use virtual functions Set()
00127    // to set parameter values.
00128    //
00129 
00130    const vector<double> pvec = GetVec(prefix + "Par", reg);
00131    if(!pvec.empty())
00132    {
00133       Set(pvec, "CurPar");
00134    }
00135 
00136    const vector<double> evec = GetVec(prefix + "Err", reg);
00137    if(!evec.empty())
00138    {
00139       Set(evec, "CurErr");
00140    }
00141 
00142    const vector<double> evec_def = GetVec(prefix + "DefErr", reg);
00143    if(!evec_def.empty())
00144    {
00145       Set(evec_def, "DefErr");
00146    }
00147 
00148    const vector<double> pvec_def = GetVec(prefix + "DefPar", reg);
00149    if(!pvec_def.empty())
00150    {
00151       Set(pvec_def, "DefPar");
00152    }
00153 
00154    const vector<double> pvec_cur = GetVec(prefix + "CurPar", reg);
00155    if(!pvec_cur.empty())
00156    {
00157       Set(pvec_cur, "CurPar");
00158    }
00159 
00160    const vector<double> evec_cur = GetVec(prefix + "CurErr", reg);
00161    if(!evec_cur.empty())
00162    {
00163       Set(evec_cur, "CurErr");
00164    }
00165 }

void Anp::AlgAdapt::Save (  const std::string &  fname  )  [virtual]
 

Definition at line 268 of file AlgAdapt.cxx.

References Anp::ConvertVector2String(), fCurErr, fCurPar, fDefErr, and fDefPar.

00269 {
00270    if(fCurErr.size() != fCurPar.size() || 
00271       fCurErr.size() != fDefErr.size() || 
00272       fCurErr.size() != fDefPar.size() || fCurErr.empty())
00273    {
00274       cerr << "AlgAdapt::Save - invalid internal state" << endl;
00275       return;
00276    }
00277 
00278    ofstream ofile(fname.c_str());
00279    if(!ofile.is_open())
00280    {
00281       cerr << "AlgAdapt::Save - failed to open output file:\n   " << fname << endl;
00282       return;
00283    }
00284 
00285    ofile << "CurErr = " << Anp::ConvertVector2String(fCurErr) << endl
00286          << "CurPar = " << Anp::ConvertVector2String(fCurPar) << endl
00287          << "DefErr = " << Anp::ConvertVector2String(fDefErr) << endl
00288          << "DefPar = " << Anp::ConvertVector2String(fDefPar) << endl;
00289 }

void Anp::AlgAdapt::Set (  const std::vector< double > &  dvec,
const std::string &  key
)  [virtual]
 

Definition at line 86 of file AlgAdapt.cxx.

References fCurErr, fCurPar, fDefErr, fDefPar, and GetNPar().

Referenced by Read(), and ReadVec().

00087 {
00088    if(dvec.size() != GetNPar())
00089    {
00090       cerr << "AlgAdapt::Set - number of parameters and size of input vector do not match: " 
00091            << " GetNPar() = " << GetNPar() << " and dvec.size() = " << dvec.size() << endl;
00092       return;
00093    }
00094 
00095    if(key == "CurErr")
00096    {
00097       fCurErr = dvec;
00098       return;
00099    }
00100    else if(key == "CurPar")
00101    {
00102       fCurPar = dvec;
00103       return;
00104    }
00105    else if(key == "DefErr")
00106    {
00107       fDefErr = dvec;
00108       return;
00109    }
00110    else if(key == "DefPar")
00111    {
00112       fDefPar = dvec;
00113       return;
00114    }
00115    
00116    cerr << "AlgAdapt::Set - unknown key: " << key << endl;
00117 
00118    assert(false && "unknown key");
00119 }

void Anp::AlgAdapt::Vary (  RecoNu &  ,
const TrueNu & 
)  const [inline, virtual]
 

Definition at line 110 of file AlgAdapt.h.

00110 {}

Member Data Documentation

std::vector<double> Anp::AlgAdapt::fCurErr [protected]
 

Definition at line 84 of file AlgAdapt.h.

Referenced by PrintVec(), Save(), and Set().

std::vector<double> Anp::AlgAdapt::fCurPar [protected]
 

Definition at line 85 of file AlgAdapt.h.

Referenced by GetPT(), PrintVec(), Save(), and Set().

std::vector<double> Anp::AlgAdapt::fDefErr [protected]
 

Definition at line 86 of file AlgAdapt.h.

Referenced by GetPT(), PrintVec(), Save(), and Set().

std::vector<double> Anp::AlgAdapt::fDefPar [protected]
 

Definition at line 87 of file AlgAdapt.h.

Referenced by GetPT(), PrintVec(), Save(), and Set().

std::vector<std::string> Anp::AlgAdapt::fParName [protected]
 

Definition at line 89 of file AlgAdapt.h.

The documentation for this class was generated from the following files:
Generated on Mon Jun 16 15:04:02 2008 for loon by  doxygen 1.3.9.1