/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Mdc/MdcCalibAlg/MdcCalibAlg-00-09-02/src/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();
}

---