QCalibrationParametersHandle.cc

Go to the documentation of this file.

#include "QCalibrationParametersHandle.hh"
#include "QCalibrationParameters.hh"
#include "QDianaDb.hh"
 
using namespace Diana;
 
QError QCalibrationParametersHandle::FillFromDB()
{
 
  QError err = QERR_SUCCESS;
 
  QCalibrationParameters calpar;
  calpar.Clear();
 
  std::string bareOwner, extraLabel;
  GetLabel().GetBareOwnerAndExtraLabel(bareOwner,extraLabel);    
  if (extraLabel=="") extraLabel="None";
  
  std::string name, formula;
  int npar =0,npeaks = 0;
  std::vector<double> params, err_params, peak_energies, residuals, err_residuals;
  double chi_square = Q_INT_DEFAULT, ndf = Q_INT_DEFAULT;
  std::vector<int> sruns;
 
  QDianaDb *db = QDianaDb::Get();
 
 
  std::stringstream squery;
  
  // query function name  
 
  squery<<"select calib_function_name from "<<bareOwner<<"_calib_algo"
        << " where calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel << "'";
  
  try {
    name = db->DoQueryString(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query function formula  
  
  squery<<"select calib_function_formula from "<<bareOwner<<"_calib_algo"
        << " where calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel << "'";
  
  try {
    formula = db->DoQueryString(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query source
  squery<<"select calib_source from "<<bareOwner<<"_calib_algo"
        << " where calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel << "'";
  
  try {
    calpar.fSource = db->DoQueryString(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query npar
  squery<<"select calib_function_par_number from "<<bareOwner<<"_calib_algo"
        << " where calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel << "'";
  
  try {
    npar = db->DoQueryInt(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query params
  squery<<"select params from calibrations where calib_algo = '"<<bareOwner
        << "' and  calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel
        << "' and channel = "<<GetChannel()
        << " and data_set = "<<GetDataset();
  
  try {
    params = db->DoQueryVectorDouble(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query err_params
  squery<<"select err_params from calibrations where calib_algo =  '"<<bareOwner
        << "' and  calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel
        << "' and channel = "<<GetChannel()
        << " and data_set = "<<GetDataset();
 
  try {
    err_params = db->DoQueryVectorDouble(squery.str());
  }
  
    catch(const QError& cerr) {
      if(cerr!=QERR_SUCCESS) {
        err = cerr;
        return err;
      } 
    }
  
  squery.str("");
  
  // query npeaks
  squery<<"select npeaks from calibrations where calib_algo = '"<<bareOwner
        << "' and  calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel
        << "' and channel = "<<GetChannel()
        << " and data_set = "<<GetDataset();
  
  try {
    npeaks = db->DoQueryInt(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query peak_energies
  squery<<"select peak_energies from calibrations where calib_algo = '"<<bareOwner
        << "' and  calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel
        << "' and channel = "<<GetChannel()
        << " and data_set = "<<GetDataset();
  
  try {
    peak_energies = db->DoQueryVectorDouble(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query residuals
  squery<<"select residuals from calibrations where calib_algo = '"<<bareOwner
        << "' and  calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel
        << "' and channel = "<<GetChannel()
        << " and data_set = "<<GetDataset();
  
  try {
    residuals = db->DoQueryVectorDouble(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query err_residuals
  squery<<"select err_residuals from calibrations where calib_algo = '"<<bareOwner
        << "' and  calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel
        << "' and channel = "<<GetChannel()
        << " and data_set = "<<GetDataset();
 
  try {
    err_residuals = db->DoQueryVectorDouble(squery.str());
  }
    
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query chi_square
  squery<<"select chi_square from calibrations where calib_algo = '"<<bareOwner
        << "' and  calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel
        << "' and channel = "<<GetChannel()
        << " and data_set = "<<GetDataset();
  
  try {
    chi_square = db->DoQueryDouble(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
  // query ndf
  squery<<"select ndf from calibrations where calib_algo = '"<<bareOwner
        << "' and  calib_version = '"<<GetVersion()
        << "' and calib_extralabel= '"<<extraLabel
        << "' and channel = "<<GetChannel()
        << " and data_set = "<<GetDataset();
  
  try {
    ndf = db->DoQueryDouble(squery.str());
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    } 
  }
  
  squery.str("");
  
 // query source_runs
  squery<<"select source_runs from calibrations where calib_algo = '"<<bareOwner
        <<"' and calib_version= '"<<GetVersion()
        <<"' and calib_extralabel= '"<<extraLabel
        <<"' and channel= "<< GetChannel()
        << " and data_set = "<<GetDataset();
  
  try {
    sruns = db->DoQueryVectorInt(squery.str());        
  }
  
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;   
    }  
  }
 
  squery.str("");
    
  TF1 func(name.c_str(),formula.c_str());
  calpar.fFunction = func;
  
  for(Int_t i=0; i<npar; i++) {
    calpar.fFunction.SetParameter(i,params[i]);
    calpar.fFunction.SetParError(i,err_params[i]);
  }
  
  calpar.fFunction.SetChisquare(chi_square);
  calpar.fChisquareNdf = ndf;
  calpar.fResiduals.resize(npeaks);
  
  for(Int_t i=0; i<npeaks; i++) {      
    calpar.fResiduals[i].PeakEnergy = peak_energies[i];
    calpar.fResiduals[i].Residual = residuals[i];
    calpar.fResiduals[i].ErrorResidual = err_residuals[i];
  }
  
  for(size_t i=0; i<sruns.size(); i++)
    {
      calpar.fSourceRuns.push_back(sruns[i]);
    }
 
  Set(calpar);
 
  // fill fStabLabel from table calibrations
 
  std::string stab_algo, stab_version, stab_extralabel;
 
  QDb::QDbTable table;
 
  squery.str("");
 
  squery<<"select stab_algo, stab_version, stab_extralabel from calibrations where calib_algo = '"<<bareOwner
        <<"' and calib_version= '"<<GetVersion()
        <<"' and calib_extralabel= '"<<extraLabel
        <<"' and channel= "<< GetChannel()
        <<" and data_set= "<<GetDataset();
  
  try {
    table = db->DoQuery(squery.str());
  }
  
  catch(const QError& cerr) {
    err = cerr;
    return err;
  }
  
  try {
    if(table["stab_algo"].size() == 1) {    
      stab_algo = table["stab_algo"].begin()->GetString(); 
      stab_version = table["stab_version"].begin()->GetString(); 
      stab_extralabel = table["stab_extralabel"].begin()->GetString(); 
    }  else {
      err = QERR_DB_NULL_RESULT;
      std::string errMsg("The primary key was not found in DB; Check you input.\nFill the object with default values.\nQuery: ");
      errMsg +=squery.str();
      err.SetDescription(__FILE__, __LINE__, errMsg);
      return err;
    }
  }
  catch(const QError& cerr) {
    if(cerr!=QERR_SUCCESS) {
      err = cerr;
      return err;
    }
  }
  
  fStabLabel = stab_algo + "_" + stab_extralabel;
  if(stab_extralabel=="None") fStabLabel = stab_algo;
  fStabVersion = stab_version;
 
  return err;
}
 
QError QCalibrationParametersHandle::StoreOnDB() const
{
    QError err = QERR_SUCCESS; 
  
    const QCalibrationParameters& cp = Get();
 
    std::string bareOwner, extraLabel;
    GetLabel().GetBareOwnerAndExtraLabel(bareOwner,extraLabel);    
    if (extraLabel=="") extraLabel="None";
    
    std::string stab_algo, stab_extralabel;
    QGlobalLabel stab_label = fStabLabel;
 
    if (stab_label.GetStringLabel()!=Q_STRING_DEFAULT) {
      stab_label.GetBareOwnerAndExtraLabel(stab_algo,stab_extralabel);    
    }
    if (stab_extralabel=="") stab_extralabel = "None";
    if(stab_algo.empty() && fStabLabel.find_first_of("@") == std::string::npos) stab_algo = fStabLabel; 
 
    // function infos
 
    const std::string &name = cp.fFunction.GetName();
    const std::string &formula = cp.fFunction.GetTitle();
    const std::string &source = cp.fSource;
    const int npar = cp.fFunction.GetNpar();
 
    // creates a string containing all components of the vector params and err_params
    
    std::stringstream list_par;
    list_par<< "'{";
    
    std::stringstream list_par_err;
    list_par_err <<"'{";    
    
    for(Int_t i=0; i<npar; i++) {
      if(i==npar-1){
        list_par<<cp.fFunction.GetParameter(i)<<"}'";
        list_par_err<<cp.fFunction.GetParError(i)<<"}'";
      }else{
        list_par<<cp.fFunction.GetParameter(i)<<",";
        list_par_err<<cp.fFunction.GetParError(i)<<",";
      }
    }
    
    if (npar==0) {
      list_par.str("NULL");
      list_par_err.str("NULL");
    }
 
    // residuals
 
    const int npeaks = cp.fResiduals.size();
 
    // creates a string containing all components of the vector peak_energies, residuals and err_residuals
    
    std::stringstream list_en;
    list_en<< "'{";    
 
    std::stringstream list_res;
    list_res<< "'{";    
 
    std::stringstream list_res_err;
    list_res_err<< "'{";    
    
    for(Int_t i=0; i<npeaks; i++) {
      if(i==npeaks-1){
        list_en<<cp.fResiduals[i].PeakEnergy<<"}'";
        list_res<< cp.fResiduals[i].Residual<<"}'";;
        list_res_err<< cp.fResiduals[i].ErrorResidual<<"}'";
      }else{
        list_en<<cp.fResiduals[i].PeakEnergy<<",";
        list_res<< cp.fResiduals[i].Residual<<",";;
        list_res_err<< cp.fResiduals[i].ErrorResidual<<",";
      }
    }
    if (npeaks==0) {
      list_en.str("NULL");
      list_res.str("NULL");
      list_res_err.str("NULL");
    }
 
    std::stringstream squery;
    
    // query insert into xxx_calib_algo where xxx is the name of the calibration module (now CalCoefficients)
 
    // first check if the table is already filled 
    squery<<"select calib_function_name from "<<bareOwner<<"_calib_algo"
          << " where calib_version = '"<<GetVersion()
          << "' and calib_extralabel= '"<<extraLabel<<"'";
 
    try {
      QDianaDb *db = QDianaDb::Get();
      std::string el = db->DoQueryString(squery.str());
    }
 
    catch(const QError& cerr) {
      if(cerr!=QERR_SUCCESS) {
 
        squery.str("");
 
        squery<<"INSERT into "<<bareOwner<<"_calib_algo (calib_version, calib_extralabel, calib_source, calib_function_name, calib_function_formula, calib_function_par_number) values "
              <<"('"
              << GetVersion()<<"','"
              << extraLabel<<"','"
              << source<<"','"
              << name<<"','"
              << formula<<"',"
              << npar<<")";
        
        try {
          QDianaDb *db = QDianaDb::Get();
          db->DoExec(squery.str());
        }
        
        catch(const QError& cerr) {
          if(cerr!=QERR_SUCCESS) {
            err = cerr;
            return err;
          } 
        }
      }
    }
 
    squery.str("");
 
   // creates a string containing source runs list 
  std::stringstream list_run;
  list_run<< "'{";
 
  for(size_t i=0; i<cp.fSourceRuns.size(); i++)
    { 
      if(i==cp.fSourceRuns.size()-1) {
        list_run<<cp.fSourceRuns[i]<<"}'";
      } else{
        list_run<<cp.fSourceRuns[i]<<",";
      }
    }
  
    // query insert into calibrations
 
  QVdt::QVdt_vector fields,values;
  fields.push_back((std::string)"calib_algo");
  fields.push_back((std::string)"calib_version");
  fields.push_back((std::string)"calib_extralabel");
  fields.push_back((std::string)"channel");
  fields.push_back((std::string)"data_set");
  fields.push_back((std::string)"stab_algo");
  fields.push_back((std::string)"stab_version");
  fields.push_back((std::string)"stab_extralabel");
  fields.push_back((std::string)"params");
  fields.push_back((std::string)"err_params");
  fields.push_back((std::string)"npeaks");
  fields.push_back((std::string)"peak_energies");
  fields.push_back((std::string)"residuals");
  fields.push_back((std::string)"err_residuals");
  fields.push_back((std::string)"chi_square");
  fields.push_back((std::string)"ndf");
  fields.push_back((std::string)"source_runs");
  values.push_back("'"+bareOwner+"'");
  values.push_back("'"+GetVersion()+"'");
  values.push_back("'"+extraLabel+"'");
  values.push_back(GetChannel());
  values.push_back(GetDataset());
  values.push_back("'"+stab_algo+"'");
  values.push_back("'"+fStabVersion+"'");
  values.push_back("'"+stab_extralabel+"'");
  values.push_back(list_par.str());
  values.push_back(list_par_err.str());
  values.push_back(npeaks);
  values.push_back(list_en.str());
  values.push_back(list_res.str());
  values.push_back(list_res_err.str());
  values.push_back(cp.fFunction.GetChisquare());
  values.push_back(cp.fChisquareNdf);
  values.push_back(list_run.str());
 
  try {
        QDianaDb *db = QDianaDb::Get();
        db->Insert("calibrations",fields,values);
  }
  catch(const QError& cerr) {
      if(cerr!=QERR_SUCCESS) {
          err = cerr;
          return err;
      } 
  }
 
 
  return err;
}