BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
MucCalibConstSvc Class Reference

#include <MucCalibConstSvc.h>

Inheritance diagram for MucCalibConstSvc:

Public Member Functions

 MucCalibConstSvc (const std::string &name, ISvcLocator *svcloc)
 ~MucCalibConstSvc ()
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

Detailed Description

Definition at line 19 of file MucCalibConstSvc.h.

Constructor & Destructor Documentation

◆ MucCalibConstSvc()

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

Definition at line 30 of file MucCalibConstSvc.cxx.

31 : base_class( name, svcloc ), m_pCalibDataSvc( 0 ) {
32 declareProperty( "ConfigMode", m_fConfigMode = 3 );
33 declareProperty( "UniformEff", m_fUniformEff = 0.95 );
34 declareProperty( "UniformCnt", m_fUniformEff = 0.05 );
35 declareProperty( "UniformNos", m_fUniformEff = 0.001 );
36 declareProperty( "UniformNosRatio", m_fUniformNos = 0.05 );
37 declareProperty( "UniformClst", m_fUniformClst = 4 );
38}

Referenced by MucCalibConstSvc().

◆ ~MucCalibConstSvc()

MucCalibConstSvc::~MucCalibConstSvc ( )

Definition at line 40 of file MucCalibConstSvc.cxx.

40{}

Member Function Documentation

◆ finalize()

StatusCode MucCalibConstSvc::finalize ( )
virtual

Definition at line 57 of file MucCalibConstSvc.cxx.

57 {
58 MsgStream log( msgSvc(), name() );
59 log << MSG::INFO << endmsg << "finalize()" << endmsg << endmsg;
60 return StatusCode::SUCCESS;
61}
msgSvc
IMessageSvc * msgSvc()
Definition ServiceAccessor.h:12

◆ getBoxClst()

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

Definition at line 394 of file MucCalibConstSvc.cxx.

394 {
395 double fClst = 0.0;
396 MsgStream log( msgSvc(), name() );
397
398 std::string fullPath = "/Calib/MucCal";
399 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
400 if ( !pMucCalibConst )
401 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
402 else { fClst = pMucCalibConst->getBoxClst( part, segment, layer, prob ); }
403
404 return fClst;
405}

◆ getBoxCnt()

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

Definition at line 355 of file MucCalibConstSvc.cxx.

355 {
356 double fCnt = 0.0;
357 MsgStream log( msgSvc(), name() );
358
359 std::string fullPath = "/Calib/MucCal";
360 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
361 if ( !pMucCalibConst )
362 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
363 else { fCnt = pMucCalibConst->getBoxCnt( part, segment, layer ); }
364
365 return fCnt;
366}

◆ getBoxEff()

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

Definition at line 340 of file MucCalibConstSvc.cxx.

340 {
341 double fEff = 0.0;
342 MsgStream log( msgSvc(), name() );
343
344 std::string fullPath = "/Calib/MucCal";
345 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
346 if ( !pMucCalibConst )
347 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
348 else { fEff = pMucCalibConst->getBoxEff( part, segment, layer ); }
349
350 // log << MSG::DEBUG << "Box:\t" << part << "\t" << segment <<"\t" << layer << "\t" << fEff
351 // << endmsg;
352 return fEff;
353}

◆ getBoxNos()

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

Definition at line 368 of file MucCalibConstSvc.cxx.

368 {
369 double fNos = 0.0;
370 MsgStream log( msgSvc(), name() );
371
372 std::string fullPath = "/Calib/MucCal";
373 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
374 if ( !pMucCalibConst )
375 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
376 else { fNos = pMucCalibConst->getBoxNos( part, segment, layer ); }
377
378 return fNos;
379}

◆ getBoxNosRatio()

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

Definition at line 381 of file MucCalibConstSvc.cxx.

381 {
382 double fNosRatio = 0.0;
383 MsgStream log( msgSvc(), name() );
384
385 std::string fullPath = "/Calib/MucCal";
386 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
387 if ( !pMucCalibConst )
388 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
389 else { fNosRatio = pMucCalibConst->getBoxNosRatio( part, segment, layer ); }
390
391 return fNosRatio;
392}

◆ getClst()

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

Definition at line 180 of file MucCalibConstSvc.cxx.

181 {
182 double cluster = 0.0;
183 MsgStream log( msgSvc(), name() );
184 std::string fullPath = "/Calib/MucCal";
185 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
186 if ( !pMucCalibConst )
187 { log << MSG::ERROR << "getClst() can not access to MucCalibData via SmartPtr" << endmsg; }
188 else
189 {
190 switch ( m_fConfigMode )
191 {
192 case 0:
193 if ( m_fUniformClst < 0 ) cluster = pMucCalibConst->getUniformClst();
194 else cluster = m_fUniformClst;
195 break;
196 case 1: cluster = pMucCalibConst->getLayerClst( layer, prob ); break;
197 case 2: cluster = pMucCalibConst->getBoxClst( part, segment, layer, prob ); break;
198 case 3: cluster = 0.0; break;
199 default:;
200 }
201 }
202
203 return cluster;
204}

◆ getCnt()

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

Definition at line 99 of file MucCalibConstSvc.cxx.

99 {
100 double cnt = 0.0;
101 MsgStream log( msgSvc(), name() );
102 std::string fullPath = "/Calib/MucCal";
103 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
104 if ( !pMucCalibConst )
105 { log << MSG::ERROR << "getCnt() can not access to MucCalibData via SmartPtr" << endmsg; }
106 else
107 {
108 switch ( m_fConfigMode )
109 {
110 case 0:
111 if ( m_fUniformCnt < 0 ) cnt = pMucCalibConst->getUniformCnt();
112 else cnt = m_fUniformCnt;
113 break;
114 case 1: cnt = pMucCalibConst->getLayerCnt( layer ); break;
115 case 2: cnt = pMucCalibConst->getBoxCnt( part, segment, layer ); break;
116 case 3: cnt = pMucCalibConst->getStripCnt( part, segment, layer, strip ); break;
117 default:;
118 }
119 }
120
121 return cnt;
122}

◆ getEff()

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

Definition at line 71 of file MucCalibConstSvc.cxx.

71 {
72 double eff = 0.0;
73 MsgStream log( msgSvc(), name() );
74 // log << MSG::INFO << "In MucCalibDataSvc" << endmsg;
75 std::string fullPath = "/Calib/MucCal";
76 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
77
78 if ( !pMucCalibConst )
79 { log << MSG::ERROR << "getEff() can not access to MucCalibData via SmartPtr" << endmsg; }
80 else
81 {
82 switch ( m_fConfigMode )
83 {
84 case 0:
85 if ( m_fUniformEff < 0 ) eff = pMucCalibConst->getUniformEff();
86 else eff = m_fUniformEff;
87 break;
88 case 1: eff = pMucCalibConst->getLayerEff( layer ); break;
89 case 2: eff = pMucCalibConst->getBoxEff( part, segment, layer ); break;
90 case 3: eff = pMucCalibConst->getStripEff( part, segment, layer, strip ); break;
91 default:;
92 }
93 }
94
95 return eff;
96}

◆ getLayerClst()

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

Definition at line 326 of file MucCalibConstSvc.cxx.

326 {
327 double fClst = 0.0;
328 MsgStream log( msgSvc(), name() );
329
330 std::string fullPath = "/Calib/MucCal";
331 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
332 if ( !pMucCalibConst )
333 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
334 else { fClst = pMucCalibConst->getLayerClst( layer, prob ); }
335
336 return fClst;
337}

◆ getLayerCnt()

double MucCalibConstSvc::getLayerCnt ( int layer) const
inline

Definition at line 287 of file MucCalibConstSvc.cxx.

287 {
288 double fCnt = 0.0;
289 MsgStream log( msgSvc(), name() );
290
291 std::string fullPath = "/Calib/MucCal";
292 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
293 if ( !pMucCalibConst )
294 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
295 else { fCnt = pMucCalibConst->getLayerCnt( layer ); }
296
297 return fCnt;
298}

◆ getLayerEff()

double MucCalibConstSvc::getLayerEff ( int layer) const
inline

Definition at line 273 of file MucCalibConstSvc.cxx.

273 {
274 double fEff = 0.0;
275 MsgStream log( msgSvc(), name() );
276
277 std::string fullPath = "/Calib/MucCal";
278 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
279 if ( !pMucCalibConst )
280 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
281 else { fEff = pMucCalibConst->getLayerEff( layer ); }
282
283 // log << MSG::DEBUG << "Layer:\t" << layer << "\t" << fEff << endmsg;
284 return fEff;
285}

◆ getLayerNos()

double MucCalibConstSvc::getLayerNos ( int layer) const
inline

Definition at line 300 of file MucCalibConstSvc.cxx.

300 {
301 double fNos = 0.0;
302 MsgStream log( msgSvc(), name() );
303
304 std::string fullPath = "/Calib/MucCal";
305 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
306 if ( !pMucCalibConst )
307 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
308 else { fNos = pMucCalibConst->getLayerNos( layer ); }
309
310 return fNos;
311}

◆ getLayerNosRatio()

double MucCalibConstSvc::getLayerNosRatio ( int layer) const
inline

Definition at line 313 of file MucCalibConstSvc.cxx.

313 {
314 double fNosRatio = 0.0;
315 MsgStream log( msgSvc(), name() );
316
317 std::string fullPath = "/Calib/MucCal";
318 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
319 if ( !pMucCalibConst )
320 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
321 else { fNosRatio = pMucCalibConst->getLayerNosRatio( layer ); }
322
323 return fNosRatio;
324}

◆ getLevel()

int MucCalibConstSvc::getLevel ( ) const
inline

Definition at line 68 of file MucCalibConstSvc.cxx.

68{ return m_fConfigMode; }

◆ getNos()

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

Definition at line 125 of file MucCalibConstSvc.cxx.

125 {
126 double nos = 0.0;
127 MsgStream log( msgSvc(), name() );
128 std::string fullPath = "/Calib/MucCal";
129 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
130 if ( !pMucCalibConst )
131 { log << MSG::ERROR << "getNos() can not access to MucCalibData via SmartPtr" << endmsg; }
132 else
133 {
134 switch ( m_fConfigMode )
135 {
136 case 0:
137 if ( m_fUniformNos < 0 ) nos = pMucCalibConst->getUniformNos();
138 else nos = m_fUniformNos;
139 break;
140 case 1: nos = pMucCalibConst->getLayerNos( layer ); break;
141 case 2: nos = pMucCalibConst->getBoxNos( part, segment, layer ); break;
142 case 3: nos = pMucCalibConst->getStripNos( part, segment, layer, strip ); break;
143 default:;
144 }
145 }
146
147 return nos;
148}

◆ getNosRatio()

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

Definition at line 151 of file MucCalibConstSvc.cxx.

152 {
153 double nosRatio = 0.0;
154 MsgStream log( msgSvc(), name() );
155 std::string fullPath = "/Calib/MucCal";
156 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
157 if ( !pMucCalibConst )
158 {
159 log << MSG::ERROR << "getNosRatio() can not access to MucCalibData via SmartPtr" << endmsg;
160 }
161 else
162 {
163 switch ( m_fConfigMode )
164 {
165 case 0:
166 if ( m_fUniformNosRatio < 0 ) nosRatio = pMucCalibConst->getUniformNosRatio();
167 else nosRatio = m_fUniformNosRatio;
168 break;
169 case 1: nosRatio = pMucCalibConst->getLayerNosRatio( layer ); break;
170 case 2: nosRatio = pMucCalibConst->getBoxNosRatio( part, segment, layer ); break;
171 case 3: nosRatio = pMucCalibConst->getStripNosRatio( part, segment, layer, strip ); break;
172 default:;
173 }
174 }
175
176 return nosRatio;
177}

◆ getStripCnt()

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

Definition at line 427 of file MucCalibConstSvc.cxx.

428 {
429 double fCnt = 0.0;
430 MsgStream log( msgSvc(), name() );
431
432 std::string fullPath = "/Calib/MucCal";
433 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
434 if ( !pMucCalibConst )
435 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
436 else { fCnt = pMucCalibConst->getStripCnt( part, segment, layer, strip ); }
437
438 return fCnt;
439}

◆ getStripEff()

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

Definition at line 408 of file MucCalibConstSvc.cxx.

409 {
410 double fEff = 0.0;
411 MsgStream log( msgSvc(), name() );
412
413 log << MSG::INFO << "in MucCalibConstSvc::getStripEff" << endmsg;
414
415 std::string fullPath = "/Calib/MucCal";
416 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
417
418 if ( !pMucCalibConst )
419 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
420 else { fEff = pMucCalibConst->getStripEff( part, segment, layer, strip ); }
421
422 // log << MSG::DEBUG << "Strip:\t" << part << "\t" << segment <<"\t" << layer << "\t" <<
423 // strip << "\t" << fEff << endmsg;
424 return fEff;
425}

◆ getStripNos()

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

Definition at line 441 of file MucCalibConstSvc.cxx.

442 {
443 double fNos = 0.0;
444 MsgStream log( msgSvc(), name() );
445
446 std::string fullPath = "/Calib/MucCal";
447 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
448 if ( !pMucCalibConst )
449 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
450 else { fNos = pMucCalibConst->getStripNos( part, segment, layer, strip ); }
451
452 return fNos;
453}

◆ getStripNosRatio()

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

Definition at line 455 of file MucCalibConstSvc.cxx.

456 {
457 double fNosRatio = 0.0;
458 MsgStream log( msgSvc(), name() );
459
460 std::string fullPath = "/Calib/MucCal";
461 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
462 if ( !pMucCalibConst )
463 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
464 else { fNosRatio = pMucCalibConst->getStripNosRatio( part, segment, layer, strip ); }
465
466 return fNosRatio;
467}

◆ getUniformClst()

double MucCalibConstSvc::getUniformClst ( ) const
inline

Definition at line 259 of file MucCalibConstSvc.cxx.

259 {
260 double fUniformClst = 0.0;
261 MsgStream log( msgSvc(), name() );
262
263 std::string fullPath = "/Calib/MucCal";
264 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
265 if ( !pMucCalibConst )
266 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
267 else { fUniformClst = pMucCalibConst->getUniformClst(); }
268
269 return fUniformClst;
270}

◆ getUniformCnt()

double MucCalibConstSvc::getUniformCnt ( ) const
inline

Definition at line 220 of file MucCalibConstSvc.cxx.

220 {
221 double fUniformCnt = 0.0;
222 MsgStream log( msgSvc(), name() );
223
224 std::string fullPath = "/Calib/MucCal";
225 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
226 if ( !pMucCalibConst )
227 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
228 else { fUniformCnt = pMucCalibConst->getUniformCnt(); }
229
230 return fUniformCnt;
231}

◆ getUniformEff()

double MucCalibConstSvc::getUniformEff ( ) const
inline

Definition at line 207 of file MucCalibConstSvc.cxx.

207 {
208 double fUniformEff = 0.0;
209 MsgStream log( msgSvc(), name() );
210
211 std::string fullPath = "/Calib/MucCal";
212 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
213 if ( !pMucCalibConst )
214 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
215 else { fUniformEff = pMucCalibConst->getUniformEff(); }
216
217 return fUniformEff;
218}

◆ getUniformNos()

double MucCalibConstSvc::getUniformNos ( ) const
inline

Definition at line 246 of file MucCalibConstSvc.cxx.

246 {
247 double fUniformNos = 0.0;
248 MsgStream log( msgSvc(), name() );
249
250 std::string fullPath = "/Calib/MucCal";
251 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
252 if ( !pMucCalibConst )
253 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
254 else { fUniformNos = pMucCalibConst->getUniformNos(); }
255
256 return fUniformNos;
257}

◆ getUniformNosRatio()

double MucCalibConstSvc::getUniformNosRatio ( ) const
inline

Definition at line 233 of file MucCalibConstSvc.cxx.

233 {
234 double fUniformNosRatio = 0.0;
235 MsgStream log( msgSvc(), name() );
236
237 std::string fullPath = "/Calib/MucCal";
238 SmartDataPtr<CalibData::MucCalibData> pMucCalibConst( m_pCalibDataSvc, fullPath );
239 if ( !pMucCalibConst )
240 { log << MSG::ERROR << "can not access to MucCalibData via SmartPtr" << endmsg; }
241 else { fUniformNosRatio = pMucCalibConst->getUniformNosRatio(); }
242
243 return fUniformNosRatio;
244}

◆ initialize()

StatusCode MucCalibConstSvc::initialize ( )
virtual

Definition at line 42 of file MucCalibConstSvc.cxx.

42 {
43 MsgStream log( msgSvc(), name() );
44 log << MSG::INFO << endmsg << "initialize()" << endmsg << endmsg;
45 log << MSG::INFO << "Config mode:\t" << m_fConfigMode << endmsg;
46 StatusCode sc = Service::initialize();
47 if ( sc.isFailure() ) return sc;
48
49 sc = service( "CalibDataSvc", m_pCalibDataSvc, true );
50 if ( sc == StatusCode::SUCCESS )
51 { log << MSG::INFO << "Retrieve IDataProviderSvc" << endmsg; }
52 else { log << MSG::FATAL << "can not get IDataProviderSvc" << endmsg; }
53
54 return StatusCode::SUCCESS;
55}
The documentation for this class was generated from the following files: