QCalibrationParameters.cc

Go to the documentation of this file.

#include "QCalibrationParameters.hh"
#include "QCalibrationResiduals.hh"
#include <sstream>
 
using std::stringstream;
using std::vector;
using std::endl;
using std::cout;
using std::string;
 
QObjectImp(QCalibrationParameters);
 
QCalibrationParameters::QCalibrationParameters()
{
    Clear();
}
void QCalibrationParameters::Clear()
{
    fFunction.Clear();
    fSource.clear();
    fResiduals.clear();
    fChisquareNdf = 0.;
    fSourceRuns.clear();
}
 
QError  QCalibrationParameters::WriteOnStream (std::ostream &o) const 
{
        QError err = QERR_SUCCESS;
 
        // fit function 
        o<<"fFunction.fName"<<"\t"<<fFunction.GetName()<<endl;
        o<<"fFunction.fTitle"<<"\t"<<fFunction.GetTitle()<<endl;
        o<<"fFunction.fNpar"<<"\t"<<fFunction.GetNpar()<<endl;
        for(Int_t i=0; i<fFunction.GetNpar(); i++) {
          o<<"fFunction.fPar["<<i<<"]\t";
          o<<fFunction.GetParameter(i)<<" ";
          o<<fFunction.GetParError(i)<<endl;
        }
        o<<"fFunction.fChisquare"<<"\t"<<fFunction.GetChisquare()<<endl;
        o<<"fChisquareNdf"<<"\t"<<fChisquareNdf<<endl;
 
        // source
        o<<"fSource"<<"\t"<<fSource<<endl;
 
        // residuals
        o<<"fResiduals.fSize"<<"\t"<<fResiduals.size()<<endl;
        for(size_t i =0; i < fResiduals.size(); i++) {
                o<<"fResiduals["<<i<<"]\t";
                o<<fResiduals[i].PeakEnergy<<" ";
                o<<fResiduals[i].Residual<<" ";
                o<<fResiduals[i].ErrorResidual<<endl;
        }
 
        // source runs
        o<<"fSourceRuns.size"<<"\t"<<fSourceRuns.size()<<endl;
  
        if(fSourceRuns.empty()) return err;
        
        for(size_t j=0; j<fSourceRuns.size(); j++) {
          o<<"fSourceRuns["<<j<<"]"<<"\t"<<fSourceRuns[j]<<"\t"<< endl; 
        }
 
        return err;
}
 
QError QCalibrationParameters::ReadFromStream(std::istream& ob) 
{
  QError err = QERR_SUCCESS;
  
  std::string tag, name, formula, source;
  int npar, nres, size, run;
  Double_t chisq, chisqndf;
  Double_t par, par_err;
  Double_t ene, res, res_err;
 
  // fit function       
  ob >> tag >> name;
  if(tag != "fFunction.fName") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fFunction.fName");
    return err;
  }
  ob >> tag >> formula;
  if(tag != "fFunction.fTitle") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fFunction.fTitle");
    return err;
  }
  ob >> tag >> npar;
  if(tag != "fFunction.fNpar") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fFunction.fNpar");
    return err;  
}
 
  TF1 f(name.c_str(),formula.c_str());
  fFunction = f;
 
  for(Int_t i=0; i<npar; i++) {
    ob >> tag >> par >> par_err;
    if(tag != Form("%s%d%s","fFunction.fPar[",i,"]")) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription("Expected tag fFunction.fPar");
    return err;    
}
    fFunction.SetParameter(i,par);
    fFunction.SetParError(i,par_err);
   }
 
  ob >> tag >> chisq;
  if(tag != "fFunction.fChisquare") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fFunction.fChisquare");
    return err;  
}
  fFunction.SetChisquare(chisq);
 
  ob >> tag >> chisqndf;
  if(tag != "fChisquareNdf") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fChisquareNdf");
    return err;  
}
  fChisquareNdf = chisqndf;
  
  // source
  ob >> tag >> source;
  if(tag != "fSource") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fSource");
    return err;  
  }
  fSource = source;
  
  // residuals
  fResiduals.clear();
  ob >> tag >> nres; 
 if(tag != "fResiduals.fSize") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fResiduals");
    return err;  
  }
 fResiduals.resize(nres);
 
  for(Int_t i=0; i<nres; i++) {
    ob >> tag >> ene >> res >> res_err;
    stringstream tagstr;
    tagstr<<"fResiduals["<<i<<"]";
    if(tag != tagstr.str()) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription(string("Expected tag ")+tagstr.str());
      return err;
    }
    fResiduals[i].PeakEnergy = ene;
  fResiduals[i].Residual = res;
  fResiduals[i].ErrorResidual = res_err;
  }
 
  // read fSource Runs
  ob >> tag >> size;
  if(tag != "fSourceRuns.size") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fSourceRuns.size");
    return err;
  }
  
  char s[50];
  
  for(Int_t i=0; i<size; i++) {
    ob >> tag >> run;
    snprintf(s,50,"fSourceRuns[%d]",i);    
    if(tag != s) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription("Expected tag fSourceRuns");
      return err;    
    }
    fSourceRuns.push_back(run);
   }
  
  return err;
}