MucCalibConstSvc Class Reference

#include <MucCalibConstSvc.h>

Inheritance diagram for MucCalibConstSvc:

IMucCalibConstSvc List of all members.

Public Member Functions

 MucCalibConstSvc (const std::string &name, ISvcLocator *svcloc)
 ~MucCalibConstSvc ()
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvUnknown)
virtual StatusCode initialize ()
virtual StatusCode finalize ()
int getLevel () const
double getEff (int part, int segment, int layer, int strip) const
double getCnt (int part, int segment, int layer, int strip) const
double getNos (int part, int segment, int layer, int strip) const
double getNosRatio (int part, int segment, int layer, int strip) const
double getClst (int part, int segment, int layer, double prob) const
double getUniformEff () const
double getUniformCnt () const
double getUniformNos () const
double getUniformNosRatio () const
double getUniformClst () const
double getLayerEff (int layer) const
double getLayerCnt (int layer) const
double getLayerNos (int layer) const
double getLayerNosRatio (int layer) const
double getLayerClst (int layer, double prob) const
double getBoxEff (int part, int segment, int layer) const
double getBoxCnt (int part, int segment, int layer) const
double getBoxNos (int part, int segment, int layer) const
double getBoxNosRatio (int part, int segment, int layer) const
double getBoxClst (int part, int segment, int layer, double prob) const
double getStripEff (int part, int segment, int layer, int strip) const
double getStripCnt (int part, int segment, int layer, int strip) const
double getStripNos (int part, int segment, int layer, int strip) const
double getStripNosRatio (int part, int segment, int layer, int strip) const

Static Public Member Functions

static const InterfaceID & interfaceID ()

Private Attributes

IDataProviderSvc * m_pCalibDataSvc
int m_fConfigMode
double m_fUniformEff
double m_fUniformCnt
double m_fUniformNos
double m_fUniformNosRatio
double m_fUniformClst

Detailed Description

Definition at line 19 of file MucCalibConstSvc.h.


Constructor & Destructor Documentation

MucCalibConstSvc::MucCalibConstSvc ( const std::string name,
ISvcLocator *  svcloc 
)

Definition at line 33 of file MucCalibConstSvc.cxx.

References m_fConfigMode, m_fUniformClst, m_fUniformEff, and m_fUniformNos.

00033                                                                               : Service (name, svcloc),
00034   m_pCalibDataSvc(0) 
00035 { 
00036   declareProperty("ConfigMode",     m_fConfigMode=3);
00037   declareProperty("UniformEff",     m_fUniformEff=0.95);
00038   declareProperty("UniformCnt",     m_fUniformEff=0.05);
00039   declareProperty("UniformNos",     m_fUniformEff=0.001);
00040   declareProperty("UniformNosRatio",m_fUniformNos=0.05);
00041   declareProperty("UniformClst",    m_fUniformClst=4);
00042 }

MucCalibConstSvc::~MucCalibConstSvc (  ) 

Definition at line 44 of file MucCalibConstSvc.cxx.

00044 { }


Member Function Documentation

StatusCode MucCalibConstSvc::finalize (  )  [virtual]

Definition at line 74 of file MucCalibConstSvc.cxx.

References Bes_Common::INFO.

00075 {
00076   MsgStream log(messageService(), name());
00077   log << MSG::INFO << endreq << "finalize()" << endreq << endreq;
00078   return StatusCode::SUCCESS;
00079 }

double MucCalibConstSvc::getBoxClst ( int  part,
int  segment,
int  layer,
double  prob 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 496 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00497 {
00498   double fClst = 0.0;
00499   MsgStream log(messageService(), name());
00500   
00501   std::string fullPath = "/Calib/MucCal";
00502   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00503   if( ! pMucCalibConst ){
00504     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00505   }else {
00506     fClst= pMucCalibConst->getBoxClst( part, segment, layer, prob );
00507   }
00508        
00509   return fClst;         
00510 }

double MucCalibConstSvc::getBoxCnt ( int  part,
int  segment,
int  layer 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 448 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00449 {
00450   double fCnt = 0.0;
00451   MsgStream log(messageService(), name());
00452   
00453   std::string fullPath = "/Calib/MucCal";
00454   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00455   if( ! pMucCalibConst ){
00456     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00457   }else {
00458     fCnt= pMucCalibConst->getBoxCnt( part, segment, layer );
00459   }
00460   
00461   return fCnt;  
00462 }

double MucCalibConstSvc::getBoxEff ( int  part,
int  segment,
int  layer 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 431 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00432 {
00433   double fEff = 0.0;
00434   MsgStream log(messageService(), name());
00435   
00436   std::string fullPath = "/Calib/MucCal";
00437   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00438   if( ! pMucCalibConst ){
00439     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00440   }else {
00441     fEff= pMucCalibConst->getBoxEff( part, segment, layer );
00442   }
00443        
00444   // log << MSG::DEBUG << "Box:\t" << part << "\t" << segment <<"\t" << layer << "\t" << fEff << endreq; 
00445   return fEff;                  
00446 }

double MucCalibConstSvc::getBoxNos ( int  part,
int  segment,
int  layer 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 464 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00465 {
00466   double fNos = 0.0;
00467   MsgStream log(messageService(), name());
00468   
00469   std::string fullPath = "/Calib/MucCal";
00470   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00471   if( ! pMucCalibConst ){
00472     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00473   }else {
00474     fNos= pMucCalibConst->getBoxNos( part, segment, layer );
00475   }
00476   
00477   return fNos;  
00478 }

double MucCalibConstSvc::getBoxNosRatio ( int  part,
int  segment,
int  layer 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 480 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00481 {
00482   double fNosRatio = 0.0;
00483   MsgStream log(messageService(), name());
00484   
00485   std::string fullPath = "/Calib/MucCal";
00486   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00487   if( ! pMucCalibConst ){
00488     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00489   }else {
00490     fNosRatio= pMucCalibConst->getBoxNosRatio( part, segment, layer );
00491   }
00492   
00493   return fNosRatio;     
00494 }

double MucCalibConstSvc::getClst ( int  part,
int  segment,
int  layer,
double  prob 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 231 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_fConfigMode, m_fUniformClst, m_pCalibDataSvc, and deljobs::string.

00232 {
00233   double cluster = 0.0;
00234   MsgStream log(messageService(), name());
00235   std::string fullPath = "/Calib/MucCal";
00236   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00237   if( ! pMucCalibConst ){
00238   log << MSG::ERROR << "getClst() can not access to MucCalibData via SmartPtr" << endreq;
00239   }else 
00240   {
00241     switch( m_fConfigMode ) 
00242     {
00243       case 0 : 
00244               if( m_fUniformClst < 0 )
00245                 cluster = pMucCalibConst->getUniformClst();
00246               else
00247                 cluster = m_fUniformClst;
00248               break;
00249       case 1 :
00250               cluster = pMucCalibConst->getLayerClst( layer, prob );
00251               break;
00252       case 2 :
00253               cluster = pMucCalibConst->getBoxClst( part, segment, layer, prob );
00254               break;
00255       case 3 :
00256               cluster = 0.0; 
00257               break;
00258       default: ;        
00259     }
00260   }
00261   
00262   return cluster;     
00263 }

double MucCalibConstSvc::getCnt ( int  part,
int  segment,
int  layer,
int  strip 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 126 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_fConfigMode, m_fUniformCnt, m_pCalibDataSvc, and deljobs::string.

00127 {
00128   double cnt = 0.0;
00129   MsgStream log(messageService(), name());
00130   std::string fullPath = "/Calib/MucCal";
00131   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00132   if( ! pMucCalibConst ){
00133     log << MSG::ERROR << "getCnt() can not access to MucCalibData via SmartPtr" << endreq;
00134   }else
00135   { 
00136     switch( m_fConfigMode ) 
00137     {  
00138       case 0 : 
00139               if( m_fUniformCnt < 0 ) 
00140                 cnt = pMucCalibConst->getUniformCnt();
00141               else 
00142                 cnt = m_fUniformCnt;
00143               break;
00144       case 1 :
00145               cnt = pMucCalibConst->getLayerCnt( layer );
00146               break;
00147       case 2 :
00148               cnt = pMucCalibConst->getBoxCnt( part, segment, layer );
00149               break;
00150       case 3 :
00151               cnt = pMucCalibConst->getStripCnt( part, segment, layer, strip ); 
00152               break;
00153       default: ;        
00154     }  
00155   }
00156   
00157   return cnt;     
00158 }

double MucCalibConstSvc::getEff ( int  part,
int  segment,
int  layer,
int  strip 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 89 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_fConfigMode, m_fUniformEff, m_pCalibDataSvc, and deljobs::string.

00090 {
00091   double eff = 0.0;
00092   MsgStream log(messageService(), name());
00093   //    log << MSG::INFO << "In MucCalibDataSvc" << endreq;
00094   std::string fullPath = "/Calib/MucCal";
00095   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00096   
00097   if( ! pMucCalibConst ){
00098     log << MSG::ERROR << "getEff() can not access to MucCalibData via SmartPtr" << endreq;
00099   }else
00100   {
00101     switch( m_fConfigMode ) 
00102     {  
00103       case 0 : 
00104               if( m_fUniformEff < 0 ) 
00105                 eff = pMucCalibConst->getUniformEff();
00106               else
00107                 eff = m_fUniformEff;
00108               break;
00109       case 1 :
00110               eff = pMucCalibConst->getLayerEff( layer );
00111               break;
00112       case 2 :
00113               eff = pMucCalibConst->getBoxEff( part, segment, layer );
00114               break;
00115       case 3 :
00116               eff = pMucCalibConst->getStripEff( part, segment, layer, strip ); 
00117               break;
00118       default: ;        
00119     }
00120   }
00121   
00122   return eff;     
00123 }

double MucCalibConstSvc::getLayerClst ( int  layer,
double  prob 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 414 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00415 {
00416   double fClst = 0.0;
00417   MsgStream log(messageService(), name());
00418   
00419   std::string fullPath = "/Calib/MucCal";
00420   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00421   if( ! pMucCalibConst ){
00422     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00423   }else {
00424     fClst= pMucCalibConst->getLayerClst( layer, prob );
00425   }
00426        
00427   return fClst; 
00428 }

double MucCalibConstSvc::getLayerCnt ( int  layer  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 366 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00367 {
00368   double fCnt = 0.0;
00369   MsgStream log(messageService(), name());
00370   
00371   std::string fullPath = "/Calib/MucCal";
00372   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00373   if( ! pMucCalibConst ){
00374     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00375   }else {
00376     fCnt= pMucCalibConst->getLayerCnt( layer );
00377   }
00378   
00379   return fCnt;
00380 }

double MucCalibConstSvc::getLayerEff ( int  layer  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 349 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00350 {
00351   double fEff = 0.0;
00352   MsgStream log(messageService(), name());
00353   
00354   std::string fullPath = "/Calib/MucCal";
00355   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00356   if( ! pMucCalibConst ){
00357     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00358   }else {
00359     fEff= pMucCalibConst->getLayerEff( layer );
00360   }
00361        
00362   // log << MSG::DEBUG << "Layer:\t" << layer << "\t" << fEff << endreq; 
00363   return fEff;
00364 }

double MucCalibConstSvc::getLayerNos ( int  layer  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 382 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00383 {
00384   double fNos = 0.0;
00385   MsgStream log(messageService(), name());
00386 
00387   std::string fullPath = "/Calib/MucCal";
00388   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00389   if( ! pMucCalibConst ){
00390     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00391   }else {
00392     fNos= pMucCalibConst->getLayerNos( layer );
00393   }
00394 
00395   return fNos;
00396 }

double MucCalibConstSvc::getLayerNosRatio ( int  layer  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 398 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00399 {
00400   double fNosRatio = 0.0;
00401   MsgStream log(messageService(), name());
00402 
00403   std::string fullPath = "/Calib/MucCal";
00404   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00405   if( ! pMucCalibConst ){
00406     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00407   }else {
00408     fNosRatio= pMucCalibConst->getLayerNosRatio( layer );
00409   }
00410 
00411   return fNosRatio;
00412 }

int MucCalibConstSvc::getLevel (  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 86 of file MucCalibConstSvc.cxx.

References m_fConfigMode.

00086 {return  m_fConfigMode;}

double MucCalibConstSvc::getNos ( int  part,
int  segment,
int  layer,
int  strip 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 161 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_fConfigMode, m_fUniformNos, m_pCalibDataSvc, and deljobs::string.

00162 {
00163   double nos = 0.0;
00164   MsgStream log(messageService(), name());
00165   std::string fullPath = "/Calib/MucCal";
00166   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00167   if( ! pMucCalibConst ){
00168     log << MSG::ERROR << "getNos() can not access to MucCalibData via SmartPtr" << endreq;
00169   }else
00170   { 
00171     switch( m_fConfigMode ) 
00172     {  
00173       case 0 : 
00174               if( m_fUniformNos < 0 ) 
00175                 nos = pMucCalibConst->getUniformNos();
00176               else 
00177                 nos = m_fUniformNos;
00178               break;
00179       case 1 :
00180               nos = pMucCalibConst->getLayerNos( layer );
00181               break;
00182       case 2 :
00183               nos = pMucCalibConst->getBoxNos( part, segment, layer );
00184               break;
00185       case 3 :
00186               nos = pMucCalibConst->getStripNos( part, segment, layer, strip ); 
00187               break;
00188       default: ;        
00189     }  
00190   }
00191   
00192   return nos;     
00193 }

double MucCalibConstSvc::getNosRatio ( int  part,
int  segment,
int  layer,
int  strip 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 196 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_fConfigMode, m_fUniformNosRatio, m_pCalibDataSvc, and deljobs::string.

00197 {
00198   double nosRatio = 0.0;
00199   MsgStream log(messageService(), name());
00200   std::string fullPath = "/Calib/MucCal";
00201   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00202   if( ! pMucCalibConst ){
00203     log << MSG::ERROR << "getNosRatio() can not access to MucCalibData via SmartPtr" << endreq;
00204   }else
00205   { 
00206     switch( m_fConfigMode ) 
00207     {  
00208       case 0 : 
00209               if( m_fUniformNosRatio < 0 ) 
00210                 nosRatio = pMucCalibConst->getUniformNosRatio();
00211               else 
00212                 nosRatio = m_fUniformNosRatio;
00213               break;
00214       case 1 :
00215               nosRatio = pMucCalibConst->getLayerNosRatio( layer );
00216               break;
00217       case 2 :
00218               nosRatio = pMucCalibConst->getBoxNosRatio( part, segment, layer );
00219               break;
00220       case 3 :
00221               nosRatio = pMucCalibConst->getStripNosRatio( part, segment, layer, strip ); 
00222               break;
00223       default: ;        
00224     }  
00225   }
00226   
00227   return nosRatio;     
00228 }

double MucCalibConstSvc::getStripCnt ( int  part,
int  segment,
int  layer,
int  strip 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 533 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00534 {
00535   double fCnt = 0.0;
00536   MsgStream log(messageService(), name());
00537   
00538   std::string fullPath = "/Calib/MucCal";
00539   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00540   if( ! pMucCalibConst ){
00541     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00542   }else {
00543     fCnt= pMucCalibConst->getStripCnt( part, segment, layer, strip );
00544   }
00545        
00546   return fCnt;  
00547 }

double MucCalibConstSvc::getStripEff ( int  part,
int  segment,
int  layer,
int  strip 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 513 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, Bes_Common::INFO, m_pCalibDataSvc, and deljobs::string.

00514 {
00515   double fEff = 0.0;
00516   MsgStream log(messageService(), name());
00517   
00518   log << MSG::INFO << "in  MucCalibConstSvc::getStripEff" << endreq;
00519   
00520   std::string fullPath = "/Calib/MucCal";
00521   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00522   
00523   if( ! pMucCalibConst ){
00524     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00525   }else {  
00526     fEff = pMucCalibConst->getStripEff( part, segment, layer, strip );
00527   }
00528      
00529   // log << MSG::DEBUG << "Strip:\t" << part << "\t" << segment <<"\t" << layer << "\t" << strip << "\t" << fEff << endreq; 
00530   return fEff;  
00531 }

double MucCalibConstSvc::getStripNos ( int  part,
int  segment,
int  layer,
int  strip 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 549 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00550 {
00551   double fNos = 0.0;
00552   MsgStream log(messageService(), name());
00553   
00554   std::string fullPath = "/Calib/MucCal";
00555   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00556   if( ! pMucCalibConst ){
00557     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00558   }else {
00559     fNos= pMucCalibConst->getStripNos( part, segment, layer, strip );
00560   }
00561        
00562   return fNos;  
00563 }

double MucCalibConstSvc::getStripNosRatio ( int  part,
int  segment,
int  layer,
int  strip 
) const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 565 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00566 {
00567   double fNosRatio = 0.0;
00568   MsgStream log(messageService(), name());
00569   
00570   std::string fullPath = "/Calib/MucCal";
00571   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00572   if( ! pMucCalibConst ){
00573     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00574   }else {
00575     fNosRatio= pMucCalibConst->getStripNosRatio( part, segment, layer, strip );
00576   }
00577        
00578   return fNosRatio;     
00579 }

double MucCalibConstSvc::getUniformClst (  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 332 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00333 {
00334   double fUniformClst = 0.0;
00335   MsgStream log(messageService(), name());
00336   
00337   std::string fullPath = "/Calib/MucCal";
00338   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00339   if( ! pMucCalibConst ){
00340     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00341   }else {
00342     fUniformClst= pMucCalibConst->getUniformClst();
00343   }
00344   
00345   return fUniformClst;
00346 }

double MucCalibConstSvc::getUniformCnt (  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 283 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00284 {
00285   double fUniformCnt = 0.0;
00286   MsgStream log(messageService(), name());
00287 
00288   std::string fullPath = "/Calib/MucCal";
00289   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00290   if( ! pMucCalibConst ){
00291     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00292   }else {
00293     fUniformCnt= pMucCalibConst->getUniformCnt();
00294   }
00295 
00296   return fUniformCnt;
00297 }

double MucCalibConstSvc::getUniformEff (  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 267 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00268 {
00269   double fUniformEff = 0.0;
00270   MsgStream log(messageService(), name());
00271   
00272   std::string fullPath = "/Calib/MucCal";
00273   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00274   if( ! pMucCalibConst ){
00275     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00276   }else {
00277     fUniformEff= pMucCalibConst->getUniformEff();
00278   }
00279      
00280   return fUniformEff;
00281 }

double MucCalibConstSvc::getUniformNos (  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 316 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00317 {
00318   double fUniformNos = 0.0;
00319   MsgStream log(messageService(), name());
00320   
00321   std::string fullPath = "/Calib/MucCal";
00322   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00323   if( ! pMucCalibConst ){
00324     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00325   }else {
00326     fUniformNos= pMucCalibConst->getUniformNos();
00327   }
00328   
00329   return fUniformNos;
00330 }

double MucCalibConstSvc::getUniformNosRatio (  )  const [inline, virtual]

Implements IMucCalibConstSvc.

Definition at line 299 of file MucCalibConstSvc.cxx.

References calibUtil::ERROR, m_pCalibDataSvc, and deljobs::string.

00300 {
00301   double fUniformNosRatio = 0.0;
00302   MsgStream log(messageService(), name());
00303 
00304   std::string fullPath = "/Calib/MucCal";
00305   SmartDataPtr<CalibData::MucCalibData> pMucCalibConst(m_pCalibDataSvc, fullPath);
00306   if( ! pMucCalibConst ){
00307     log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endreq;
00308   }else {
00309     fUniformNosRatio= pMucCalibConst->getUniformNosRatio();
00310   }
00311 
00312   return fUniformNosRatio;
00313 }

StatusCode MucCalibConstSvc::initialize (  )  [virtual]

Definition at line 56 of file MucCalibConstSvc.cxx.

References Bes_Common::FATAL, Bes_Common::INFO, m_fConfigMode, and m_pCalibDataSvc.

00057 {
00058   MsgStream log(messageService(), name());
00059   log << MSG::INFO << endreq << "initialize()" << endreq << endreq;
00060   log << MSG::INFO << "Config mode:\t" << m_fConfigMode << endreq;  
00061   StatusCode sc = Service::initialize();
00062   if( sc.isFailure() ) return sc;
00063   
00064   sc = service("CalibDataSvc", m_pCalibDataSvc, true);
00065   if( sc == StatusCode::SUCCESS ) {
00066     log << MSG::INFO << "Retrieve IDataProviderSvc" << endreq;
00067   }else{
00068     log << MSG::FATAL << "can not get IDataProviderSvc" << endreq;
00069   }
00070   
00071   return StatusCode::SUCCESS;
00072 }

static const InterfaceID& IMucCalibConstSvc::interfaceID (  )  [inline, static, inherited]

Definition at line 20 of file IMucCalibConstSvc.h.

References IID_IMucCalibConstSvc().

00020 { return IID_IMucCalibConstSvc; }

StatusCode MucCalibConstSvc::queryInterface ( const InterfaceID &  riid,
void **  ppvUnknown 
) [virtual]

Definition at line 46 of file MucCalibConstSvc.cxx.

References IID_IMucCalibConstSvc().

00047 {
00048   if( IID_IMucCalibConstSvc.versionMatch(riid) ){
00049     *ppvInterface = static_cast<IMucCalibConstSvc*> (this);
00050   } else {
00051     return Service::queryInterface(riid, ppvInterface);
00052   }
00053   return StatusCode::SUCCESS;
00054 }


Member Data Documentation

int MucCalibConstSvc::m_fConfigMode [private]

Definition at line 64 of file MucCalibConstSvc.h.

Referenced by getClst(), getCnt(), getEff(), getLevel(), getNos(), getNosRatio(), initialize(), and MucCalibConstSvc().

double MucCalibConstSvc::m_fUniformClst [private]

Definition at line 69 of file MucCalibConstSvc.h.

Referenced by getClst(), and MucCalibConstSvc().

double MucCalibConstSvc::m_fUniformCnt [private]

Definition at line 66 of file MucCalibConstSvc.h.

Referenced by getCnt().

double MucCalibConstSvc::m_fUniformEff [private]

Definition at line 65 of file MucCalibConstSvc.h.

Referenced by getEff(), and MucCalibConstSvc().

double MucCalibConstSvc::m_fUniformNos [private]

Definition at line 67 of file MucCalibConstSvc.h.

Referenced by getNos(), and MucCalibConstSvc().

double MucCalibConstSvc::m_fUniformNosRatio [private]

Definition at line 68 of file MucCalibConstSvc.h.

Referenced by getNosRatio().

IDataProviderSvc* MucCalibConstSvc::m_pCalibDataSvc [private]

Definition at line 63 of file MucCalibConstSvc.h.

Referenced by getBoxClst(), getBoxCnt(), getBoxEff(), getBoxNos(), getBoxNosRatio(), getClst(), getCnt(), getEff(), getLayerClst(), getLayerCnt(), getLayerEff(), getLayerNos(), getLayerNosRatio(), getNos(), getNosRatio(), getStripCnt(), getStripEff(), getStripNos(), getStripNosRatio(), getUniformClst(), getUniformCnt(), getUniformEff(), getUniformNos(), getUniformNosRatio(), and initialize().


Generated on Tue Nov 29 23:20:26 2016 for BOSS_7.0.2 by  doxygen 1.4.7