MdcCalibConst.cxx

Go to the documentation of this file.

#include "MdcCalibAlg/MdcCalibConst.h"
#include "MdcCalibAlg/MdcCalParams.h"
 
#include <iostream>
 
using namespace std;
 
typedef map<int, double>::value_type valType;
 
MdcCalibConst::MdcCalibConst(){
}
 
MdcCalibConst::MdcCalibConst(const MdcCalibConst& calconst){
     m_xtmap = calconst.m_xtmap;
     m_t0 = calconst.m_t0;
     m_delt0 = calconst.m_delt0;
     m_qtpar0 = calconst.m_qtpar0;
     m_qtpar1 = calconst.m_qtpar1;
     m_sdmap = calconst.m_sdmap;
}
 
void MdcCalibConst::initCalibConst(){
     int lay;
     int lr;
     int entr;
     int ord;
     int key;
     double val;
     for(lay=0; lay<MdcCalNLayer; lay++){
      for(entr=0; entr<MdcCalNENTRXT; entr++){
           for(lr=0; lr<MdcCalLR; lr++){
            for(ord=0; ord<MdcCalXtNPars; ord++){
             key = getXtKey(lay, entr, lr, ord);
             if(1 == ord){
                  val = 0.03;
             } else if(6 == ord){
                  val = 999.0;
             } else{
                  val = 0.0;
             }
             m_xtmap.insert( valType(key, val) );
            }
           }
      }
     }
 
     int wir;
     double t0 = 0.0;
     double dt0 = 0.0;
     for(wir=0; wir<MdcCalTotCell; wir++){
      m_t0.push_back(t0);
      m_delt0.push_back(dt0);
     }
 
     double qtpar0 = 0.0;
     double qtpar1 = 0.0;
     for(lay=0; lay<MdcCalNLayer; lay++){
      m_qtpar0.push_back(qtpar0);
      m_qtpar1.push_back(qtpar1);
     }
 
     int bin;
     double sdpar = 0.16;
     for(lay=0; lay<MdcCalNLayer; lay++){
      for(entr=0; entr<MdcCalNENTRSD; entr++){
           for(lr=0; lr<2; lr++){
            for(bin=0; bin<MdcCalSdNBIN; bin++){
             key = getSdKey(lay, entr, lr, ord);
             m_sdmap.insert( valType( key, sdpar) );
            }    
           }
      }
     }
}
 
void MdcCalibConst::fillXtpar(int key, double val){
     m_xtmap.insert( valType( key, val ) );
}
 
void MdcCalibConst::resetXtpar(int lay, int entr, int lr, int order, double val){
     int key = getXtKey(lay, entr, lr, order);
     m_xtmap[key] = val;
}
 
double MdcCalibConst::getXtpar(int lay, int entr, int lr, int order){
     double xtpar = -999.0;
     int key = getXtKey(lay, entr, lr, order);
     if( 1 == m_xtmap.count(key) )
      xtpar = m_xtmap[key];
 
     return xtpar;
}
 
int MdcCalibConst::getXtKey(int lay, int entr, int lr, int order) const{
     int key;
 
     key = ( (lay << XTLAYER_INDEX) & XTLAYER_MASK ) |
      ( (entr << XTENTRA_INDEX) & XTENTRA_MASK ) |
      ( (lr << XTLR_INDEX) & XTLR_MASK ) |
      ( (order << XTORDER_INDEX) & XTORDER_MASK );
 
     return key;
}
 
void MdcCalibConst::setXtBegin(){
     m_xtiter = m_xtmap.begin();
}
 
int MdcCalibConst::getNextXtpar(int& key, double& xtpar) {
     if( m_xtiter != m_xtmap.end() ){
      key = (*m_xtiter).first;
      xtpar = (*m_xtiter).second;
      m_xtiter++;
      return 1;
     }
     else return 0;
}
 
void MdcCalibConst::fillQtpar(int order, double val){
     if( 0 == order ){
      m_qtpar0.push_back( val );
     } else if( 1 == order ){
      m_qtpar1.push_back( val );
     } else {
      cout << "Order of Qtpar Error in fillQtpar()!" << endl;
     }
}
 
void MdcCalibConst::resetQtpar(int lay, int order, double val){
     if( 0 == order ){
      m_qtpar0[lay] = val;
     } else if( 1 == order ){
      m_qtpar1[lay] = val;
     } else{
      cout << "Order of Qtpar Error in resetQtpar()!" << endl;
     }
}
 
double MdcCalibConst::getQtpar(int lay, int order) const{
     if( 0 == order ){
      return m_qtpar0[lay];
     } else if( 1 == order ){
      return m_qtpar1[lay];
     } else{
      cout << "Order of Qtpar Error in getQtpar()!" << endl;
      return -9999.0;
     }
}
 
void MdcCalibConst::fillSdpar(int key, double val){
     m_sdmap.insert( valType( key, val) );
}
 
void MdcCalibConst::resetSdpar(int lay, int entr, int lr, int bin, double val){
     int key = getSdKey(lay, entr, lr, bin);
     m_sdmap[key] = val;
}
 
double MdcCalibConst::getSdpar(int lay, int entr, int lr, int bin){
                   
     double sdpar = -999.0;
     int key = getSdKey(lay, entr, lr, bin);
     if( 1 == m_sdmap.count(key) ){
      return m_sdmap[key];
     }
 
     return sdpar;
}
 
int MdcCalibConst::getSdKey(int lay, int entr, int lr, int bin) const{
     int key;
 
     key = ( (lay << SDLAYER_INDEX) & SDLAYER_MASK ) |
      ( (entr << SDENTRA_INDEX) & SDENTRA_MASK ) |
      ( (lr << SDLR_INDEX) & SDLR_MASK ) |
      ( (bin << SDBIN_INDEX) & SDBIN_MASK );
 
     return key;
}
 
void MdcCalibConst::setSdBegin(){
     m_sditer = m_sdmap.begin();
}
 
int MdcCalibConst::getNextSdpar(int& key, double& sdpar) {
     if( m_sditer != m_sdmap.end() ){
      key = (*m_sditer).first;
      sdpar = (*m_sditer).second;
      m_sditer++;
      return 1;
     }
     else return 0;
}
 
void MdcCalibConst::clear(){
     m_xtmap.clear();
     m_t0.clear();
     m_delt0.clear();
     m_qtpar0.clear();
     m_qtpar1.clear();
     m_sdmap.clear();
}