00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #include "GaudiKernel/IInterface.h"
00011 #include "GaudiKernel/StatusCode.h"
00012
00013 #include "GaudiKernel/SvcFactory.h"
00014 #include "GaudiKernel/MsgStream.h"
00015
00016 #include "GaudiKernel/ISvcLocator.h"
00017 #include "GaudiKernel/Bootstrap.h"
00018
00019 #include "GaudiKernel/IDataProviderSvc.h"
00020 #include "GaudiKernel/SmartDataPtr.h"
00021 #include "GaudiKernel/DataSvc.h"
00022
00023 #include "CalibData/CalibModel.h"
00024 #include "CalibData/Muc/MucCalibData.h"
00025 #include "CalibDataSvc/ICalibRootSvc.h"
00026 #include "CalibDataSvc/CalibDataSvc.h"
00027
00028 #include "MucCalibConstSvc/MucCalibConstSvc.h"
00029
00030
00031
00032
00033 MucCalibConstSvc::MucCalibConstSvc( const std::string& name, ISvcLocator* svcloc) : 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 }
00043
00044 MucCalibConstSvc::~MucCalibConstSvc() { }
00045
00046 StatusCode MucCalibConstSvc::queryInterface(const InterfaceID& riid, void** ppvInterface)
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 }
00055
00056 StatusCode MucCalibConstSvc::initialize()
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 }
00073
00074 StatusCode MucCalibConstSvc::finalize()
00075 {
00076 MsgStream log(messageService(), name());
00077 log << MSG::INFO << endreq << "finalize()" << endreq << endreq;
00078 return StatusCode::SUCCESS;
00079 }
00080
00081
00082
00083
00084
00085
00086 inline int MucCalibConstSvc::getLevel() const {return m_fConfigMode;}
00087
00088
00089 inline double MucCalibConstSvc::getEff(int part, int segment, int layer, int strip ) const
00090 {
00091 double eff = 0.0;
00092 MsgStream log(messageService(), name());
00093
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 }
00124
00125
00126 inline double MucCalibConstSvc::getCnt(int part, int segment, int layer, int strip ) const
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 }
00159
00160
00161 inline double MucCalibConstSvc::getNos(int part, int segment, int layer, int strip ) const
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 }
00194
00195
00196 inline double MucCalibConstSvc::getNosRatio(int part, int segment, int layer, int strip ) const
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 }
00229
00230
00231 inline double MucCalibConstSvc::getClst(int part, int segment, int layer, double prob ) const
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 }
00264
00265
00266
00267 inline double MucCalibConstSvc::getUniformEff() const
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 }
00282
00283 inline double MucCalibConstSvc::getUniformCnt() const
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 }
00298
00299 inline double MucCalibConstSvc::getUniformNosRatio() const
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 }
00314
00315
00316 inline double MucCalibConstSvc::getUniformNos() const
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 }
00331
00332 inline double MucCalibConstSvc::getUniformClst() const
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 }
00347
00348
00349 inline double MucCalibConstSvc::getLayerEff( int layer ) const
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
00363 return fEff;
00364 }
00365
00366 inline double MucCalibConstSvc::getLayerCnt( int layer ) const
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 }
00381
00382 inline double MucCalibConstSvc::getLayerNos( int layer ) const
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 }
00397
00398 inline double MucCalibConstSvc::getLayerNosRatio( int layer ) const
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 }
00413
00414 double MucCalibConstSvc::getLayerClst( int layer, double prob ) const
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 }
00429
00430
00431 inline double MucCalibConstSvc::getBoxEff( int part, int segment, int layer ) const
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
00445 return fEff;
00446 }
00447
00448 inline double MucCalibConstSvc::getBoxCnt( int part, int segment, int layer ) const
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 }
00463
00464 inline double MucCalibConstSvc::getBoxNos( int part, int segment, int layer ) const
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 }
00479
00480 inline double MucCalibConstSvc::getBoxNosRatio( int part, int segment, int layer ) const
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 }
00495
00496 double MucCalibConstSvc::getBoxClst( int part, int segment, int layer, double prob ) const
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 }
00511
00512
00513 inline double MucCalibConstSvc::getStripEff( int part, int segment, int layer, int strip ) const
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
00530 return fEff;
00531 }
00532
00533 inline double MucCalibConstSvc::getStripCnt( int part, int segment, int layer, int strip ) const
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 }
00548
00549 inline double MucCalibConstSvc::getStripNos( int part, int segment, int layer, int strip ) const
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 }
00564
00565 inline double MucCalibConstSvc::getStripNosRatio( int part, int segment, int layer, int strip ) const
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 }
00580
00581