MdcCalibConst.cpp

Go to the documentation of this file.

#include "include/MdcCalibConst.h"
 
#include <iostream>
 
typedef std::map<int, double>::value_type valType;
 
MdcCalibConst::MdcCalibConst() {
  // constructor
}
 
MdcCalibConst::MdcCalibConst( const MdcCalibConst& calconst ) {
  m_xtmap = calconst.m_xtmap;
  m_t0    = calconst.m_t0;
  m_delt0 = calconst.m_delt0;
  //      m_wshift = calconst.m_wshift;
  //      m_delwshift = calconst.m_delwshift;
  m_qtpar0 = calconst.m_qtpar0;
  m_qtpar1 = calconst.m_qtpar1;
  m_sdmap  = calconst.m_sdmap;
}
 
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 { std::cout << "Order of Qtpar Error in fillQtpar()!" << std::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 { std::cout << "Order of Qtpar Error in resetQtpar()!" << std::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
  {
    std::cout << "Order of Qtpar Error in getQtpar()!" << std::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_wshift.clear();
  //      m_delwshift.clear();
  m_qtpar0.clear();
  m_qtpar1.clear();
  m_sdmap.clear();
}