BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
MucCalibMgr.cxx
Go to the documentation of this file.
1//------------------------------------------------------------------------------|
2// [File ]: MucCalibMgr.cxx |
3// [Brief ]: Manager of MUC calibration algrithom |
4// [Author]: Xie Yuguang, <ygxie@mail.ihep.ac.cn> |
5// [Date ]: Mar 28, 2006 |
6// [Log ]: See ChangLog |
7//------------------------------------------------------------------------------|
8#include "CLHEP/Geometry/Point3D.h"
9#include "CLHEP/Vector/LorentzVector.h"
10#include "CLHEP/Vector/ThreeVector.h"
11#include "CLHEP/Vector/TwoVector.h"
12#include "GaudiKernel/Algorithm.h"
13#include "GaudiKernel/Bootstrap.h"
14#include "GaudiKernel/IDataProviderSvc.h"
15#include "GaudiKernel/IHistogramSvc.h"
16#include "GaudiKernel/INTupleSvc.h"
17#include "GaudiKernel/ISvcLocator.h"
18#include "GaudiKernel/MsgStream.h"
19#include "GaudiKernel/NTuple.h"
20#include "GaudiKernel/PropertyMgr.h"
21#include "GaudiKernel/SmartDataLocator.h"
22#include "GaudiKernel/SmartDataPtr.h"
23#include <cstdio>
24#include <fstream>
25#include <iostream>
26
27#include "DstEvent/TofHitStatus.h"
28#include "EmcRecEventModel/RecEmcEventModel.h"
29#include "EvTimeEvent/RecEsTime.h"
30#include "EventModel/EventHeader.h"
31#include "EventModel/EventModel.h"
32#include "Identifier/Identifier.h"
33#include "Identifier/MucID.h"
34#include "McTruth/McKine.h"
35#include "McTruth/McParticle.h"
36#include "McTruth/MucMcHit.h"
37#include "MdcRecEvent/RecMdcTrack.h"
38#include "MucRawEvent/MucDigi.h"
39#include "MucRecEvent/MucRecHit.h"
40#include "MucRecEvent/MucRecHitContainer.h"
41#include "MucRecEvent/RecMucTrack.h"
42#include "TofRecEvent/RecTofTrack.h"
43// #include "ReconEvent/ReconEvent.h"
44
45#include "MucCalib/MucBoxCal.h"
46#include "MucCalib/MucCalibMgr.h"
47#include "MucCalib/MucMark.h"
48#include "MucCalib/MucStripCal.h"
49#include "MucCalib/MucStructConst.h"
50
51using CLHEP::Hep2Vector;
52using CLHEP::Hep3Vector;
53using CLHEP::HepLorentzVector;
54using namespace std;
55using namespace Event;
56
57//------------------------------------------- Constructor
58//-----------------------------------------
59MucCalibMgr::MucCalibMgr( std::vector<double> jobInfo, std::vector<int> configInfo,
60 std::string outputFile ) {
61 MsgStream log( msgSvc, "MucCalibMgr" );
62 log << MSG::INFO << "-------Initializing------- " << endmsg;
63
64 // init Gaudi service
65 log << MSG::INFO << "Initialize Gaudi service" << endmsg;
66 Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
67 ntupleSvc = NULL;
68 eventSvc = NULL;
69
70 m_jobStart = clock();
71
72 // init parameters
73 log << MSG::INFO << "Initialize parameters" << endmsg;
74
75 m_vs = jobInfo[0];
76 m_hv = jobInfo[1];
77 m_th = jobInfo[2];
78
79 if ( jobInfo[3] <= 0 ) m_er = TRIGGER_RATE; // 4000Hz
80 else m_er = jobInfo[3];
81
82 if ( jobInfo[4] <= 0 || jobInfo[4] > 5 ) m_tag = 0;
83 else m_tag = jobInfo[4];
84
85 if ( configInfo[0] < 0 || configInfo[0] > 2 ) m_recMode = 0;
86 else m_recMode = configInfo[0];
87
88 m_usePad = configInfo[1];
89
90 if ( configInfo[2] < 0 || configInfo[2] > STRIP_INBOX_MAX )
91 m_effWindow = EFF_WINDOW; // 4 strip-width
92 else m_effWindow = configInfo[2];
93
94 if ( configInfo[3] < 0 || configInfo[3] > 4 ) m_clusterMode = DEFAULT_BUILD_MODE;
95 else m_clusterMode = configInfo[3];
96
97 m_clusterSave = configInfo[4];
98 m_checkEvent = configInfo[5];
99 m_dimuSelect = configInfo[6];
100 m_dimuOnly = configInfo[7];
101
102 m_outputFile = outputFile;
103
104 m_fdata = NULL;
105 if ( m_clusterMode == 1 && m_clusterSave == 1 )
106 m_fdata = new ofstream( "MucCluster.dat", ios::out );
107
108 m_fStartRun = m_fEndRun = 0;
109 m_currentRun = m_currentEvent = 0;
110 m_eventTag = 0;
111
112 for ( int i = 0; i < PART_MAX; i++ )
113 for ( int j = 0; j < SEGMENT_MAX; j++ )
114 for ( int k = 0; k < LAYER_MAX; k++ )
115 for ( int n = 0; n < STRIP_INBOX_MAX; n++ )
116 {
117 m_record[i][j][k][n][0] = 0;
118 m_record[i][j][k][n][1] = 0;
119 m_record[i][j][k][n][2] = 0;
120 m_record[i][j][k][n][3] = 0;
121 m_record[i][j][k][n][4] = 0;
122 }
123
124 for ( int i = 0; i < LAYER_MAX; i++ )
125 {
126 m_layerResults[0][i] = 0;
127 m_layerResults[1][i] = 0;
128 m_layerResults[2][i] = 0;
129 m_layerResults[3][i] = 0;
130 m_layerResults[4][i] = 0;
131 }
132
133 for ( int i = 0; i < BOX_MAX; i++ )
134 {
135 m_boxResults[0][i] = 0;
136 m_boxResults[1][i] = 0;
137 m_boxResults[2][i] = 0;
138 m_boxResults[3][i] = 0;
139 m_boxResults[4][i] = 0;
140 }
141
142 for ( int i = 0; i < STRIP_MAX; i++ )
143 {
144 m_stripResults[0][i] = 0;
145 m_stripResults[1][i] = 0;
146 m_stripResults[2][i] = 0;
147 m_stripResults[3][i] = 0;
148 // strip no cluster
149 }
150
151 m_fTotalDAQTime = 0;
152
153 m_ptrMucMark = new MucMark( 0, 0, 0, 0 );
154 m_ptrIdTr = new MucIdTransform();
155
156 m_digiCol.resize( 0 );
157 m_calHitCol.resize( 0 );
158 m_expHitCol.resize( 0 );
159 m_effHitCol.resize( 0 );
160 m_nosHitCol.resize( 0 );
161 m_clusterCol.resize( 0 );
162
163 for ( int i = 0; i < PART_MAX; i++ )
164 for ( int j = 0; j < SEGMENT_MAX; j++ ) { m_segDigiCol[i][j].resize( 0 ); }
165
166 // init Gaudi Ntuple
167 InitNtuple();
168
169 // init ROOT histograms
170 InitHisto();
171
172 // init Tree
173 InitConstTree();
174
175 // init area of units
176 InitArea();
177 log << MSG::INFO << "Initialize done!" << endmsg;
178}
179
180//----------------------------------------------- Destructor
181//--------------------------------------
182MucCalibMgr::~MucCalibMgr() {
183 ClearOnlineHisto();
184
185 ClearHistoLV2();
186 ClearHistoLV1();
187 ClearHistoLV0();
188 if ( m_usePad != 0 ) Clear2DEffHisto();
189
190 ClearClusterHisto();
191 ClearResHisto();
192 ClearConstTree();
193
194 if ( m_ptrMucMark ) delete m_ptrMucMark;
195 if ( m_ptrIdTr ) delete m_ptrIdTr;
196
197 m_digiCol.clear();
198 m_calHitCol.clear();
199 m_effHitCol.clear();
200 m_nosHitCol.clear();
201 m_clusterCol.clear();
202
203 for ( int i = 0; i < PART_MAX; i++ )
204 for ( int j = 0; j < SEGMENT_MAX; j++ ) { m_segDigiCol[i][j].clear(); }
205
206 if ( m_record ) delete[] m_record;
207 if ( m_layerResults ) delete[] m_layerResults;
208 if ( m_boxResults ) delete[] m_boxResults;
209 if ( m_stripResults ) delete[] m_stripResults;
210}
211
212// Clear online histograms
213StatusCode MucCalibMgr::ClearOnlineHisto() {
214 if ( m_hHitMapBarrel_Lay ) delete[] m_hHitMapBarrel_Lay;
215 if ( m_hHitMapEndcap_Lay ) delete[] m_hHitMapEndcap_Lay;
216 if ( m_hHitMapBarrel_Seg ) delete[] m_hHitMapBarrel_Seg;
217 if ( m_hHitMapEndcap_Seg ) delete[] m_hHitMapEndcap_Seg;
218
219 if ( m_hHitVsEvent ) delete m_hHitVsEvent;
220 if ( m_hTrackDistance ) delete m_hTrackDistance;
221 if ( m_hTrackPosPhiDiff ) delete m_hTrackPosPhiDiff;
222 if ( m_hTrackPosThetaDiff ) delete m_hTrackPosThetaDiff;
223 if ( m_hTrackMomPhiDiff ) delete m_hTrackMomPhiDiff;
224 if ( m_hTrackMomThetaDiff ) delete m_hTrackMomThetaDiff;
225 if ( m_hDimuTracksPosDiff ) delete m_hDimuTracksPosDiff;
226 if ( m_hDimuTracksMomDiff ) delete m_hDimuTracksMomDiff;
227 if ( m_hPhiCosTheta ) delete m_hPhiCosTheta;
228
229 return StatusCode::SUCCESS;
230}
231
232// Clear level 0 histograms
233StatusCode MucCalibMgr::ClearHistoLV0() {
234 if ( m_hBrLayerFire ) delete m_hBrLayerFire;
235 if ( m_hEcLayerFire ) delete m_hEcLayerFire;
236 if ( m_hLayerFire ) delete m_hLayerFire;
237 if ( m_hLayerExpHit ) delete m_hLayerExpHit;
238 if ( m_hLayerExpHit ) delete m_hLayerEffHit;
239 if ( m_hLayerNosHit ) delete m_hLayerNosHit;
240 if ( m_hLayerEff ) delete m_hLayerEff;
241 if ( m_hLayerNosRatio ) delete m_hLayerNosRatio;
242 if ( m_hLayerArea ) delete m_hLayerArea;
243 if ( m_hLayerNos ) delete m_hLayerNos;
244 if ( m_hLayerCnt ) delete m_hLayerCnt;
245
246 return StatusCode::SUCCESS;
247}
248
249// Clear level 1 histograms
250StatusCode MucCalibMgr::ClearHistoLV1() {
251 if ( m_hBoxFire ) delete m_hBoxFire;
252 if ( m_hBoxExpHit ) delete m_hBoxExpHit;
253 if ( m_hBoxEffHit ) delete m_hBoxEffHit;
254 if ( m_hBoxNosHit ) delete m_hBoxNosHit;
255 if ( m_hBoxEff ) delete m_hBoxEff;
256 if ( m_hBoxNosRatio ) delete m_hBoxNosRatio;
257 if ( m_hBoxArea ) delete m_hBoxArea;
258 if ( m_hBoxNos ) delete m_hBoxNos;
259 if ( m_hBoxCnt ) delete m_hBoxCnt;
260
261 return StatusCode::SUCCESS;
262}
263
264// Clear level 2 histograms
265StatusCode MucCalibMgr::ClearHistoLV2() {
266 for ( int i = 0; i < BOX_MAX; i++ )
267 {
268 if ( m_hStripFireMap[i] ) delete m_hStripFireMap[i];
269 if ( m_hStripExpHitMap[i] ) delete m_hStripExpHitMap[i];
270 if ( m_hStripEffHitMap[i] ) delete m_hStripEffHitMap[i];
271 if ( m_hStripNosHitMap[i] ) delete m_hStripNosHitMap[i];
272 if ( m_hStripEffMap[i] ) delete m_hStripEffMap[i];
273 if ( m_hStripNosRatioMap[i] ) delete m_hStripNosRatioMap[i];
274 }
275
276 if ( m_hStripFire ) delete m_hStripFire;
277 if ( m_hStripExpHit ) delete m_hStripExpHit;
278 if ( m_hStripEffHit ) delete m_hStripEffHit;
279 if ( m_hStripNosHit ) delete m_hStripNosHit;
280 if ( m_hStripEff ) delete m_hStripEff;
281 if ( m_hStripNosRatio ) delete m_hStripNosRatio;
282 if ( m_hStripArea ) delete m_hStripArea;
283 if ( m_hStripNos ) delete m_hStripNos;
284 if ( m_hStripCnt ) delete m_hStripCnt;
285
286 return StatusCode::SUCCESS;
287}
288
289// Clear 2D eff histogrames
290StatusCode MucCalibMgr::Clear2DEffHisto() {
291
292 for ( int i = 0; i < PART_MAX; i++ )
293 for ( int j = 0; j < ( ( i == BRID ) ? B_SEG_NUM : E_SEG_NUM ); j++ )
294 for ( int k = 0; k < ( ( i == BRID ) ? B_LAY_NUM : E_LAY_NUM ); k++ )
295 {
296 if ( m_h2DExpMap[i][j][k] ) delete m_h2DExpMap[i][j][k];
297 if ( m_h2DHitMap[i][j][k] ) delete m_h2DHitMap[i][j][k];
298 if ( m_h2DEffMap[i][j][k] ) delete m_h2DEffMap[i][j][k];
299 }
300
301 return StatusCode::SUCCESS;
302}
303
304// Clear cluster histograms
305StatusCode MucCalibMgr::ClearClusterHisto() {
306 for ( int i = 0; i < LAYER_MAX; i++ )
307 {
308 if ( m_hLayerCluster[i] ) delete m_hLayerCluster[i];
309 }
310
311 for ( int i = 0; i < BOX_MAX; i++ )
312 {
313 if ( m_hBoxCluster[i] ) delete m_hBoxCluster[i];
314 }
315
316 if ( m_hLayerClusterCmp ) delete m_hLayerClusterCmp;
317 if ( m_hBoxClusterCmp ) delete m_hBoxClusterCmp;
318
319 return StatusCode::SUCCESS;
320}
321
322// Clear resolution histograms
323StatusCode MucCalibMgr::ClearResHisto() {
324 for ( int i = 0; i < B_LAY_NUM; i++ )
325 {
326 if ( m_hBarrelResDist[i] ) delete m_hBarrelResDist[i];
327 }
328 for ( int i = 0; i < E_LAY_NUM; i++ )
329 {
330 if ( m_hEndcapResDist[i] ) delete m_hEndcapResDist[i];
331 }
332
333 if ( m_hBarrelResComp[0] ) delete m_hBarrelResComp[0];
334 if ( m_hBarrelResComp[1] ) delete m_hBarrelResComp[1];
335 if ( m_hEndcapResComp[0] ) delete m_hEndcapResComp[0];
336 if ( m_hEndcapResComp[1] ) delete m_hEndcapResComp[1];
337
338 return StatusCode::SUCCESS;
339}
340
341// Clear Tree
342StatusCode MucCalibMgr::ClearConstTree() {
343
344 if ( m_tJobLog ) delete m_tJobLog;
345 if ( m_tStatLog ) delete m_tStatLog;
346 if ( m_tLayConst ) delete m_tLayConst;
347 if ( m_tBoxConst ) delete m_tBoxConst;
348 if ( m_tStrConst ) delete m_tStrConst;
349
350 return StatusCode::SUCCESS;
351}
352
353//-------------------------------------------------------------------------------------------------
354//-------------------------------- Member functions for initializing
355//------------------------------
356//-------------------------------------------------------------------------------------------------
357
358// init Ntuples
359StatusCode MucCalibMgr::InitNtuple() {
360 MsgStream log( msgSvc, "MucCalibMgr" );
361 log << MSG::INFO << "Initialize NTuples" << endmsg;
362
363 // Book ntuple
364 Gaudi::svcLocator()->service( "NTupleSvc", ntupleSvc );
365
366 StatusCode sc;
367
368 // event log
369 NTuplePtr nt1( ntupleSvc, "FILE450/EventLog" );
370 if ( nt1 ) { m_eventLogTuple = nt1; }
371 else
372 {
373 m_eventLogTuple =
374 ntupleSvc->book( "FILE450/EventLog", CLID_RowWiseTuple, "MucCalibConst N-Tuple" );
375 if ( m_eventLogTuple )
376 {
377 sc = m_eventLogTuple->addItem( "event_id", m_ntEventId );
378 sc = m_eventLogTuple->addItem( "event_tag", m_ntEventTag );
379 sc = m_eventLogTuple->addItem( "start_time", m_ntEsTime );
380 sc = m_eventLogTuple->addItem( "digi_num", m_ntDigiNum );
381 sc = m_eventLogTuple->addItem( "track_num", m_ntTrackNum );
382 sc = m_eventLogTuple->addItem( "exphit_num", m_ntExpHitNum );
383 sc = m_eventLogTuple->addItem( "effhit_num", m_ntEffHitNum );
384 sc = m_eventLogTuple->addItem( "noshit_num", m_ntNosHitNum );
385 sc = m_eventLogTuple->addItem( "cluster_num", m_ntClusterNum );
386 sc = m_eventLogTuple->addItem( "event_time", m_ntEventTime );
387 }
388 else
389 {
390 log << MSG::ERROR << "Cannot book N-tuple:" << long( m_eventLogTuple ) << endmsg;
391 return StatusCode::FAILURE;
392 }
393 }
394
395 // track info
396
397 NTuplePtr nt2( ntupleSvc, "FILE450/MdcTrkInfo" );
398 if ( nt2 ) { m_mdcTrkInfoTuple = nt2; }
399 else
400 {
401 m_mdcTrkInfoTuple =
402 ntupleSvc->book( "FILE450/MdcTrkInfo", CLID_RowWiseTuple, "MucCalibConst N-Tuple" );
403 if ( m_mdcTrkInfoTuple )
404 {
405 sc = m_mdcTrkInfoTuple->addItem( "charge", m_charge );
406 sc = m_mdcTrkInfoTuple->addItem( "mdcpx", m_mdcpx );
407 sc = m_mdcTrkInfoTuple->addItem( "mdcpy", m_mdcpy );
408 sc = m_mdcTrkInfoTuple->addItem( "mdcpz", m_mdcpz );
409 sc = m_mdcTrkInfoTuple->addItem( "mdcpt", m_mdcpt );
410 sc = m_mdcTrkInfoTuple->addItem( "mdcpp", m_mdcpp );
411 sc = m_mdcTrkInfoTuple->addItem( "mdcphi", m_mdcphi );
412 sc = m_mdcTrkInfoTuple->addItem( "mdctheta", m_mdctheta );
413 }
414 else
415 {
416 log << MSG::ERROR << "Cannot book N-tuple:" << long( m_mdcTrkInfoTuple ) << endmsg;
417 return StatusCode::FAILURE;
418 }
419 }
420
421 NTuplePtr nt3( ntupleSvc, "FILE450/TrackInfo" );
422 if ( nt3 ) { m_trackInfoTuple = nt3; }
423 else
424 {
425 m_trackInfoTuple =
426 ntupleSvc->book( "FILE450/TrackInfo", CLID_RowWiseTuple, "MucCalibConst N-Tuple" );
427 if ( m_trackInfoTuple )
428 {
429 sc = m_trackInfoTuple->addItem( "track_event", m_ntTrackEvent );
430 sc = m_trackInfoTuple->addItem( "track_tag", m_ntTrackTag );
431 sc = m_trackInfoTuple->addItem( "track_hits", m_ntTrackHits );
432 sc = m_trackInfoTuple->addItem( "segment_fly", m_ntTrackSegFly );
433 sc = m_trackInfoTuple->addItem( "layer_fly_a", m_ntTrackLayFlyA );
434 sc = m_trackInfoTuple->addItem( "layer_fly_b", m_ntTrackLayFlyB );
435 sc = m_trackInfoTuple->addItem( "layer_fly_c", m_ntTrackLayFlyC );
436 sc = m_trackInfoTuple->addItem( "rec_mode", m_trkRecMode );
437 sc = m_trackInfoTuple->addItem( "chi2", m_chi2 );
438 sc = m_trackInfoTuple->addItem( "px", m_px );
439 sc = m_trackInfoTuple->addItem( "py", m_py );
440 sc = m_trackInfoTuple->addItem( "pz", m_pz );
441 sc = m_trackInfoTuple->addItem( "pt", m_pt );
442 sc = m_trackInfoTuple->addItem( "pp", m_pp );
443 sc = m_trackInfoTuple->addItem( "r", m_r );
444 sc = m_trackInfoTuple->addItem( "costheta", m_cosTheta );
445 sc = m_trackInfoTuple->addItem( "theta", m_theta );
446 sc = m_trackInfoTuple->addItem( "phi", m_phi );
447 sc = m_trackInfoTuple->addItem( "depth", m_depth );
448 sc = m_trackInfoTuple->addItem( "br_last_lay", m_brLastLayer );
449 sc = m_trackInfoTuple->addItem( "ec_last_lay", m_ecLastLayer );
450 sc = m_trackInfoTuple->addItem( "total_hits", m_totalHits );
451 sc = m_trackInfoTuple->addItem( "fired_layers", m_totalLayers );
452 sc = m_trackInfoTuple->addItem( "maxhits_in_layer", m_maxHitsInLayer );
453 }
454 else
455 {
456 log << MSG::ERROR << "Cannot book N-tuple:" << long( m_trackInfoTuple ) << endmsg;
457 return StatusCode::FAILURE;
458 }
459 }
460
461 // track collinearity
462 NTuplePtr nt4( ntupleSvc, "FILE450/TrackDiff" );
463 if ( nt4 ) { m_trackDiffTuple = nt4; }
464 else
465 {
466 m_trackDiffTuple =
467 ntupleSvc->book( "FILE450/TrackDiff", CLID_RowWiseTuple, "MucCalibConst N-Tuple" );
468 if ( m_trackDiffTuple )
469 {
470 sc = m_trackDiffTuple->addItem( "dimu_tag", m_ntDimuTag );
471 sc = m_trackDiffTuple->addItem( "pos_phi_diff", m_ntPosPhiDiff );
472 sc = m_trackDiffTuple->addItem( "pos_theta_diff", m_ntPosThetaDiff );
473 sc = m_trackDiffTuple->addItem( "mom_phi_diff", m_ntMomPhiDiff );
474 sc = m_trackDiffTuple->addItem( "mom_theta_diff", m_ntMomThetaDiff );
475 }
476 else
477 {
478 log << MSG::ERROR << "Cannot book N-tuple:" << long( m_trackDiffTuple ) << endmsg;
479 return StatusCode::FAILURE;
480 }
481 }
482
483 // cluster size
484 NTuplePtr nt5( ntupleSvc, "FILE450/ClusterSize" );
485 if ( nt5 ) { m_clusterSizeTuple = nt5; }
486 else
487 {
488 m_clusterSizeTuple =
489 ntupleSvc->book( "FILE450/ClusterSize", CLID_RowWiseTuple, "MucCalibConst N-Tuple" );
490 if ( m_clusterSizeTuple )
491 { sc = m_clusterSizeTuple->addItem( "cluster_size", m_ntClusterSize ); }
492 else
493 {
494 log << MSG::ERROR << "Cannot book N-tuple:" << long( m_clusterSizeTuple ) << endmsg;
495 return StatusCode::FAILURE;
496 }
497 }
498
499 // eff window
500 NTuplePtr nt6( ntupleSvc, "FILE450/EffWindow" );
501 if ( nt6 ) { m_effWindowTuple = nt6; }
502 else
503 {
504 m_effWindowTuple =
505 ntupleSvc->book( "FILE450/EffWindow", CLID_RowWiseTuple, "MucCalibConst N-Tuple" );
506 if ( m_effWindowTuple ) { sc = m_effWindowTuple->addItem( "hit_window", m_ntEffWindow ); }
507 else
508 {
509 log << MSG::ERROR << "Cannot book N-tuple:" << long( m_effWindowTuple ) << endmsg;
510 return StatusCode::FAILURE;
511 }
512 }
513 // res info
514 NTuplePtr nt7( ntupleSvc, "FILE450/ResInfo" );
515 if ( nt7 ) { m_resInfoTuple = nt7; }
516 else
517 {
518 m_resInfoTuple =
519 ntupleSvc->book( "FILE450/ResInfo", CLID_RowWiseTuple, "MucCalibConst N-Tuple" );
520 if ( m_resInfoTuple )
521 {
522 sc = m_resInfoTuple->addItem( "line_res", m_lineRes );
523 sc = m_resInfoTuple->addItem( "quad_res", m_quadRes );
524 sc = m_resInfoTuple->addItem( "extr_res", m_extrRes );
525 sc = m_resInfoTuple->addItem( "res_part", m_resPart );
526 sc = m_resInfoTuple->addItem( "res_segment", m_resSegment );
527 sc = m_resInfoTuple->addItem( "res_layer", m_resLayer );
528 sc = m_resInfoTuple->addItem( "res_fired", m_resFired );
529 sc = m_resInfoTuple->addItem( "res_mode", m_resMode );
530 }
531 else
532 {
533 log << MSG::ERROR << "Cannot book N-tuple:" << long( m_resInfoTuple ) << endmsg;
534 return StatusCode::FAILURE;
535 }
536 }
537
538 /*
539 NTuplePtr nt7(ntupleSvc, "FILE450/ResInfo");
540 if ( nt7 ) { m_resInfoTuple = nt7; }
541 else
542 {
543 m_resInfoTuple = ntupleSvc->book ("FILE450/ResInfo", CLID_ColumnWiseTuple, "MucCalibConst
544 N-Tuple"); if ( m_resInfoTuple ) { sc = m_resInfoTuple->addItem ("exp_num", m_nExpNum, 0,
545 30); sc = m_resInfoTuple->addIndexedItem ("res", m_nExpNum, m_res); sc =
546 m_resInfoTuple->addIndexedItem ("res_part", m_nExpNum, m_resPart); sc =
547 m_resInfoTuple->addIndexedItem ("res_segment", m_nExpNum, m_resSegment); sc =
548 m_resInfoTuple->addIndexedItem ("res_layer", m_nExpNum, m_resLayer); sc =
549 m_resInfoTuple->addIndexedItem ("res_fired", m_nExpNum, m_resFired);
550 }
551 else {
552 log << MSG::ERROR << "Cannot book N-tuple:" << long(m_resInfoTuple) << endmsg;
553 return StatusCode::FAILURE;
554 }
555 }
556
557 for(int i=0; i<24; i++ )
558 {
559 m_res[i] = 211;
560 m_resPart[i] = -1;
561 m_resSegment[i] = -1;
562 m_resLayer[i] = -1;
563 m_resFired[i] = false;
564 }
565 */
566
567 return StatusCode::SUCCESS;
568}
569
570// Initialize histogram maps of fired strips and reconstructed hits
571StatusCode MucCalibMgr::InitHisto() {
572 MsgStream log( msgSvc, "MucCalibMgr" );
573 log << MSG::INFO << "Initialize Histograms" << endmsg;
574
575 // Init online monitor histo
576 InitOnlineHisto();
577
578 // Init eff map and so on
579 InitHistoLV2();
580 InitHistoLV1();
581 InitHistoLV0();
582
583 // Init 2D eff map
584 if ( m_usePad != 0 ) Init2DEffHisto();
585
586 // Init cluster histo
587 InitClusterHisto();
588
589 // Init spacial resolution histo
590 InitResHisto();
591
592 return StatusCode::SUCCESS;
593}
594
595// Init histograme for online monitor
596StatusCode MucCalibMgr::InitOnlineHisto() {
597 char name[60];
598 char title[60];
599 int stripMax = 0;
600
601 // Init hit map
602 for ( int i = 0; i < B_LAY_NUM; i++ )
603 {
604 // According to layer
605 if ( i % 2 != 0 ) { stripMax = 96 * 7 + 112; }
606 else { stripMax = 48 * 8; }
607 sprintf( name, "HitMapBarrel_Lay_L%d", i );
608 sprintf( title, "Hit map in barrel layer %d", i );
609 m_hHitMapBarrel_Lay[i] = new TH1F( name, title, stripMax, 0, stripMax );
610
611 if ( i < E_LAY_NUM )
612 {
613 stripMax = 64 * 4; // 256
614 sprintf( name, "HitMapEastEndcap_L%d", i );
615 sprintf( title, "Hit map in east-endcap layer %d", i );
616 m_hHitMapEndcap_Lay[0][i] = new TH1F( name, title, stripMax, 0, stripMax );
617
618 sprintf( name, "HitMapWestEndcap_L%d", i );
619 sprintf( title, "Hit map in west-endcap layer %d", i );
620 m_hHitMapEndcap_Lay[1][i] = new TH1F( name, title, stripMax, 0, stripMax );
621 }
622 }
623
624 for ( int i = 0; i < B_SEG_NUM; i++ )
625 {
626 // According to segment
627 sprintf( name, "HitMapBarrel_Seg_S%d", i );
628 sprintf( title, "Hit map in barrel segment %d", i );
629 if ( i == 2 ) { stripMax = 48 * 5 + 112 * 4; } // 688
630 else { stripMax = 48 * 5 + 96 * 4; } // 624
631 m_hHitMapBarrel_Seg[i] = new TH1F( name, title, stripMax, 0, stripMax );
632
633 if ( i < E_SEG_NUM )
634 {
635 sprintf( name, "HitMapEastEndcap_S%d", i );
636 sprintf( title, "Hit map in east-endcap segment %d", i );
637 stripMax = 64 * 8; // 512
638 m_hHitMapEndcap_Seg[0][i] = new TH1F( name, title, stripMax, 0, stripMax );
639
640 sprintf( name, "HitMapWestEndcap_S%d", i );
641 sprintf( title, "Hit map in west-endcap segment %d", i );
642 m_hHitMapEndcap_Seg[1][i] = new TH1F( name, title, stripMax, 0, stripMax );
643 }
644 }
645
646 // Init histograms for online monitor
647 // 1D histograms
648 m_hHitVsEvent = new TH1F( "HitVsEvent", "Hit VS event", 10000, 0, 10000 );
649 m_hHitVsEvent->GetXaxis()->SetTitle( "Event NO." );
650 m_hHitVsEvent->GetXaxis()->CenterTitle();
651 m_hHitVsEvent->GetYaxis()->SetTitle( "Hits" );
652 m_hHitVsEvent->GetYaxis()->CenterTitle();
653
654 m_hTrackDistance = new TH1F( "TrackDistance", "Track distance", 1000, -500, 500 );
655 m_hTrackDistance->GetXaxis()->SetTitle(
656 "Distance of fit pos and hit pos on 1st layer [cm]" );
657 m_hTrackDistance->GetXaxis()->CenterTitle();
658
659 m_hTrackPosPhiDiff =
660 new TH1F( "TrackPosPhiDiff", "#Delta#phi of tracks pos", 720, -2 * PI, 2 * PI );
661 m_hTrackPosPhiDiff->GetXaxis()->SetTitle( "#Delta#phi [rad]" );
662 m_hTrackPosPhiDiff->GetXaxis()->CenterTitle();
663
664 m_hTrackPosThetaDiff =
665 new TH1F( "TrackPosThetaDiff", "#Delta#theta of tracks pos", 720, -2 * PI, 2 * PI );
666 m_hTrackPosThetaDiff->GetXaxis()->SetTitle( "#Delta#theta [rad]" );
667 m_hTrackPosThetaDiff->GetXaxis()->CenterTitle();
668
669 m_hTrackMomPhiDiff =
670 new TH1F( "TrackMomPhiDiff", "#Delta#phi of tracks mom", 720, -2 * PI, 2 * PI );
671 m_hTrackMomPhiDiff->GetXaxis()->SetTitle( "#Delta#phi [rad]" );
672 m_hTrackMomPhiDiff->GetXaxis()->CenterTitle();
673
674 m_hTrackMomThetaDiff =
675 new TH1F( "TrackMomThetaDiff", "#Delta#theta of tracks mom", 720, -2 * PI, 2 * PI );
676 m_hTrackMomThetaDiff->GetXaxis()->SetTitle( "#Delta#theta [rad]" );
677 m_hTrackMomThetaDiff->GetXaxis()->CenterTitle();
678
679 // 2D histograms
680 m_hDimuTracksPosDiff =
681 new TH2F( "DimuTracksPosDiff", "#Delta#phi VS #Delta#theta of dimu tracks pos", 720, -PI,
682 PI, 720, -PI, PI );
683 m_hDimuTracksPosDiff->GetXaxis()->SetTitle( "#Delta#theta" );
684 m_hDimuTracksPosDiff->GetXaxis()->CenterTitle();
685 m_hDimuTracksPosDiff->GetYaxis()->SetTitle( "#Delta#phi" );
686 m_hDimuTracksPosDiff->GetYaxis()->CenterTitle();
687
688 m_hDimuTracksMomDiff =
689 new TH2F( "DimuTracksMomDiff", "#Delta#phi VS #Delta#theta of dimu tracks mom", 720, -PI,
690 PI, 720, -PI, PI );
691 m_hDimuTracksMomDiff->GetXaxis()->SetTitle( "#Delta#theta" );
692 m_hDimuTracksMomDiff->GetXaxis()->CenterTitle();
693 m_hDimuTracksMomDiff->GetYaxis()->SetTitle( "#Delta#phi" );
694 m_hDimuTracksMomDiff->GetYaxis()->CenterTitle();
695
696 m_hPhiCosTheta =
697 new TH2F( "PhiVsCosTheta", "#phi VS cos(#theta)", 720, -1, 1, 720, -PI, PI );
698 m_hPhiCosTheta->GetXaxis()->SetTitle( "cos(#theta)" );
699 m_hPhiCosTheta->GetXaxis()->CenterTitle();
700 m_hPhiCosTheta->GetYaxis()->SetTitle( "#phi" );
701 m_hPhiCosTheta->GetYaxis()->CenterTitle();
702
703 return StatusCode::SUCCESS;
704}
705
706// Init histograme for calibration level 0
707StatusCode MucCalibMgr::InitHistoLV0() {
708 m_hBrLayerFire = new TH1F( "BrLayerFire", "Fires per layer in Barrel", LAYER_MAX + 1, -0.5,
709 LAYER_MAX + 0.5 );
710 m_hEcLayerFire = new TH1F( "EcLayerFire", "Fires per layer in Endcap", 2 * LAYER_MAX - 1,
711 -LAYER_MAX + 1, LAYER_MAX - 0.5 );
712
713 m_hLayerFire =
714 new TH1F( "LayerFire", "Fires per layer", LAYER_MAX + 1, -0.5, LAYER_MAX + 0.5 );
715 m_hLayerExpHit =
716 new TH1F( "LayerExpHit", "Exp hits per layer", LAYER_MAX + 1, -0.5, LAYER_MAX + 0.5 );
717 m_hLayerEffHit =
718 new TH1F( "LayerEffHit", "Eff hits per layer", LAYER_MAX + 1, -0.5, LAYER_MAX + 0.5 );
719 m_hLayerNosHit =
720 new TH1F( "LayerNosHit", "Nos hits per layer", LAYER_MAX + 1, -0.5, LAYER_MAX + 0.5 );
721 m_hLayerEff =
722 new TH1F( "LayerEff", "Layer efficiency", LAYER_MAX + 1, -0.5, LAYER_MAX + 0.5 );
723 m_hLayerNosRatio = new TH1F( "LayerNosRatio", "Layer noise hit ratio", LAYER_MAX + 1, -0.5,
724 LAYER_MAX + 0.5 );
725 m_hLayerArea = new TH1F( "LayerArea", "Layer area", LAYER_MAX + 1, -0.5, LAYER_MAX + 0.5 );
726 m_hLayerNos = new TH1F( "LayerNos", "Layer noise", LAYER_MAX + 1, -0.5, LAYER_MAX + 0.5 );
727 m_hLayerCnt = new TH1F( "LayerCnt", "Layer count", LAYER_MAX + 1, -0.5, LAYER_MAX + 0.5 );
728
729 return StatusCode::SUCCESS;
730}
731
732// Init histograme for calibration level 1
733StatusCode MucCalibMgr::InitHistoLV1() {
734 m_hBoxFire = new TH1F( "BoxFire", "Fires per box", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
735 m_hBoxExpHit = new TH1F( "BoxExpHit", "Exp hits per box", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
736 m_hBoxEffHit = new TH1F( "BoxEffHit", "Eff hits per box", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
737 m_hBoxNosHit = new TH1F( "BoxNosHit", "Nos hits per box", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
738 m_hBoxEff = new TH1F( "BoxEff", "Box efficiency", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
739 m_hBoxNosRatio =
740 new TH1F( "BoxNosRatio", "Box noise hit ratio", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
741 m_hBoxArea = new TH1F( "BoxArea", "Box area", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
742 m_hBoxNos = new TH1F( "BoxNos", "Box noise", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
743 m_hBoxCnt = new TH1F( "BoxCnt", "Box count", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
744
745 return StatusCode::SUCCESS;
746}
747
748// Init histograme for calibration level 2
749StatusCode MucCalibMgr::InitHistoLV2() {
750 char name[60];
751 char title[60];
752 int part, segment, layer, stripMax;
753 part = segment = layer = stripMax = 0;
754
755 for ( int i = 0; i < BOX_MAX; i++ )
756 {
757 m_ptrIdTr->SetBoxPos( i, &part, &segment, &layer );
758 stripMax = m_ptrIdTr->GetStripMax( part, segment, layer );
759
760 sprintf( name, "StripFireMap_P%d_S%d_L%d_Box%d", part, segment, layer, i );
761 sprintf( title, "Fires per strip in P%d_S%d_L%d Box%d", part, segment, layer, i );
762 m_hStripFireMap[i] = new TH1F( name, title, stripMax, 0, stripMax );
763
764 sprintf( name, "StripExpHitMap_P%d_S%d_L%d_Box%d", part, segment, layer, i );
765 sprintf( title, "Exp hits per strip in P%d_S%d_L%d Box%d", part, segment, layer, i );
766 m_hStripExpHitMap[i] = new TH1F( name, title, stripMax, 0, stripMax );
767
768 sprintf( name, "StripEffHitMap_P%d_S%d_L%d_Box%d", part, segment, layer, i );
769 sprintf( title, "Eff hits per strip in P%d_S%d_L%d Box%d", part, segment, layer, i );
770 m_hStripEffHitMap[i] = new TH1F( name, title, stripMax, 0, stripMax );
771
772 sprintf( name, "StripNosHitMap_P%d_S%d_L%d_Box%d", part, segment, layer, i );
773 sprintf( title, "Inc hits per strip in P%d_S%d_L%d Box%d", part, segment, layer, i );
774 m_hStripNosHitMap[i] = new TH1F( name, title, stripMax, 0, stripMax );
775
776 sprintf( name, "StripEffMap_P%d_S%d_L%d_Box%d", part, segment, layer, i );
777 sprintf( title, "Strip efficiency in P%d_S%d_L%d Box%d", part, segment, layer, i );
778 m_hStripEffMap[i] = new TH1F( name, title, stripMax, 0, stripMax );
779
780 sprintf( name, "StripNosRatioMap_P%d_S%d_L%d_Box%d", part, segment, layer, i );
781 sprintf( title, "Strip noise hit ratio in P%d_S%d_L%d Box%d", part, segment, layer, i );
782 m_hStripNosRatioMap[i] = new TH1F( name, title, stripMax, 0, stripMax );
783 }
784
785 m_hStripFire =
786 new TH1F( "StripFire", "Fires per strip", STRIP_MAX + 1, -0.5, STRIP_MAX + 0.5 );
787 m_hStripExpHit =
788 new TH1F( "StripExpHit", "Exp hit per strip", STRIP_MAX + 1, -0.5, STRIP_MAX + 0.5 );
789 m_hStripEffHit =
790 new TH1F( "StripEffHit", "Eff hit per strip", STRIP_MAX + 1, -0.5, STRIP_MAX + 0.5 );
791 m_hStripNosHit =
792 new TH1F( "StripNoshit", "Nos hit per strip", STRIP_MAX + 1, -0.5, STRIP_MAX + 0.5 );
793 m_hStripEff =
794 new TH1F( "StripEff", "Strip efficiency", STRIP_MAX + 1, -0.5, STRIP_MAX + 0.5 );
795 m_hStripNosRatio = new TH1F( "StripNosRatio", "Strip noise hit ratio", STRIP_MAX + 1, -0.5,
796 STRIP_MAX + 0.5 );
797 m_hStripArea = new TH1F( "StripArea", "Strip area", STRIP_MAX + 1, -0.5, STRIP_MAX + 0.5 );
798 m_hStripNos = new TH1F( "StripNos", "Strip noise", STRIP_MAX + 1, -0.5, STRIP_MAX + 0.5 );
799 m_hStripCnt = new TH1F( "StripCnt", "Strip count", STRIP_MAX + 1, -0.5, STRIP_MAX + 0.5 );
800
801 return StatusCode::SUCCESS;
802}
803
804// Init 2D eff histograme
805StatusCode MucCalibMgr::Init2DEffHisto() {
806 char name[60];
807 int stripMax, boxID, stripID, xBin, yBin;
808 stripMax = boxID = stripID = xBin = yBin = 0;
809 double xStart, xEnd, yStart, yEnd, sWidth;
810 xStart = xEnd = yStart = yEnd = sWidth = 0.;
811
812 m_histArray = new TObjArray();
813
814 for ( int i = 0; i < PART_MAX; i++ )
815 for ( int j = 0; j < ( ( i == BRID ) ? B_SEG_NUM : E_SEG_NUM ); j++ )
816 for ( int k = 0; k < ( ( i == BRID ) ? B_LAY_NUM : E_LAY_NUM ); k++ )
817 {
818 boxID = m_ptrIdTr->GetBoxId( i, j, k );
819
820 if ( i == BRID )
821 {
822 xStart = -2000, xEnd = 2000;
823 sWidth = B_STR_DST[k];
824 xBin = int( ( xEnd - xStart ) / sWidth );
825 yStart = -B_BOX_WT[k] / 2 - 100, yEnd = B_BOX_WT[k] / 2 + 100;
826 yBin = int( ( B_BOX_WT[k] + 200 ) / sWidth );
827 }
828 else
829 {
830 xStart = yStart = -1250;
831 xEnd = yEnd = 1250;
832 sWidth = E_STR_DST;
833 xBin = yBin = int( ( xEnd - xStart ) / sWidth );
834 }
835
836 sprintf( name, "ExpMap2D_P%d_S%d_L%d_Box%d", i, j, k, boxID );
837 m_h2DExpMap[i][j][k] = new TH2F( name, name, xBin, xStart, xEnd, yBin, yStart, yEnd );
838 sprintf( name, "HitMap2D_P%d_S%d_L%d_Box%d", i, j, k, boxID );
839 m_h2DHitMap[i][j][k] = new TH2F( name, name, xBin, xStart, xEnd, yBin, yStart, yEnd );
840 sprintf( name, "EffMap2D_P%d_S%d_L%d_Box%d", i, j, k, boxID );
841 m_h2DEffMap[i][j][k] = new TH2F( name, name, xBin, xStart, xEnd, yBin, yStart, yEnd );
842
843 // m_histArray->Add(m_h2DExpMap[i][j][k]);
844 // m_histArray->Add(m_h2DHitMap[i][j][k]);
845 m_histArray->Add( m_h2DEffMap[i][j][k] );
846 }
847
848 return StatusCode::SUCCESS;
849}
850
851// Init histograme for cluster
852StatusCode MucCalibMgr::InitClusterHisto() {
853 char name[60];
854 char title[60];
855 int part, segment, layer, stripMax;
856 part = segment = layer = stripMax = 0;
857
858 for ( int i = 0; i < LAYER_MAX; i++ )
859 {
860 sprintf( name, "LayerCluster_L%d", i );
861 sprintf( title, "Clusters in L%d", i );
862 m_hLayerCluster[i] = new TH1F( name, title, CLUSTER_RANGE, 0, CLUSTER_RANGE );
863 }
864
865 for ( int i = 0; i < BOX_MAX; i++ )
866 {
867 m_ptrIdTr->SetBoxPos( i, &part, &segment, &layer );
868 stripMax = m_ptrIdTr->GetStripMax( part, segment, layer );
869 sprintf( name, "BoxCluster_P%d_S%d_L%d_Box%d", part, segment, layer, i );
870 sprintf( title, "Clusters in P%d_S%d_L%d Box%d", part, segment, layer, i );
871 m_hBoxCluster[i] = new TH1F( name, title, CLUSTER_RANGE, 0, CLUSTER_RANGE );
872 }
873
874 m_hLayerClusterCmp =
875 new TH1F( "LayerCluster", "LayerCluster", LAYER_MAX + 1, -0.5, LAYER_MAX + 0.5 );
876 m_hBoxClusterCmp = new TH1F( "BoxCluster", "BoxCluster", BOX_MAX + 1, -0.5, BOX_MAX + 0.5 );
877
878 return StatusCode::SUCCESS;
879}
880
881// Init histograms for spacial resolution
882StatusCode MucCalibMgr::InitResHisto() {
883 char name[60];
884 char title[60];
885
886 for ( int i = 0; i < B_LAY_NUM; i++ )
887 {
888 sprintf( name, "BarrelRes_L%d", i );
889 sprintf( title, "Barrel spacial resolution in L%d", i );
890 m_hBarrelResDist[i] = new TH1F( name, title, 200, -100, 100 );
891 }
892
893 for ( int i = 0; i < E_LAY_NUM; i++ )
894 {
895 sprintf( name, "EndcapRes_L%d", i );
896 sprintf( title, "Endcap spacial resolution in L%d", i );
897 m_hEndcapResDist[i] = new TH1F( name, title, 200, -100, 100 );
898 }
899
900 m_hBarrelResComp[0] =
901 new TH1F( "BarrelResMean", "BarrelResMean", B_LAY_NUM + 1, -0.5, B_LAY_NUM + 0.5 );
902 m_hBarrelResComp[1] =
903 new TH1F( "BarrelResSigma", "BarrelResSigma", B_LAY_NUM + 1, -0.5, B_LAY_NUM + 0.5 );
904 m_hEndcapResComp[0] =
905 new TH1F( "EndcapResMean", "EndcapResMean", E_LAY_NUM + 1, -0.5, E_LAY_NUM + 0.5 );
906 m_hEndcapResComp[1] =
907 new TH1F( "EndcapResSigma", "EndcapResSigma", E_LAY_NUM + 1, -0.5, E_LAY_NUM + 0.5 );
908
909 return StatusCode::SUCCESS;
910}
911
912// Init Tree
913StatusCode MucCalibMgr::InitConstTree() {
914 MsgStream log( msgSvc, "MucCalibMgr" );
915 log << MSG::INFO << "Initialize Trees" << endmsg;
916
917 // job log tree
918 m_tJobLog = new TTree( "JobLog", "Job information" );
919 m_tJobLog->Branch( "version", &m_vs, "m_vs/D" );
920 m_tJobLog->Branch( "high_voltage", &m_hv, "m_hv/D" );
921 m_tJobLog->Branch( "threshold", &m_th, "m_th/D" );
922 m_tJobLog->Branch( "event_rate", &m_er, "m_er/D" );
923 m_tJobLog->Branch( "input_tag", &m_tag, "m_tag/D" );
924 m_tJobLog->Branch( "rec_mode", &m_recMode, "m_recMode/I" );
925 m_tJobLog->Branch( "use_pad", &m_usePad, "m_usePad/I" );
926 m_tJobLog->Branch( "eff_window", &m_effWindow, "m_effWindow/I" );
927 m_tJobLog->Branch( "cluster_mode", &m_clusterMode, "m_clusterMode/I" );
928 m_tJobLog->Branch( "check_event", &m_checkEvent, "m_checkEvent/I" );
929 m_tJobLog->Branch( "dimu_select", &m_dimuSelect, "m_dimuSelect/I" );
930 m_tJobLog->Branch( "dimu_only", &m_dimuOnly, "m_dimuOnly/I" );
931
932 m_tJobLog->Branch( "run_start", &m_fStartRun, "m_fStartRun/I" );
933 m_tJobLog->Branch( "run_end", &m_fEndRun, "m_fEndRun/I" );
934 m_tJobLog->Branch( "daq_time", &m_fTotalDAQTime, "m_fTotalDAQTime/D" );
935 m_tJobLog->Branch( "job_time", &m_fTotalJobTime, "m_fTotalJobTime/D" );
936 m_tJobLog->Branch( "calib_layer", &m_fCalibLayerNum, "m_fCalibLayerNum/D" );
937 m_tJobLog->Branch( "calib_box", &m_fCalibBoxNum, "m_fCalibBoxNum/D" );
938 m_tJobLog->Branch( "calib_strip", &m_fCalibStripNum, "m_fCalibStripNum/D" );
939 m_tJobLog->Branch( "total_event", &m_fTotalEvent, "m_fTotalEvent/D" );
940 m_tJobLog->Branch( "total_digi", &m_fTotalDigi, "m_fTotalDigi/D" );
941 m_tJobLog->Branch( "total_exphit", &m_fTotalExpHit, "m_fTotalExpHit/D" );
942 m_tJobLog->Branch( "total_effhit", &m_fTotalEffHit, "m_fTotalEffHit/D" );
943 m_tJobLog->Branch( "total_noshit", &m_fTotalNosHit, "m_fTotalNosHit/D" );
944 m_tJobLog->Branch( "total_cluster", &m_fTotalClstNum, "m_fTotalClstNum/D" );
945 m_tJobLog->Branch( "total_strip_area", &m_fTotalStripArea, "m_fTotalStripArea/D" );
946 m_tJobLog->Branch( "layer_coverage", &m_fLayerCoverage, "m_fLayerCoverage/D" );
947 m_tJobLog->Branch( "box_coverage", &m_fBoxCoverage, "m_fBoxCoverage/D" );
948 m_tJobLog->Branch( "strip_coverage", &m_fStripCoverage, "m_fStripCoverage/D" );
949
950 // statistic log tree
951 m_tStatLog = new TTree( "StatLog", "Statistic results" );
952
953 // layer constants tree, level 0
954 m_tLayConst = new TTree( "LayConst", "layer constants" );
955 m_tLayConst->Branch( "layer_id", &m_fLayerId, "m_fLayerId/D" );
956 m_tLayConst->Branch( "layer_eff", &m_fLayerEff, "m_fLayerEff/D" );
957 m_tLayConst->Branch( "layer_efferr", &m_fLayerEffErr, "m_fLayerEffErr/D" );
958 m_tLayConst->Branch( "layer_nosratio", &m_fLayerNosRatio, "m_fLayerNosRatio/D" );
959 m_tLayConst->Branch( "layer_digi", &m_fLayerDigi, "m_fLayerDigi/D" );
960 m_tLayConst->Branch( "layer_noise", &m_fLayerNos, "m_fLayerNos/D" );
961 m_tLayConst->Branch( "layer_cnt", &m_fLayerCnt, "m_fLayerCnt/D" );
962 m_tLayConst->Branch( "layer_exphit", &m_fLayerExpHit, "m_fLayerExpHit/D" );
963 m_tLayConst->Branch( "layer_effHit", &m_fLayerEffHit, "m_fLayerEffHit/D" );
964 m_tLayConst->Branch( "layer_nosHit", &m_fLayerNosHit, "m_fLayerNosHit/D" );
965 m_tLayConst->Branch( "layer_cluster", &m_fLayerCluster, "m_fLayerCluster/D" );
966 m_tLayConst->Branch( "layer_trknum", &m_fLayerTrkNum, "m_fLayerTrkNum/D" );
967
968 // box constants tree, level 1
969 m_tBoxConst = new TTree( "BoxConst", "box constants" );
970 m_tBoxConst->Branch( "box_id", &m_fBoxId, "m_fBoxId/D" );
971 m_tBoxConst->Branch( "box_part", &m_fBoxPart, "m_fBoxPart/D" );
972 m_tBoxConst->Branch( "box_segment", &m_fBoxSegment, "m_fBoxSegment/D" );
973 m_tBoxConst->Branch( "box_layer", &m_fBoxLayer, "m_fBoxLayer/D" );
974 m_tBoxConst->Branch( "box_eff", &m_fBoxEff, "m_fBoxEff/D" );
975 m_tBoxConst->Branch( "box_efferr", &m_fBoxEffErr, "m_fBoxEffErr/D" );
976 m_tBoxConst->Branch( "box_nosratio", &m_fBoxNosRatio, "m_fBoxNosRatio/D" );
977 m_tBoxConst->Branch( "box_digi", &m_fBoxDigi, "m_fBoxDigi/D" );
978 m_tBoxConst->Branch( "box_noise", &m_fBoxNos, "m_fBoxNos/D" );
979 m_tBoxConst->Branch( "box_cnt", &m_fBoxCnt, "m_fBoxCnt/D" );
980 m_tBoxConst->Branch( "box_exphit", &m_fBoxExpHit, "m_fBoxExpHit/D" );
981 m_tBoxConst->Branch( "box_effhit", &m_fBoxEffHit, "m_fBoxEffHit/D" );
982 m_tBoxConst->Branch( "box_noshit", &m_fBoxNosHit, "m_fBoxNosHit/D" );
983 m_tBoxConst->Branch( "box_cluster", &m_fBoxCluster, "m_fBoxCluster/D" );
984 m_tBoxConst->Branch( "box_trknum", &m_fBoxTrkNum, "m_fBoxTrkNum/D" );
985
986 // strip constants tree, level 2
987 m_tStrConst = new TTree( "StrConst", "strip constants" );
988 m_tStrConst->Branch( "strip_id", &m_fStripId, "m_fStripId/D" );
989 m_tStrConst->Branch( "strip_part", &m_fStripPart, "m_fStripPart/D" );
990 m_tStrConst->Branch( "strip_segment", &m_fStripSegment, "m_fStripSegment/D" );
991 m_tStrConst->Branch( "strip_layer", &m_fStripLayer, "m_fStripLayer/D" );
992 m_tStrConst->Branch( "strip_eff", &m_fStripEff, "m_fStripEff/D" );
993 m_tStrConst->Branch( "strip_efferr", &m_fStripEffErr, "m_fStripEffErr/D" );
994 m_tStrConst->Branch( "strip_nosratio", &m_fStripNosRatio, "m_fStripNosRatio/D" );
995 m_tStrConst->Branch( "strip_digi", &m_fStripDigi, "m_fStripDigi/D" );
996 m_tStrConst->Branch( "strip_noise", &m_fStripNos, "m_fStripNos/D" );
997 m_tStrConst->Branch( "strip_cnt", &m_fStripCnt, "m_fStripCnt/D" );
998 m_tStrConst->Branch( "strip_effhit", &m_fStripEffHit, "m_fStripEffHit/D" );
999 m_tStrConst->Branch( "strip_exphit", &m_fStripExpHit, "m_fStripExpHit/D" );
1000 m_tStrConst->Branch( "strip_noshit", &m_fStripNosHit, "m_fStripNosHit/D" );
1001 m_tStrConst->Branch( "strip_trknum", &m_fStripTrkNum, "m_fStripTrkNum/D" );
1002
1003 return StatusCode::SUCCESS;
1004}
1005
1006// Init area of units
1007StatusCode MucCalibMgr::InitArea() {
1008 int stripMax, boxID, stripID;
1009 stripMax = boxID = stripID = 0;
1010 double totalArea = 0;
1011
1012 for ( int i = 0; i < PART_MAX; i++ )
1013 for ( int j = 0; j < ( ( i == BRID ) ? B_SEG_NUM : E_SEG_NUM ); j++ )
1014 for ( int k = 0; k < ( ( i == BRID ) ? B_LAY_NUM : E_LAY_NUM ); k++ )
1015 {
1016 MucBoxCal* aBox = new MucBoxCal( i, j, k );
1017 boxID = m_ptrIdTr->GetBoxId( i, j, k );
1018 m_boxResults[3][boxID] = aBox->GetArea();
1019 m_layerResults[3][k] += aBox->GetArea();
1020 delete aBox;
1021
1022 stripMax = m_ptrIdTr->GetStripMax( i, j, k );
1023 for ( int m = 0; m < stripMax; m++ )
1024 {
1025 MucStripCal* aStrip = new MucStripCal( i, j, k, m );
1026 stripID = m_ptrIdTr->GetStripId( i, j, k, m );
1027 m_stripResults[3][stripID] = aStrip->GetArea();
1028 totalArea += m_stripResults[3][stripID];
1029 delete aStrip;
1030 }
1031 }
1032
1033 for ( int i = 0; i < LAYER_MAX; i++ ) m_hLayerArea->Fill( i, m_layerResults[3][i] );
1034 for ( int i = 0; i < BOX_MAX; i++ ) m_hBoxArea->Fill( i, m_boxResults[3][i] );
1035 for ( int i = 0; i < STRIP_MAX; i++ ) m_hStripArea->Fill( i, m_stripResults[3][i] );
1036
1037 m_fTotalStripArea = totalArea;
1038
1039 return StatusCode::SUCCESS;
1040}
1041
1042//-------------------------------------------------------------------------------------------------
1043//-------------------------------- Member functions for executing
1044//--------------------------------
1045//-------------------------------------------------------------------------------------------------
1046
1047// Dimu select
1048StatusCode MucCalibMgr::DimuSelect() {
1049 MsgStream log( msgSvc, "MucCalibMgr" );
1050 log << MSG::INFO << "Dimu select" << endmsg;
1051 Gaudi::svcLocator()->service( "EventDataSvc", eventSvc );
1052
1053 if ( m_tag > 0 )
1054 {
1055 m_eventTag = (int)m_tag;
1056 return ( StatusCode::SUCCESS );
1057 }
1058
1059 m_eventTag = 0;
1060 SmartDataPtr<Event::EventHeader> eventHeader( eventSvc, "/Event/EventHeader" );
1061 if ( !eventHeader )
1062 {
1063 log << MSG::FATAL << "Could not find event header" << endmsg;
1064 return ( StatusCode::FAILURE );
1065 }
1066
1067 // Select by MDC Info
1068 SmartDataPtr<RecMdcTrackCol> mdcTrackCol( eventSvc, "/Event/Recon/RecMdcTrackCol" );
1069 if ( !mdcTrackCol )
1070 {
1071 log << MSG::FATAL << "Could not find mdc tracks" << endmsg;
1072 return ( StatusCode::FAILURE );
1073 }
1074 log << MSG::INFO << mdcTrackCol->size() << endmsg;
1075 if ( mdcTrackCol->size() != 2 ) return ( StatusCode::FAILURE );
1076
1077 log << MSG::INFO << "r1:\t" << ( *mdcTrackCol )[0]->r()
1078 << "\tz1:" << ( *mdcTrackCol )[0]->z() << endmsg;
1079 log << MSG::INFO << "r2:\t" << ( *mdcTrackCol )[1]->r()
1080 << "\tz2:" << ( *mdcTrackCol )[1]->z() << endmsg;
1081 log << MSG::INFO << "p1:\t" << ( *mdcTrackCol )[0]->p()
1082 << "\tp2:" << ( *mdcTrackCol )[1]->p() << endmsg;
1083
1084 bool mdcFlag1 = ( *mdcTrackCol )[0]->charge() + ( *mdcTrackCol )[1]->charge() == 0;
1085 bool mdcFlag2 =
1086 fabs( ( *mdcTrackCol )[0]->r() ) <= 1 && fabs( ( *mdcTrackCol )[0]->z() ) < 3;
1087 bool mdcFlag3 =
1088 fabs( ( *mdcTrackCol )[1]->r() ) <= 1 && fabs( ( *mdcTrackCol )[1]->z() ) < 3;
1089 bool mdcFlag4 = ( *mdcTrackCol )[0]->p() < 2 && ( *mdcTrackCol )[1]->p() < 2;
1090 bool mdcFlag5 = fabs( ( *mdcTrackCol )[0]->p() - ( *mdcTrackCol )[1]->p() ) /
1091 ( ( *mdcTrackCol )[0]->p() + ( *mdcTrackCol )[1]->p() ) <
1092 0.5;
1093 bool mdcPass = false;
1094 if ( mdcFlag1 && mdcFlag2 && mdcFlag3 && mdcFlag4 && mdcFlag5 ) mdcPass = true;
1095
1096 // Select by TOF Info
1097 SmartDataPtr<RecTofTrackCol> tofTrackCol( eventSvc, "/Event/Recon/RecTofTrackCol" );
1098 if ( !tofTrackCol )
1099 {
1100 log << MSG::FATAL << "Could not find RecTofTrackCol!" << endmsg;
1101 return ( StatusCode::FAILURE );
1102 }
1103 log << MSG::INFO << "TOF tracks:\t" << tofTrackCol->size() << endmsg;
1104
1105 double t1, t2;
1106 t1 = 0., t2 = 1000;
1107 // if(tofTrackCol->size() < 8 && tofTrackCol->size() > 20)
1108 if ( tofTrackCol->size() > 7 && tofTrackCol->size() < 21 )
1109 {
1110 int goodtof = 0;
1111 for ( unsigned int itof = 0; itof < tofTrackCol->size(); itof++ )
1112 {
1113 TofHitStatus* status = new TofHitStatus;
1114 status->setStatus( ( *tofTrackCol )[itof]->status() );
1115
1116 if ( !( status->is_cluster() ) )
1117 {
1118 delete status;
1119 continue;
1120 }
1121 if ( goodtof == 0 ) t1 = ( *tofTrackCol )[itof]->tof();
1122 if ( goodtof == 1 ) t2 = ( *tofTrackCol )[itof]->tof();
1123
1124 goodtof++;
1125 delete status;
1126 }
1127 }
1128 bool tofPass = false;
1129 if ( fabs( t1 - t2 ) < 4 ) tofPass = true; // ns
1130
1131 // Select by EMC Info
1132 SmartDataPtr<RecEmcShowerCol> emcShowerCol( eventSvc, "/Event/Recon/RecEmcShowerCol" );
1133 if ( !emcShowerCol )
1134 {
1135 log << MSG::FATAL << "Could not find RecEmcShowerCol!" << endmsg;
1136 return ( StatusCode::FAILURE );
1137 }
1138 log << MSG::INFO << "EMC showers:\t" << emcShowerCol->size() << endmsg;
1139
1140 if ( emcShowerCol->size() < 2 ) return ( StatusCode::SUCCESS );
1141
1142 double e1, e2, theta1, theta2, phi1, phi2;
1143 int part;
1144
1145 e1 = ( *emcShowerCol )[0]->energy();
1146 e2 = ( *emcShowerCol )[1]->energy();
1147 theta1 = ( *emcShowerCol )[0]->theta();
1148 theta2 = ( *emcShowerCol )[1]->theta();
1149 phi1 = ( *emcShowerCol )[0]->phi();
1150 phi2 = ( *emcShowerCol )[1]->phi();
1151 part = ( *emcShowerCol )[0]->module();
1152
1153 log << MSG::INFO << "e1:\t" << e1 << "\te2:\t" << e2 << endmsg;
1154 log << MSG::INFO << "theta1:\t" << theta1 << "\ttheta2:\t" << theta2 << endmsg;
1155 log << MSG::INFO << "phi1:\t" << phi1 << "\tphi2:\t" << phi2 << endmsg;
1156
1157 bool emcFlag1 = e1 < 1.0 && e1 > 0.1;
1158 bool emcFlag2 = e2 < 1.0 && e2 > 0.1;
1159 bool emcFlag3 = fabs( theta1 + theta2 - PI ) < 0.05;
1160 bool emcFlag4 = fabs( phi1 - phi2 ) - PI < 0.4;
1161
1162 bool emcPass = false;
1163 if ( emcFlag1 && emcFlag2 && emcFlag3 && emcFlag4 ) emcPass = true;
1164
1165 // Select by MUC Info
1166 SmartDataPtr<MucDigiCol> mucDigiCol( eventSvc, "/Event/Digi/MucDigiCol" );
1167 if ( !mucDigiCol )
1168 {
1169 log << MSG::FATAL << "Could not find MUC digi" << endmsg;
1170 return ( StatusCode::FAILURE );
1171 }
1172 SmartDataPtr<RecMucTrackCol> mucTrackCol( eventSvc, "/Event/Recon/RecMucTrackCol" );
1173 if ( !mucTrackCol )
1174 {
1175 log << MSG::FATAL << "Could not find RecMucTrackCol" << endmsg;
1176 return ( StatusCode::FAILURE );
1177 }
1178 log << MSG::INFO << "digi:\t" << mucDigiCol->size() << "tracks:\t" << mucTrackCol->size()
1179 << endmsg;
1180
1181 bool mucFlag1 = mucDigiCol->size() > 6;
1182 bool mucFlag2 = mucTrackCol->size() > 1;
1183 bool mucPass = false;
1184 if ( mucFlag1 && mucFlag2 ) mucPass = true;
1185
1186 if ( mdcPass && tofPass && emcPass && mucPass ) m_eventTag = 1;
1187 else m_eventTag = (int)m_tag;
1188
1189 return ( StatusCode::SUCCESS );
1190}
1191
1192// Read event info from TDS
1193StatusCode MucCalibMgr::ReadEvent() {
1194 MsgStream log( msgSvc, "MucCalibMgr" );
1195 log << MSG::INFO << "Read event" << endmsg;
1196
1197 Gaudi::svcLocator()->service( "EventDataSvc", eventSvc );
1198 m_evtBegin = clock();
1199
1200 // Check event head
1201 SmartDataPtr<Event::EventHeader> eventHeader( eventSvc, "/Event/EventHeader" );
1202 if ( !eventHeader )
1203 {
1204 log << MSG::FATAL << "Could not find event header" << endmsg;
1205 return ( StatusCode::FAILURE );
1206 }
1207
1208 m_currentRun = eventHeader->runNumber();
1209 m_currentEvent = eventHeader->eventNumber();
1210 if ( m_fStartRun == 0 ) m_fStartRun = m_currentRun;
1211 m_fEndRun = m_currentRun;
1212 m_fTotalEvent++;
1213
1214 log << MSG::INFO << "Run [ " << m_currentRun << " ]\tEvent [ " << m_currentEvent << " ]"
1215 << endmsg;
1216 if ( ( (long)m_fTotalEvent ) % 2000 == 0 ) cout << m_fTotalEvent << "\tdone!" << endl;
1217
1218 // Select dimu
1219 if ( m_dimuSelect )
1220 {
1221 MucCalibMgr::DimuSelect();
1222 log << MSG::INFO << "Event tag:\t" << m_eventTag << endmsg;
1223 if ( m_dimuOnly && m_eventTag != 1 ) return ( StatusCode::FAILURE );
1224 }
1225
1226 //---> Retrieve MUC digi
1227 log << MSG::INFO << "Retrieve digis" << endmsg;
1228
1229 SmartDataPtr<MucDigiCol> mucDigiCol( eventSvc, "/Event/Digi/MucDigiCol" );
1230 if ( !mucDigiCol )
1231 {
1232 log << MSG::FATAL << "Could not find MUC digi" << endmsg;
1233 return ( StatusCode::FAILURE );
1234 }
1235
1236 int part, segment, layer, strip, pad;
1237 part = segment = layer = strip = pad = 0;
1238 double padX, padY, padZ;
1239 padX = padY = padZ = 0.;
1240 double resMax = 0.;
1241
1242 Identifier mucId;
1243 MucDigiCol::iterator digiIter = mucDigiCol->begin();
1244 int eventDigi = 0;
1245 for ( int digiId = 0; digiIter != mucDigiCol->end(); digiIter++, digiId++ )
1246 {
1247 mucId = ( *digiIter )->identify();
1248 part = MucID::barrel_ec( mucId );
1249 segment = MucID::segment( mucId );
1250 layer = MucID::layer( mucId );
1251 strip = MucID::channel( mucId );
1252
1253 log << MSG::DEBUG << "[" << part << "\t" << segment << "\t" << layer << "\t" << strip
1254 << "]\t";
1255 if ( ( digiId + 1 ) % 8 == 0 ) log << MSG::DEBUG << endmsg;
1256
1257 eventDigi++;
1258
1259 if ( abs( part ) >= PART_MAX || abs( segment ) >= SEGMENT_MAX ||
1260 abs( layer ) >= LAYER_MAX || abs( strip ) >= STRIP_INBOX_MAX )
1261 {
1262 log << MSG::ERROR << endmsg << "Digi IDs slop over!" << endmsg;
1263 continue;
1264 }
1265
1266 // Add digi
1267 MucMark* aMark = new MucMark( part, segment, layer, strip );
1268 m_digiCol.push_back( aMark );
1269 m_segDigiCol[part][segment].push_back( aMark );
1270 }
1271 log << MSG::DEBUG << endmsg;
1272 log << MSG::INFO << "Total digits of this event: " << eventDigi << endmsg;
1273 if ( eventDigi > 200 )
1274 log << MSG::ERROR << "Event: " << m_currentEvent << "\tdigits sharply rise:\t" << eventDigi
1275 << endmsg;
1276
1277 /*
1278 if( (long)m_fTotalEvent%10000 == 0 ) {
1279 log << MSG::INFO << "Delete HitVsEvent." << endmsg;
1280 if(m_hHitVsEvent != NULL) delete m_hHitVsEvent;
1281 m_hHitVsEvent = new TH1F("HitVsEvent","Hit VS
1282 event",10000,m_fTotalEvent,m_fTotalEvent+10000); m_hHitVsEvent->GetXaxis()->SetTitle("Event
1283 NO."); log << MSG::INFO << "Recreate HitVsEvent." << endmsg;
1284 }
1285 log << MSG::INFO << "Fill HitVsEvent\t" << m_hHitVsEvent << "\t" << m_fTotalEvent << "\t" <<
1286 m_currentEvent << endmsg;
1287 //m_hHitVsEvent->Fill(m_currentEvent+m_currentEvent%10000, eventDigi);
1288 m_hHitVsEvent->Fill(m_fTotalEvent, eventDigi);
1289 log << MSG::INFO << "Fill HitVsEvent done." << endmsg;
1290 */
1291
1292 // Search cluster in digis
1293 // Method detail in MucMark class
1294 int clusterNum, bigClusterNum, clusterSize;
1295 clusterNum = bigClusterNum = clusterSize = 0;
1296 if ( m_clusterMode )
1297 {
1298 log << MSG::INFO << "Searching clusters" << endmsg;
1299 m_clusterCol = ( *m_ptrMucMark ).CreateClusterCol( m_clusterMode, m_digiCol );
1300 }
1301
1302 for ( unsigned int i = 0; i < m_clusterCol.size(); i++ )
1303 {
1304 clusterSize = m_clusterCol[i].size();
1305 // real cluster, size >= 2
1306 if ( clusterSize > CLUSTER_ALARM )
1307 {
1308 log << MSG::WARNING << "Big cluster:" << endmsg;
1309 part = ( *m_clusterCol[i][0] ).Part();
1310 segment = ( *m_clusterCol[i][0] ).Segment();
1311 layer = ( *m_clusterCol[i][0] ).Layer();
1312
1313 if ( m_clusterSave )
1314 ( *m_fdata ) << "Event:\t" << m_currentEvent << "\tbig cluster " << bigClusterNum
1315 << endl;
1316
1317 for ( int j = 0; j < clusterSize; j++ )
1318 {
1319 strip = ( *m_clusterCol[i][j] ).Strip();
1320 log << MSG::WARNING << "[" << part << "\t" << segment << "\t" << layer << "\t" << strip
1321 << "]\t";
1322 if ( ( j + 1 ) % 8 == 0 ) log << MSG::WARNING << endmsg;
1323 if ( m_clusterSave )
1324 ( *m_fdata ) << part << "\t" << segment << "\t" << layer << "\t" << strip << endl;
1325 }
1326 log << MSG::WARNING << endmsg;
1327 bigClusterNum++;
1328 }
1329 else if ( clusterSize > 1 )
1330 {
1331 log << MSG::DEBUG << "cluster: " << clusterNum << endmsg;
1332 clusterNum++, m_fTotalClstNum++;
1333 part = ( *m_clusterCol[i][0] ).Part();
1334 segment = ( *m_clusterCol[i][0] ).Segment();
1335 layer = ( *m_clusterCol[i][0] ).Layer();
1336 for ( int j = 0; j < clusterSize; j++ )
1337 {
1338 strip = ( *m_clusterCol[i][j] ).Strip();
1339 log << MSG::DEBUG << "[" << part << "\t" << segment << "\t" << layer << "\t" << strip
1340 << "]\t";
1341 if ( ( j + 1 ) % 8 == 0 ) log << MSG::DEBUG << endmsg;
1342 }
1343 log << MSG::DEBUG << endmsg;
1344 }
1345 } // End m_clusterCol.size()
1346
1347 if ( m_clusterMode )
1348 log << MSG::INFO << "Total clusters in this event: " << clusterNum << endmsg;
1349 else log << MSG::INFO << "Clusters not built" << endmsg;
1350 //<--- End retrieve digis
1351
1352 //---> Retrieve rec tracks
1353 log << MSG::INFO << "Retrieve tracks" << endmsg;
1354 // MDC tracks
1355 SmartDataPtr<RecMdcTrackCol> mdcTrackCol( eventSvc, "/Event/Recon/RecMdcTrackCol" );
1356 if ( !mdcTrackCol )
1357 {
1358 log << MSG::FATAL << "Could not find mdc tracks" << endmsg;
1359 return ( StatusCode::FAILURE );
1360 }
1361
1362 RecMdcTrackCol::iterator mdctrkIter = mdcTrackCol->begin();
1363 for ( ; mdctrkIter != mdcTrackCol->end(); mdctrkIter++ )
1364 {
1365 m_charge = ( *mdctrkIter )->charge();
1366 m_mdcpx = ( *mdctrkIter )->px();
1367 m_mdcpy = ( *mdctrkIter )->py();
1368 m_mdcpz = ( *mdctrkIter )->pz();
1369 m_mdcpt = ( *mdctrkIter )->pxy();
1370 m_mdcpp = ( *mdctrkIter )->p();
1371 m_mdcphi = ( *mdctrkIter )->phi();
1372 m_mdctheta = ( *mdctrkIter )->theta();
1373 m_mdcTrkInfoTuple->write();
1374 }
1375
1376 // MUC tracks
1377 SmartDataPtr<RecMucTrackCol> mucTrackCol( eventSvc, "/Event/Recon/RecMucTrackCol" );
1378 if ( !mucTrackCol )
1379 {
1380 log << MSG::FATAL << "Could not find RecMucTrackCol" << endmsg;
1381 return ( StatusCode::FAILURE );
1382 }
1383
1384 RecMucTrackCol* aRecMucTrackCol = mucTrackCol;
1385 if ( aRecMucTrackCol->size() < 1 )
1386 {
1387 log << MSG::INFO << "No MUC tracks in this event" << endmsg;
1388 return StatusCode::SUCCESS;
1389 }
1390 log << MSG::INFO << "Total tracks of this event: " << aRecMucTrackCol->size() << endmsg;
1391
1392 // Get RecEsTimeCol
1393 // int esTimeflag;
1394 // if( m_recMode == 0 ) // only for ExtTrk
1395 if ( 0 ) // only for ExtTrk
1396 {
1397 SmartDataPtr<RecEsTimeCol> aRecEsTimeCol( eventSvc, "/Event/Recon/RecEsTimeCol" );
1398 if ( !aRecEsTimeCol )
1399 {
1400 log << MSG::ERROR << "Could not find RecEsTimeCol" << endmsg;
1401 return StatusCode::FAILURE;
1402 }
1403 else
1404 {
1405 RecEsTimeCol::iterator iter_evt = aRecEsTimeCol->begin();
1406 // tes = (*iter_evt)->getTest();
1407 // esTimeflag = (*iter_evt)->getStat();
1408 m_ntEsTime = ( *iter_evt )->getStat();
1409 if ( ( *iter_evt )->getStat() != 211 )
1410 {
1411 log << MSG::WARNING << "Event time not by TOF, skip!" << endmsg;
1412 return StatusCode::SUCCESS;
1413 }
1414 }
1415 }
1416
1417 // Phi diff of two tracks( dimuon event )
1418 double phi1, phi2, phiDiff, theta1, theta2, thetaDiff;
1419 phiDiff = thetaDiff = 0.;
1420 if ( aRecMucTrackCol->size() == 2 && ( *aRecMucTrackCol )[0]->GetTotalHits() > 4 &&
1421 ( *aRecMucTrackCol )[1]->GetTotalHits() > 4 )
1422 {
1423 // Pos phi diff
1424 phi1 = ( *aRecMucTrackCol )[0]->getMucPos().phi();
1425 phi2 = ( *aRecMucTrackCol )[1]->getMucPos().phi();
1426 if ( phi1 > 0 ) phiDiff = phi1 - phi2 - PI;
1427 else phiDiff = phi2 - phi1 - PI;
1428
1429 // Pos theta diff
1430 theta1 = ( *aRecMucTrackCol )[0]->getMucPos().theta();
1431 theta2 = ( *aRecMucTrackCol )[1]->getMucPos().theta();
1432 thetaDiff = theta1 + theta2 - PI;
1433 m_hTrackPosPhiDiff->Fill( phiDiff );
1434 m_hTrackPosThetaDiff->Fill( thetaDiff );
1435 m_hDimuTracksPosDiff->Fill( thetaDiff, phiDiff );
1436 m_ntPosPhiDiff = phiDiff;
1437 m_ntPosThetaDiff = thetaDiff;
1438
1439 log << MSG::INFO << "PosPhiDiff:\t" << phiDiff << "\tPosThetaDiff:\t" << thetaDiff
1440 << endmsg;
1441
1442 // Mom phi diff
1443 phi1 = ( *aRecMucTrackCol )[0]->getMucMomentum().phi();
1444 phi2 = ( *aRecMucTrackCol )[1]->getMucMomentum().phi();
1445 if ( phi1 > 0 ) phiDiff = phi1 - phi2 - PI;
1446 else phiDiff = phi2 - phi1 - PI;
1447
1448 // Mom theta diff
1449 theta1 = ( *aRecMucTrackCol )[0]->getMucMomentum().theta();
1450 theta2 = ( *aRecMucTrackCol )[1]->getMucMomentum().theta();
1451 thetaDiff = theta1 + theta2 - PI;
1452
1453 m_hTrackMomPhiDiff->Fill( phiDiff );
1454 m_hTrackMomThetaDiff->Fill( thetaDiff );
1455 m_hDimuTracksMomDiff->Fill( thetaDiff, phiDiff );
1456 m_ntMomPhiDiff = phiDiff;
1457 m_ntMomThetaDiff = thetaDiff;
1458
1459 log << MSG::INFO << "MomPhiDiff:\t" << phiDiff << "\tMomThetaDiff:\t" << thetaDiff
1460 << endmsg;
1461 m_ntDimuTag = m_eventTag;
1462 m_trackDiffTuple->write();
1463 }
1464
1465 // Retrieve tracks for calibration
1466 RecMucTrackCol::iterator trackIter = mucTrackCol->begin();
1467 int trackHitNum, rawHitNum, expectedHitNum, segNum, trkRecMode, lastLayerBR, lastLayerEC;
1468 int layerPassNum[3], passMax[TRACK_SEG_MAX][2];
1469 bool firedLay[TRACK_SEG_MAX][LAYER_MAX];
1470 bool seedList[PART_MAX][LAYER_MAX];
1471 trackHitNum = rawHitNum = expectedHitNum = segNum = trkRecMode = lastLayerBR = lastLayerEC =
1472 0;
1473 layerPassNum[0] = layerPassNum[1] = layerPassNum[2] = 0;
1474 for ( int segi = 0; segi < TRACK_SEG_MAX; segi++ )
1475 {
1476 passMax[segi][0] = passMax[segi][1] = 0;
1477 for ( int layi = 0; layi < LAYER_MAX; layi++ ) firedLay[segi][layi] = 0;
1478 }
1479
1480 mark_col trkSeg[TRACK_SEG_MAX];
1481
1482 // vector<MucRecHit*> mucRawHitCol;
1483 // vector<MucRecHit*> mucExpHitCol; //==========
1484 vector<int> mucRawHitCol;
1485 vector<int> mucExpHitCol;
1486
1487 for ( int trackId = 0; trackIter != mucTrackCol->end(); trackIter++, trackId++ )
1488 {
1489
1490 // cout<<__LINE__<<"trackID "<<trackId<<endl;
1491 // trackHitNum = (*trackIter)->GetTotalHits();
1492 trackHitNum = ( *trackIter )->numHits();
1493 log << MSG::DEBUG << "Track: " << trackId << " Hits: " << trackHitNum << endmsg;
1494 // cout<< "Track: " << trackId << " Hits: " << trackHitNum << endl;
1495 if ( trackHitNum == 0 )
1496 {
1497 log << MSG::INFO << "Track " << trackId << " no hits" << endmsg;
1498 continue;
1499 }
1500
1501 m_ntTrackHits = trackHitNum;
1502
1503 m_trkRecMode = trkRecMode = ( *trackIter )->GetRecMode();
1504 m_chi2 = ( *trackIter )->chi2();
1505 m_px = ( *trackIter )->getMucMomentum().x();
1506 m_py = ( *trackIter )->getMucMomentum().y();
1507 m_pz = ( *trackIter )->getMucMomentum().z();
1508 m_pt = sqrt( m_px * m_px + m_py * m_py );
1509 m_pp = sqrt( m_px * m_px + m_py * m_py + m_pz * m_pz );
1510
1511 // First fit position in MUC
1512 m_r = ( *trackIter )->getMucPos().mag();
1513 m_cosTheta = ( *trackIter )->getMucPos().cosTheta();
1514 m_theta = ( *trackIter )->getMucPos().theta();
1515 m_phi = ( *trackIter )->getMucPos().phi();
1516 m_depth = ( *trackIter )->depth();
1517 m_brLastLayer = lastLayerBR = ( *trackIter )->brLastLayer();
1518 m_ecLastLayer = lastLayerEC = ( *trackIter )->ecLastLayer();
1519 m_totalHits = ( *trackIter )->numHits();
1520 m_totalLayers = ( *trackIter )->numLayers();
1521 m_maxHitsInLayer = ( *trackIter )->maxHitsInLayer();
1522
1523 m_hPhiCosTheta->Fill( m_cosTheta, m_phi );
1524 log << MSG::INFO << "Fill track info" << endmsg;
1525
1526 // MucRecHit* pMucRawHit;
1527 // MucRecHit* pMucExpHit;
1528 if ( m_calHitCol.size() != 0 ) m_calHitCol.clear(); // Fresh each track
1529
1530 // Digis belong to this rec track
1531 log << MSG::DEBUG << "Reconstruction hits(digis in a track): " << endmsg;
1532 // mucRawHitCol = (*trackIter)->GetHits(); // Get hit collection of a track
1533 mucRawHitCol = ( *trackIter )->getVecHits();
1534 rawHitNum += mucRawHitCol.size();
1535 // cout<<__LINE__<<"rawHitNum "<<rawHitNum<<endl;
1536 segNum = 0;
1537 /*
1538 if( trkRecMode == 3 ) { // By SlfTrk
1539 for(int iPart=0; iPart<PART_MAX; iPart++)
1540 for(int iLayer=0; iLayer<LAYER_MAX; iLayer++) seedList[iPart][iLayer] = false;
1541 }
1542 */
1543 for ( unsigned int hitId = 0; hitId < mucRawHitCol.size(); hitId++ )
1544 {
1545 /* pMucRawHit = mucRawHitCol[ hitId ];
1546 part = pMucRawHit->Part();
1547 segment = pMucRawHit->Seg();
1548 layer = pMucRawHit->Gap();
1549 strip = pMucRawHit->Strip();
1550 */
1551 mucId = mucRawHitCol[hitId];
1552 int part = MucID::barrel_ec( mucId );
1553 int segment = MucID::segment( mucId );
1554 int layer = MucID::layer( mucId );
1555 int strip = MucID::channel( mucId );
1556
1557 // cout<<__LINE__<<" mu p s l s "<<mucId<<" "<<part<<" "<<segment<<" "<<layer<<"
1558 // "<<strip<<endl;
1559 log << MSG::DEBUG << "[" << part << "\t" << segment << "\t" << layer << "\t" << strip
1560 << "]\t";
1561 // if( (hitId+1)%8 == 0 ) log << MSG::DEBUG << endmsg;
1562
1563 // Add hit
1564 MucMark* aMark = new MucMark( part, segment, layer, strip );
1565 m_calHitCol.push_back( aMark );
1566
1567 // Set seed flag
1568 // if( trkRecMode == 3 ) seedList[part][layer] = pMucRawHit->HitIsSeed(); // By
1569 // SlfTrk
1570
1571 // Find track segment
1572 if ( hitId == 0 )
1573 {
1574 trkSeg[segNum].push_back( aMark );
1575 segNum++;
1576 }
1577 else
1578 {
1579 log << MSG::DEBUG << "segNum: " << segNum << endmsg;
1580 bool notInSeg = true;
1581 for ( int segi = 0; segi < segNum; segi++ )
1582 {
1583 if ( aMark->IsInSegWith( *( trkSeg[segi][0] ) ) )
1584 {
1585 trkSeg[segi].push_back( aMark );
1586 notInSeg = false;
1587 break;
1588 }
1589 }
1590 // new track seg
1591 if ( notInSeg == true )
1592 {
1593 trkSeg[segNum].push_back( aMark );
1594 segNum++;
1595 if ( segNum > TRACK_SEG_MAX )
1596 {
1597 log << MSG::ERROR << "Track segment overflow: " << segNum << endmsg;
1598 break;
1599 }
1600 }
1601 } // End else
1602 } // End raw hits
1603 log << MSG::DEBUG << endmsg;
1604
1605 // Find maximal layers passed in track segments
1606 layerPassNum[0] = layerPassNum[1] = layerPassNum[2] = 0;
1607 for ( int segi = 0; segi < segNum; segi++ )
1608 {
1609 int tmpLayNum = 0;
1610 passMax[segi][0] = passMax[segi][1] = trkSeg[segi][0]->Layer();
1611 for ( unsigned int hiti = 1; hiti < trkSeg[segi].size(); hiti++ )
1612 {
1613 if ( trkSeg[segi][hiti]->Layer() < passMax[segi][0] )
1614 passMax[segi][0] = trkSeg[segi][hiti]->Layer();
1615 if ( trkSeg[segi][hiti]->Layer() > passMax[segi][1] )
1616 passMax[segi][1] = trkSeg[segi][hiti]->Layer();
1617 firedLay[segi][trkSeg[segi][hiti]->Layer()] = 1;
1618 }
1619
1620 for ( int layi = 0; layi < LAYER_MAX; layi++ )
1621 {
1622 if ( firedLay[segi][layi] ) tmpLayNum++;
1623 }
1624
1625 if ( segi == 0 ) layerPassNum[0] += passMax[segi][1] + 1;
1626 else layerPassNum[0] += ( passMax[segi][1] - passMax[segi][0] + 1 );
1627
1628 layerPassNum[1] += ( passMax[segi][1] - passMax[segi][0] + 1 );
1629 layerPassNum[2] += tmpLayNum;
1630
1631 trkSeg[segi].clear();
1632 }
1633 m_ntTrackEvent = m_currentEvent;
1634 m_ntTrackTag = m_eventTag;
1635 m_ntTrackSegFly = segNum;
1636 m_ntTrackLayFlyA = layerPassNum[0];
1637 m_ntTrackLayFlyB = layerPassNum[1];
1638 m_ntTrackLayFlyC = layerPassNum[2];
1639 m_trackInfoTuple->write();
1640 log << MSG::INFO << "Track\t" << trackId << "\tsegment(s):\t" << segNum
1641 << "\tlayer passed:\t" << layerPassNum[0] << "\t" << layerPassNum[1] << "\t"
1642 << layerPassNum[2] << endmsg;
1643 // if( layerPassNum[0]>B_LAY_NUM || layerPassNum[1]>B_LAY_NUM || layerPassNum[2]>B_LAY_NUM
1644 // )
1645 // log << MSG::ERROR << "Over max layer:\t" << m_currentRun << "\t" << m_currentEvent <<
1646 // endmsg;
1647
1648 // Expected hits in this rec track
1649 log << MSG::DEBUG << "Fitting hits(expected hits in a track): " << endmsg;
1650 // mucExpHitCol = (*trackIter)->GetExpectedHits();
1651 mucExpHitCol = ( *trackIter )->getExpHits();
1652
1653 expectedHitNum += mucExpHitCol.size();
1654 // cout<<__LINE__<<"expectedHitNum "<<expectedHitNum<<endl;
1655 for ( unsigned int hitId = 0; hitId < mucExpHitCol.size(); hitId++ )
1656 {
1657 // pMucRawHit = mucExpHitCol[ hitId ];
1658 // part = pMucRawHit->Part(); segment = pMucRawHit->Seg();
1659 // layer = pMucRawHit->Gap(); strip = pMucRawHit->Strip();
1660
1661 mucId = mucExpHitCol[hitId];
1662 int part = MucID::barrel_ec( mucId );
1663 int segment = MucID::segment( mucId );
1664 int layer = MucID::layer( mucId );
1665 int strip = MucID::channel( mucId );
1666 // cout<<__LINE__<<part<<" "<<segment<<" "<<layer<<" "<<strip<<endl;
1667 /*
1668 if( m_usePad != 0 )
1669 {
1670 pad = pMucRawHit->GetPadID(); padZ =
1671 pMucRawHit->GetIntersectZ(); padX = pMucRawHit->GetIntersectY(); padY =
1672 pMucRawHit->GetIntersectX(); // Note: local coordinate
1673
1674 if( part != BRID )
1675 {
1676 if(segment == 1) { padX = -padX; }
1677 else if(segment == 2) { padX = -padX, padY = -padY; }
1678 else if(segment == 3) { padY = -padY; }
1679 }
1680 }
1681 */
1682 // Avoid bias in seed layers
1683 // if( seedList[part][layer] == true ) continue;
1684
1685 MucMark* currentMark = new MucMark( part, segment, layer, strip );
1686 m_expHitCol.push_back( currentMark );
1687 // log << MSG::DEBUG << "[" << part << "\t" << segment << "\t" << layer << "\t" << strip
1688 // << "]\t"; if( (hitId+1)%8 == 0 ) log << MSG::DEBUG << endmsg;
1689
1690 // Judge efficiency hit
1691 int isInPos = -1;
1692 bool isInEffWindow = false;
1693 isInPos = currentMark->IsInCol( m_segDigiCol[part][segment] );
1694
1695 // Avoid bias in outer layers caused by low momentum tracks
1696 if ( part == BRID && ( layer - lastLayerBR > 1 ) ) continue;
1697 if ( part != BRID && ( layer - lastLayerEC > 1 ) ) continue;
1698
1699 // Avoid bias in both sides of the innermost layer of Barrel
1700 if ( part == BRID && layer == 0 && ( strip < 2 || strip > 45 ) )
1701 {
1702 if ( isInPos != -1 ) // expHit is fired
1703 {
1704 m_record[part][segment][layer][strip][2]++; // Efficiency hit number
1705 m_record[part][segment][layer][strip][1]++; // Rec track number
1706 m_effHitCol.push_back( m_segDigiCol[part][segment][isInPos] );
1707
1708 if ( m_usePad != 0 )
1709 {
1710 m_h2DExpMap[part][segment][layer]->Fill( padX, padY );
1711 m_h2DHitMap[part][segment][layer]->Fill( padX, padY );
1712 }
1713 }
1714 else
1715 {
1716 m_record[part][segment][layer][strip][1]++;
1717 if ( m_usePad != 0 ) m_h2DExpMap[part][segment][layer]->Fill( padX, padY );
1718 }
1719 continue; // Judge next hit
1720 }
1721
1722 // Eff calibration
1723 if ( isInPos != -1 ) // expHit is fired
1724 {
1725 m_record[part][segment][layer][strip][2]++; // Efficiency hit number
1726 m_record[part][segment][layer][strip][1]++; // Rec track number
1727 m_effHitCol.push_back( m_segDigiCol[part][segment][isInPos] );
1728
1729 if ( m_usePad != 0 )
1730 {
1731 m_h2DExpMap[part][segment][layer]->Fill( padX, padY );
1732 m_h2DHitMap[part][segment][layer]->Fill( padX, padY );
1733 }
1734
1735 continue; // Judge next hit
1736 }
1737 else
1738 for ( int tempStrip = 0, hiti = -m_effWindow; hiti <= m_effWindow; hiti++ )
1739 {
1740 if ( hiti == 0 ) continue;
1741 tempStrip = strip + hiti;
1742 if ( tempStrip < 0 || tempStrip > m_ptrIdTr->GetStripMax( part, segment, layer ) )
1743 continue;
1744
1745 isInPos = m_ptrMucMark->IsInCol( part, segment, layer, tempStrip,
1746 m_segDigiCol[part][segment] );
1747 if ( isInPos != -1 )
1748 {
1749 m_record[part][segment][layer][tempStrip][2]++; // Efficiency hit number
1750 m_record[part][segment][layer][tempStrip][1]++; // Rec track number
1751 m_effHitCol.push_back( m_segDigiCol[part][segment][isInPos] );
1752
1753 if ( m_usePad != 0 )
1754 {
1755 m_h2DExpMap[part][segment][layer]->Fill( padX, padY );
1756 m_h2DHitMap[part][segment][layer]->Fill( padX, padY );
1757 }
1758
1759 m_ntEffWindow = hiti;
1760 m_effWindowTuple->write();
1761 isInEffWindow = true;
1762 }
1763
1764 } // End else
1765
1766 if ( isInEffWindow ) { continue; } // Judge next hit
1767 else
1768 { // A hit should be fired but not fired and not in the EffWindow
1769 m_record[part][segment][layer][strip][1]++; // Rec track number
1770 if ( m_usePad != 0 ) m_h2DExpMap[part][segment][layer]->Fill( padX, padY );
1771 }
1772
1773 } // End expected hits
1774
1775 // Fill residual, and for the other way of eff calculation
1776 log << MSG::INFO << "Fill residual" << endmsg;
1777 vector<float> m_lineResCol = ( *trackIter )->getDistHits();
1778 vector<float> m_quadResCol = ( *trackIter )->getQuadDistHits();
1779 vector<float> m_extrResCol = ( *trackIter )->getExtDistHits();
1780 int mode = ( *trackIter )->GetRecMode();
1781
1782 for ( unsigned int nres = 0; nres < m_lineResCol.size(); nres++ )
1783 if ( fabs( m_lineResCol[nres] ) > resMax ) resMax = fabs( m_lineResCol[nres] );
1784
1785 log << MSG::INFO << "Good track for res" << endmsg;
1786 if ( trackHitNum > 4 && m_lineResCol[0] != -99 ) // track is good for res
1787 {
1788 // Fill res histograms
1789 bool firedFlag[PART_MAX][LAYER_MAX][2];
1790 for ( int iprt = 0; iprt < PART_MAX; iprt++ )
1791 for ( int jlay = 0; jlay < LAYER_MAX; jlay++ )
1792 firedFlag[iprt][jlay][0] = firedFlag[iprt][jlay][1] = false;
1793
1794 for ( unsigned int hitId = 0; hitId < mucExpHitCol.size(); hitId++ )
1795 {
1796 // pMucExpHit = mucExpHitCol[ hitId ];
1797 // part = pMucExpHit->Part(); segment = pMucExpHit->Seg(); layer =
1798 // pMucExpHit->Gap();
1799
1800 mucId = mucExpHitCol[hitId];
1801
1802 int part = MucID::barrel_ec( mucId );
1803 int segment = MucID::segment( mucId );
1804 int layer = MucID::layer( mucId );
1805 // cout<<__LINE__<<" m p s l"<<mucId<<" "<<part<<" "<<segment<<" "<<layer<<endl;
1806 firedFlag[part][layer][0] = true;
1807 }
1808
1809 log << MSG::INFO << "Fit res" << endmsg;
1810 for ( unsigned int hitId = 0; hitId < mucRawHitCol.size(); hitId++ )
1811 {
1812 // pMucRawHit = mucRawHitCol[ hitId ];
1813 // part = pMucRawHit->Part(); segment = pMucRawHit->Seg(); layer =
1814 // pMucRawHit->Gap();
1815
1816 mucId = mucRawHitCol[hitId];
1817 int part = MucID::barrel_ec( mucId );
1818 int segment = MucID::segment( mucId );
1819 int layer = MucID::layer( mucId );
1820 // cout<<__LINE__<<" part "<< mucId<<" "<<part<<" "<<segment<<" "<<layer<<endl;
1821 if ( part == BRID ) m_hBarrelResDist[layer]->Fill( m_lineResCol[hitId] );
1822 else m_hEndcapResDist[layer]->Fill( m_lineResCol[hitId] );
1823
1824 // if exp is true and fired is true, and not filled yet
1825 if ( firedFlag[part][layer][0] == true && firedFlag[part][layer][1] == false )
1826 {
1827 m_resPart = part;
1828 m_resSegment = segment;
1829 m_resLayer = layer;
1830 m_lineRes = m_lineResCol[hitId];
1831 // m_quadRes = m_quadResCol[hitId];
1832 // m_extrRes = m_extrResCol[hitId];
1833 m_quadRes = 999;
1834 m_extrRes = 999;
1835 m_resFired = 1;
1836 m_resMode = mode;
1837 m_resInfoTuple->write();
1838 // cout<<__LINE__<<" m_resInfoTuple->write "<<endl;
1839 }
1840
1841 firedFlag[part][layer][1] = true;
1842 }
1843
1844 log << MSG::INFO << "Exp res" << endmsg;
1845 for ( unsigned int hitId = 0; hitId < mucExpHitCol.size(); hitId++ )
1846 {
1847 // pMucExpHit = mucExpHitCol[ hitId ];
1848 // part = pMucExpHit->Part(); segment = pMucExpHit->Seg(); layer =
1849 // pMucExpHit->Gap();
1850
1851 mucId = mucExpHitCol[hitId];
1852 int part = MucID::barrel_ec( mucId );
1853 int segment = MucID::segment( mucId );
1854 int layer = MucID::layer( mucId );
1855 // cout<<__LINE__<<mucId<<" "<<part<<" "<<segment<<" "<<layer<<endl;
1856 if ( firedFlag[part][layer][0] == true && firedFlag[part][layer][1] == false )
1857 {
1858 m_resPart = part;
1859 m_resSegment = segment;
1860 m_resLayer = layer;
1861 m_lineRes = 1000;
1862 m_quadRes = 1000;
1863 m_extrRes = 1000;
1864 m_resFired = 0;
1865 m_resMode = mode;
1866 m_resInfoTuple->write();
1867 }
1868 }
1869
1870 } // End fill residual, if track is good for res
1871
1872 mucRawHitCol.clear();
1873 mucExpHitCol.clear();
1874
1875 } // End read all tracks
1876
1877 // if( resMax > 300 ) cout <<"Res too big!\t"<< m_fTotalEvent <<"\t"<< m_currentRun <<"\t"<<
1878 // m_currentEvent <<"\t"<< resMax << endl;
1879
1880 m_ntTrackNum = mucTrackCol->size();
1881
1882 m_fTotalEffHit += rawHitNum;
1883 log << MSG::INFO << "Total hits in this event, raw: " << rawHitNum
1884 << "\texpected: " << expectedHitNum << endmsg;
1885 //<--- End retrieve rec tracks
1886
1887 //---> Searching inc/noise hits
1888 log << MSG::INFO << "Searching inc/noise hits" << endmsg;
1889 bool isNosHit;
1890 bool hasEffHit;
1891 for ( unsigned int i = 0; i < m_digiCol.size(); i++ )
1892 {
1893 isNosHit = true;
1894
1895 if ( m_digiCol[i]->IsInCol( m_effHitCol ) != -1 ) continue; // digi in effHitCol
1896 else
1897 {
1898 for ( unsigned int j = 0; j < m_clusterCol.size(); j++ )
1899 {
1900 hasEffHit = false;
1901 for ( unsigned int k = 0; k < m_clusterCol[j].size(); k++ )
1902 {
1903 if ( m_clusterCol[j][k]->IsInCol( m_effHitCol ) != -1 ) // Clusters have efficiency
1904 // hit
1905 {
1906 hasEffHit = true;
1907 break; // Out a cluster
1908 }
1909 }
1910
1911 if ( hasEffHit && ( m_digiCol[i]->IsInCol( m_clusterCol[j] ) != -1 ) )
1912 {
1913 isNosHit = false;
1914 break; // Out cluster collection
1915 }
1916 } // End cluster col
1917
1918 if ( isNosHit )
1919 {
1920 m_nosHitCol.push_back( m_digiCol[i] );
1921 m_fTotalNosHit++;
1922 }
1923 } // End else
1924 } // End digi collection
1925
1926 return StatusCode::SUCCESS;
1927}
1928
1929// Check event
1930StatusCode MucCalibMgr::CheckEvent() {
1931 MsgStream log( msgSvc, "MucCalibMgr" );
1932 log << MSG::INFO << "Check event" << endmsg;
1933
1934 // Find over digis in digis
1935 // Note that only one digi relates to one strip
1936 log << MSG::INFO << "Searching over digi" << endmsg;
1937 int overDigi = 0;
1938 for ( unsigned int i = 0; i < m_digiCol.size(); i++ )
1939 for ( unsigned int j = i + 1; j < m_digiCol.size(); j++ )
1940 {
1941 if ( ( *m_digiCol[i] ) == ( *m_digiCol[j] ) ) overDigi++;
1942 }
1943
1944 if ( overDigi != 0 ) log << MSG::ERROR << overDigi << " over digi found in digis!" << endmsg;
1945
1946 // Find over hits in reconstruction hits
1947 // Note that two tracks may pass thought one strip
1948 log << MSG::INFO << "Searching over hit" << endmsg;
1949 int overHit = 0;
1950 for ( unsigned int i = 0; i < m_expHitCol.size(); i++ )
1951 for ( unsigned int j = i + 1; j < m_expHitCol.size(); j++ )
1952 {
1953 if ( ( *m_expHitCol[i] ) == ( *m_expHitCol[j] ) ) overHit++;
1954 }
1955
1956 if ( overHit != 0 )
1957 log << MSG::WARNING << overHit << " over hits found in rec hits!" << endmsg;
1958
1959 // Find hits of reconstruction not in MUCdigis
1960 log << MSG::INFO << "Searching new hit" << endmsg;
1961 int newHit = 0;
1962 int num = 0;
1963 for ( unsigned int i = 0; i < m_expHitCol.size(); i++ )
1964 {
1965 num = m_expHitCol[i]->NumInCol( m_digiCol );
1966 if ( num == 0 )
1967 {
1968 log << MSG::ERROR << "Exp hit not in digis!"
1969 << "prt: " << ( *m_expHitCol[i] ).Part()
1970 << "\tseg: " << ( *m_expHitCol[i] ).Segment()
1971 << "\tlay: " << ( *m_expHitCol[i] ).Layer()
1972 << "\tstr: " << ( *m_expHitCol[i] ).Strip() << endmsg;
1973
1974 newHit++;
1975 }
1976 }
1977
1978 if ( newHit != 0 )
1979 log << MSG::WARNING << newHit << " new hit(s) found in rec hits!" << endmsg;
1980
1981 return StatusCode::SUCCESS;
1982}
1983
1984// Fill event
1985StatusCode MucCalibMgr::FillEvent() {
1986 MsgStream log( msgSvc, "MucCalibMgr" );
1987 log << MSG::INFO << "Fill event" << endmsg;
1988
1989 int part, segment, layer, strip, size;
1990 part = segment = layer = strip = size = 0;
1991
1992 // Fill digis
1993 log << MSG::INFO << "Fill digis" << endmsg;
1994 for ( unsigned int i = 0; i < m_digiCol.size(); i++ )
1995 {
1996 part = ( *m_digiCol[i] ).Part();
1997 segment = ( *m_digiCol[i] ).Segment();
1998 layer = ( *m_digiCol[i] ).Layer();
1999 strip = ( *m_digiCol[i] ).Strip();
2000
2001 FillDigi( part, segment, layer, strip );
2002 m_record[part][segment][layer][strip][0]++;
2003 m_fTotalDigi++;
2004 }
2005
2006 // Fill rec hits
2007 log << MSG::INFO << "Fill rec hits" << endmsg;
2008 for ( unsigned int i = 0; i < m_expHitCol.size(); i++ )
2009 {
2010 part = ( *m_expHitCol[i] ).Part();
2011 segment = ( *m_expHitCol[i] ).Segment();
2012 layer = ( *m_expHitCol[i] ).Layer();
2013 strip = ( *m_expHitCol[i] ).Strip();
2014
2015 FillExpHit( part, segment, layer, strip );
2016 m_record[part][segment][layer][strip][4]++;
2017 m_fTotalExpHit++;
2018 }
2019
2020 // Fill eff hits
2021 log << MSG::INFO << "Fill eff hits" << endmsg;
2022 for ( unsigned int i = 0; i < m_effHitCol.size(); i++ )
2023 {
2024 part = ( *m_effHitCol[i] ).Part();
2025 segment = ( *m_effHitCol[i] ).Segment();
2026 layer = ( *m_effHitCol[i] ).Layer();
2027 strip = ( *m_effHitCol[i] ).Strip();
2028
2029 FillEffHit( part, segment, layer, strip );
2030 m_fTotalEffHit++;
2031 }
2032
2033 // Fill clusters
2034 log << MSG::INFO << "Fill clusters" << endmsg;
2035 for ( unsigned int i = 0; i < m_clusterCol.size(); i++ )
2036 {
2037 size = m_clusterCol[i].size();
2038 // may include the special cluster, size = 1
2039 if ( size > CLUSTER_CUT )
2040 {
2041 part = ( *m_clusterCol[i][0] ).Part();
2042 segment = ( *m_clusterCol[i][0] ).Segment();
2043 layer = ( *m_clusterCol[i][0] ).Layer();
2044
2045 FillCluster( part, segment, layer, size );
2046 m_ntClusterSize = size;
2047 m_clusterSizeTuple->write();
2048 }
2049 }
2050
2051 // Fill inc/noise hits
2052 log << MSG::INFO << "Fill inc/noise hits" << endmsg;
2053 for ( unsigned int i = 0; i < m_nosHitCol.size(); i++ )
2054 {
2055 part = ( *m_nosHitCol[i] ).Part();
2056 segment = ( *m_nosHitCol[i] ).Segment();
2057 layer = ( *m_nosHitCol[i] ).Layer();
2058 strip = ( *m_nosHitCol[i] ).Strip();
2059
2060 FillNosHit( part, segment, layer, strip );
2061 m_record[part][segment][layer][strip][3]++;
2062 }
2063
2064 // Event log
2065 m_ntEventId = m_currentEvent;
2066 m_ntEventTag = m_eventTag;
2067 m_ntDigiNum = m_digiCol.size();
2068 m_ntExpHitNum = m_expHitCol.size();
2069 m_ntEffHitNum = m_effHitCol.size();
2070 m_ntNosHitNum = m_nosHitCol.size();
2071 m_ntClusterNum = m_clusterCol.size();
2072
2073 // Reset mark collection
2074 for ( unsigned int i = 0; i < m_digiCol.size(); i++ )
2075 {
2076 if ( m_digiCol[i] != NULL ) delete m_digiCol[i];
2077 }
2078
2079 for ( unsigned int i = 0; i < m_expHitCol.size(); i++ )
2080 {
2081 if ( m_expHitCol[i] != NULL ) delete m_expHitCol[i];
2082 }
2083 /*
2084 for( unsigned int i=0; i<m_effHitCol.size(); i++ ) {
2085 if( m_effHitCol[i] != NULL ) delete m_effHitCol[i];
2086 }
2087 log << MSG::INFO << m_effHitCol.size() << endmsg;
2088 */
2089 for ( unsigned int i = 0; i < m_calHitCol.size(); i++ )
2090 {
2091 if ( m_calHitCol[i] != NULL ) delete m_calHitCol[i];
2092 }
2093
2094 if ( m_digiCol.size() != 0 ) m_digiCol.clear();
2095 if ( m_expHitCol.size() != 0 ) m_expHitCol.clear();
2096 if ( m_calHitCol.size() != 0 ) m_calHitCol.clear();
2097 if ( m_effHitCol.size() != 0 ) m_effHitCol.clear();
2098 if ( m_nosHitCol.size() != 0 ) m_nosHitCol.clear();
2099 if ( m_clusterCol.size() != 0 ) m_clusterCol.clear();
2100
2101 for ( int i = 0; i < PART_MAX; i++ )
2102 {
2103 for ( int j = 0; j < SEGMENT_MAX; j++ )
2104 {
2105 if ( m_segDigiCol[i][j].size() != 0 ) m_segDigiCol[i][j].clear();
2106 }
2107 }
2108
2109 m_evtEnd = clock();
2110
2111 m_ntEventTime = ( double( m_evtEnd - m_evtBegin ) ) / CLOCKS_PER_SEC;
2112 log << MSG::INFO << "Event time:\t" << m_ntEventTime << "s" << endmsg;
2113 m_eventLogTuple->write();
2114
2115 return StatusCode::SUCCESS;
2116}
2117
2118StatusCode MucCalibMgr::FillDigi( int part, int segment, int layer, int strip ) {
2119 // Hit map for online check
2120 int tmpId;
2121
2122 if ( (int)m_tag || m_dimuOnly == 0 || ( m_dimuOnly == 1 && m_eventTag == 1 ) )
2123 {
2124 if ( part == BRID )
2125 {
2126 // According to layer
2127 if ( layer % 2 == 0 )
2128 {
2129 if ( segment > 4 ) tmpId = segment * 48 + ( 47 - strip );
2130 else tmpId = segment * 48 + strip;
2131 }
2132 else if ( segment < 3 ) tmpId = segment * 96 + strip;
2133 else tmpId = ( segment - 1 ) * 96 + 112 + strip;
2134
2135 m_hHitMapBarrel_Lay[layer]->Fill( tmpId );
2136
2137 // According to segment
2138 if ( segment != B_TOP )
2139 {
2140 if ( segment > 4 )
2141 tmpId = 48 * ( ( layer + 1 ) / 2 ) + 96 * ( layer / 2 ) +
2142 ( ( ( layer + 1 ) % 2 ) * 48 + ( layer % 2 ) * 96 - strip - 1 );
2143 else tmpId = 48 * ( ( layer + 1 ) / 2 ) + 96 * ( layer / 2 ) + strip;
2144 }
2145 else tmpId = 48 * ( ( layer + 1 ) / 2 ) + 112 * ( layer / 2 ) + strip;
2146
2147 m_hHitMapBarrel_Seg[segment]->Fill( tmpId );
2148 }
2149 else if ( part == EEID )
2150 {
2151 // According to layer
2152 tmpId = segment * 64 + strip;
2153 m_hHitMapEndcap_Lay[0][layer]->Fill( tmpId );
2154 // According to segment
2155 tmpId = layer * 64 + strip;
2156 m_hHitMapEndcap_Seg[0][segment]->Fill( tmpId );
2157 }
2158 else if ( part == EWID )
2159 {
2160 // According to layer
2161 tmpId = segment * 64 + strip;
2162 m_hHitMapEndcap_Lay[1][layer]->Fill( tmpId );
2163 // According to segment
2164 tmpId = layer * 64 + strip;
2165 m_hHitMapEndcap_Seg[1][segment]->Fill( tmpId );
2166 }
2167 }
2168
2169 // Total units
2170 int boxId = m_ptrIdTr->GetBoxId( part, segment, layer );
2171 int strId = m_ptrIdTr->GetStripId( part, segment, layer, strip );
2172
2173 m_hStripFireMap[boxId]->Fill( strip );
2174 m_hStripFire->Fill( strId );
2175 m_hBoxFire->Fill( boxId );
2176 m_hLayerFire->Fill( layer );
2177 if ( part == BRID ) m_hBrLayerFire->Fill( layer );
2178 else if ( part == EEID ) m_hEcLayerFire->Fill( layer + 1 );
2179 else m_hEcLayerFire->Fill( -( layer + 1 ) );
2180
2181 return StatusCode::SUCCESS;
2182}
2183
2184StatusCode MucCalibMgr::FillExpHit( int part, int segment, int layer, int strip ) {
2185 int boxId = m_ptrIdTr->GetBoxId( part, segment, layer );
2186 int strId = m_ptrIdTr->GetStripId( part, segment, layer, strip );
2187
2188 m_hStripExpHitMap[boxId]->Fill( strip );
2189 m_hStripExpHit->Fill( strId );
2190 m_hBoxExpHit->Fill( boxId );
2191 m_hLayerExpHit->Fill( layer );
2192
2193 return StatusCode::SUCCESS;
2194}
2195
2196StatusCode MucCalibMgr::FillEffHit( int part, int segment, int layer, int strip ) {
2197 int boxId = m_ptrIdTr->GetBoxId( part, segment, layer );
2198 int strId = m_ptrIdTr->GetStripId( part, segment, layer, strip );
2199
2200 m_hStripEffHitMap[boxId]->Fill( strip );
2201 m_hStripEffHit->Fill( strId );
2202 m_hBoxEffHit->Fill( boxId );
2203 m_hLayerEffHit->Fill( layer );
2204
2205 return StatusCode::SUCCESS;
2206}
2207
2208StatusCode MucCalibMgr::FillNosHit( int part, int segment, int layer, int strip ) {
2209 int boxId = m_ptrIdTr->GetBoxId( part, segment, layer );
2210 int strId = m_ptrIdTr->GetStripId( part, segment, layer, strip );
2211
2212 m_hStripNosHitMap[boxId]->Fill( strip );
2213 m_hStripNosHit->Fill( strId );
2214 m_hBoxNosHit->Fill( boxId );
2215 m_hLayerNosHit->Fill( layer );
2216
2217 return StatusCode::SUCCESS;
2218}
2219
2220StatusCode MucCalibMgr::FillCluster( int part, int segment, int layer, int size ) {
2221 int boxId = m_ptrIdTr->GetBoxId( part, segment, layer );
2222
2223 m_hLayerCluster[layer]->Fill( size );
2224 m_hBoxCluster[boxId]->Fill( size );
2225
2226 return StatusCode::SUCCESS;
2227}
2228
2229//-------------------------------------------------------------------------------------------------
2230//-------------------------------- Member functions for finalizing
2231//--------------------------------
2232//-------------------------------------------------------------------------------------------------
2233
2234StatusCode MucCalibMgr::AnalyseEffAndNoise() {
2235 MsgStream log( msgSvc, "MucCalibMgr" );
2236 log << MSG::INFO << "Start efficiency and noise calibration" << endmsg;
2237
2238 // Set time
2239 m_fTotalDAQTime = m_fTotalEvent / m_er;
2240 log << MSG::INFO << "Total run time:\t" << m_fTotalDAQTime << endmsg;
2241
2242 EffAndNoiseLV2();
2243 EffAndNoiseLV1();
2244 EffAndNoiseLV0();
2245
2246 if ( m_usePad != 0 ) PadEff();
2247
2248 return StatusCode::SUCCESS;
2249}
2250
2251StatusCode MucCalibMgr::EffAndNoiseLV0() {
2252 MsgStream log( msgSvc, "MucCalibMgr" );
2253 log << MSG::INFO << "Analyse layer efficiency and noise" << endmsg;
2254
2255 int part, segment, layer, stripMax;
2256 part = segment = layer = stripMax = 0;
2257
2258 double digi, effHit, trackNum, nosHit, recHit;
2259 double eff, effErr, noise, nosRatio, nosRatioErr, cnt, cluster;
2260 eff = effErr = noise = nosRatio = nosRatioErr = cnt = cluster = 0.;
2261
2262 for ( int i = 0; i < LAYER_MAX; i++ )
2263 {
2264 digi = effHit = trackNum = nosHit = recHit = 0;
2265
2266 for ( int j = 0; j < PART_MAX; j++ )
2267 {
2268 for ( int k = 0; k < SEGMENT_MAX; k++ )
2269 {
2270 stripMax = m_ptrIdTr->GetStripMax( j, k, i );
2271 for ( int n = 0; n < stripMax; n++ )
2272 {
2273 digi += m_record[j][k][i][n][0];
2274 trackNum += m_record[j][k][i][n][1];
2275 effHit += m_record[j][k][i][n][2];
2276 nosHit += m_record[j][k][i][n][3];
2277 recHit += m_record[j][k][i][n][4];
2278 }
2279 }
2280 }
2281
2282 // Efficiency
2283 if ( trackNum == 0 )
2284 {
2285 eff = effErr = 0.0;
2286 // eff = DEFAULT_EFF_VALUE;
2287 // effErr = DEFAULT_EFF_ERR;
2288 }
2289 else
2290 {
2291 eff = ( (double)effHit ) / trackNum;
2292 effErr = sqrt( eff * ( 1 - eff ) / trackNum );
2293 m_fCalibLayerNum++;
2294 }
2295
2296 // Noise
2297 if ( m_layerResults[3][i] < LIMIT_CUT || m_fTotalDAQTime < LIMIT_CUT )
2298 noise = DEFAULT_NOS_VALUE;
2299 else
2300 {
2301 if ( m_recMode == 2 )
2302 noise = (double)nosHit / ( m_fTotalEvent * TRIGGER_WINDOW * m_layerResults[3][i] );
2303 else noise = (double)nosHit / ( m_fTotalDAQTime * m_layerResults[3][i] );
2304 }
2305
2306 if ( digi != 0 )
2307 {
2308 nosRatio = ( (double)nosHit ) / digi;
2309 nosRatioErr = sqrt( nosRatio * ( 1 - nosRatio ) / digi );
2310 }
2311 else
2312 {
2313 nosRatio = DEFAULT_INC_VALUE;
2314 nosRatioErr = 0;
2315 }
2316
2317 // Counting rate
2318 if ( m_recMode == 2 )
2319 cnt = (double)digi / ( m_fTotalEvent * TRIGGER_WINDOW * m_layerResults[3][i] );
2320 else cnt = (double)digi / ( m_fTotalDAQTime * m_layerResults[3][i] );
2321
2322 // Cluster
2323 cluster = m_hLayerCluster[i]->GetMean();
2324
2325 m_layerResults[0][i] = eff;
2326 m_layerResults[1][i] = effErr;
2327 m_layerResults[2][i] = noise;
2328 m_layerResults[4][i] = cluster;
2329 m_layerResults[5][i] = trackNum;
2330
2331 // Fill histogram
2332 m_hLayerEff->Fill( i, eff );
2333 m_hLayerEff->SetBinError( i + 1, effErr );
2334 m_hLayerNosRatio->Fill( i, nosRatio );
2335 m_hLayerNosRatio->SetBinError( i + 1, nosRatioErr );
2336 m_hLayerNos->Fill( i, noise );
2337 m_hLayerCnt->Fill( i, cnt );
2338
2339 // Add cluster histogram
2340 m_hLayerClusterCmp->Fill( i, cluster );
2341
2342 // Fill tree
2343 m_fLayerId = i;
2344 m_fLayerEff = eff;
2345 m_fLayerEffErr = effErr;
2346 m_fLayerTrkNum = trackNum;
2347 m_fLayerExpHit = recHit;
2348 m_fLayerEffHit = effHit;
2349 m_fLayerNosRatio = nosRatio;
2350 m_fLayerDigi = digi;
2351 m_fLayerNosHit = nosHit;
2352 m_fLayerNos = noise;
2353 m_fLayerCnt = cnt;
2354 m_tLayConst->Fill();
2355
2356 // Add cluster ntuple
2357 m_fLayerCluster = cluster;
2358
2359 } // End layer
2360
2361 return StatusCode::SUCCESS;
2362}
2363
2364StatusCode MucCalibMgr::EffAndNoiseLV1() {
2365 MsgStream log( msgSvc, "MucCalibMgr" );
2366 log << MSG::INFO << "Analyse box efficiency and noise" << endmsg;
2367
2368 int part, segment, layer, stripMax;
2369 part = segment = layer = stripMax = 0;
2370
2371 double digi, effHit, trackNum, nosHit, recHit;
2372 double eff, effErr, noise, nosRatio, nosRatioErr, cnt, cluster;
2373 eff = effErr = noise = nosRatio = nosRatioErr = cnt = cluster = 0.;
2374
2375 for ( int i = 0; i < BOX_MAX; i++ )
2376 {
2377 m_ptrIdTr->SetBoxPos( i, &part, &segment, &layer );
2378 stripMax = m_ptrIdTr->GetStripMax( part, segment, layer );
2379
2380 digi = effHit = trackNum = nosHit = recHit = 0;
2381 for ( int j = 0; j < stripMax; j++ )
2382 {
2383 digi += m_record[part][segment][layer][j][0];
2384 trackNum += m_record[part][segment][layer][j][1];
2385 effHit += m_record[part][segment][layer][j][2];
2386 nosHit += m_record[part][segment][layer][j][3];
2387 recHit += m_record[part][segment][layer][j][4];
2388 }
2389
2390 // Efficiency
2391 if ( trackNum == 0 )
2392 {
2393 eff = effErr = 0.0;
2394 // eff = DEFAULT_EFF_VALUE;
2395 // effErr = DEFAULT_EFF_ERR;
2396 }
2397 else
2398 {
2399 eff = ( (double)effHit ) / trackNum;
2400 effErr = sqrt( eff * ( 1 - eff ) / trackNum );
2401 m_fCalibBoxNum++;
2402 }
2403
2404 // Noise
2405 if ( m_boxResults[3][i] < LIMIT_CUT || m_fTotalDAQTime < LIMIT_CUT )
2406 noise = DEFAULT_NOS_VALUE;
2407 else
2408 {
2409 if ( m_recMode == 2 )
2410 noise = (double)nosHit / ( m_fTotalEvent * TRIGGER_WINDOW * m_boxResults[3][i] );
2411 else noise = (double)nosHit / ( m_fTotalDAQTime * m_boxResults[3][i] );
2412 }
2413
2414 if ( digi != 0 )
2415 {
2416 nosRatio = ( (double)nosHit ) / digi;
2417 nosRatioErr = sqrt( nosRatio * ( 1 - nosRatio ) / digi );
2418 }
2419 else
2420 {
2421 nosRatio = DEFAULT_INC_VALUE;
2422 nosRatioErr = 0;
2423 }
2424
2425 // Counting rate
2426 if ( m_recMode == 2 )
2427 cnt = (double)digi / ( m_fTotalEvent * TRIGGER_WINDOW * m_boxResults[3][i] );
2428 else cnt = (double)digi / ( m_fTotalDAQTime * m_boxResults[3][i] );
2429
2430 // Cluster
2431 cluster = m_hBoxCluster[i]->GetMean();
2432
2433 m_boxResults[0][i] = eff;
2434 m_boxResults[1][i] = effErr;
2435 m_boxResults[2][i] = noise;
2436 m_boxResults[4][i] = cluster;
2437 m_boxResults[5][i] = trackNum;
2438
2439 // Fill histograms
2440 m_hBoxEff->Fill( i, eff );
2441 m_hBoxEff->SetBinError( i + 1, effErr );
2442 m_hBoxNosRatio->Fill( i, nosRatio );
2443 m_hBoxNosRatio->SetBinError( i + 1, nosRatioErr );
2444 m_hBoxNos->Fill( i, noise );
2445 m_hBoxCnt->Fill( i, cnt );
2446
2447 // add cluster histogram
2448 m_hBoxClusterCmp->Fill( i, cluster );
2449
2450 // Fill tree
2451 m_fBoxId = i;
2452 m_fBoxPart = part;
2453 m_fBoxSegment = segment;
2454 m_fBoxLayer = layer;
2455 m_fBoxEff = eff;
2456 m_fBoxEffErr = effErr;
2457 m_fBoxTrkNum = trackNum;
2458 m_fBoxExpHit = recHit;
2459 m_fBoxEffHit = effHit;
2460 m_fBoxNosRatio = nosRatio;
2461 m_fBoxDigi = digi;
2462 m_fBoxNosHit = nosHit;
2463 m_fBoxNos = noise;
2464 m_fBoxCnt = cnt;
2465 m_tBoxConst->Fill();
2466
2467 // add box cluster ntuple
2468 m_fBoxCluster = cluster;
2469
2470 } // End BOX_MAX
2471
2472 return StatusCode::SUCCESS;
2473}
2474
2475StatusCode MucCalibMgr::EffAndNoiseLV2() {
2476 MsgStream log( msgSvc, "MucCalibMgr" );
2477 log << MSG::INFO << "Analyse strip efficiency and noise" << endmsg;
2478
2479 int part, segment, layer, stripMax;
2480 part = segment = layer = stripMax = 0;
2481
2482 double digi, effHit, trackNum, nosHit, recHit;
2483 double eff, effErr, noise, nosRatio, nosRatioErr, cnt, cluster;
2484 eff = effErr = noise = nosRatio = nosRatioErr = cnt = cluster = 0.;
2485
2486 for ( int i = 0; i < BOX_MAX; i++ )
2487 {
2488 m_ptrIdTr->SetBoxPos( i, &part, &segment, &layer );
2489 stripMax = m_ptrIdTr->GetStripMax( part, segment, layer );
2490
2491 for ( int j = 0; j < stripMax; j++ )
2492 {
2493 digi = m_record[part][segment][layer][j][0];
2494 trackNum = m_record[part][segment][layer][j][1];
2495 effHit = m_record[part][segment][layer][j][2];
2496 nosHit = m_record[part][segment][layer][j][3];
2497 recHit = m_record[part][segment][layer][j][4];
2498
2499 int stripId = m_ptrIdTr->GetStripId( part, segment, layer, j );
2500
2501 // Efficiency
2502 if ( trackNum == 0 )
2503 {
2504 eff = effErr = 0.0;
2505 // eff = DEFAULT_EFF_VALUE;
2506 // effErr = DEFAULT_EFF_ERR;
2507 }
2508 else
2509 {
2510 eff = ( (double)effHit ) / trackNum;
2511 effErr = sqrt( eff * ( 1 - eff ) / trackNum );
2512 m_fCalibStripNum++;
2513 }
2514
2515 // Noise
2516 if ( m_stripResults[3][stripId] < LIMIT_CUT || m_fTotalDAQTime < LIMIT_CUT )
2517 noise = DEFAULT_NOS_VALUE;
2518 else
2519 {
2520 if ( m_recMode == 2 )
2521 noise =
2522 (double)nosHit / ( m_fTotalEvent * TRIGGER_WINDOW * m_stripResults[3][stripId] );
2523 else noise = (double)nosHit / ( m_fTotalDAQTime * m_stripResults[3][stripId] );
2524 }
2525
2526 if ( digi != 0 )
2527 {
2528 nosRatio = ( (double)nosHit ) / digi;
2529 nosRatioErr = sqrt( nosRatio * ( 1 - nosRatio ) / digi );
2530 }
2531 else
2532 {
2533 nosRatio = DEFAULT_INC_VALUE;
2534 nosRatioErr = 0.;
2535 }
2536
2537 // Counting rate
2538 if ( m_recMode == 2 )
2539 cnt = (double)digi / ( m_fTotalEvent * TRIGGER_WINDOW * m_stripResults[3][stripId] );
2540 else cnt = (double)digi / ( m_fTotalDAQTime * m_stripResults[3][stripId] );
2541
2542 // Strip itself no clusters
2543 m_stripResults[0][stripId] = eff;
2544 m_stripResults[1][stripId] = effErr;
2545 m_stripResults[2][stripId] = noise;
2546 m_stripResults[5][stripId] = trackNum;
2547
2548 // Fill histotram
2549 m_hStripEffMap[i]->Fill( j, eff );
2550 m_hStripEffMap[i]->SetBinError( j + 1, effErr );
2551 m_hStripEff->Fill( stripId, eff );
2552 m_hStripEff->SetBinError( stripId + 1, effErr );
2553 m_hStripNosRatioMap[i]->Fill( j, nosRatio );
2554 m_hStripNosRatioMap[i]->SetBinError( j + 1, nosRatioErr );
2555 m_hStripNosRatio->Fill( stripId, nosRatio );
2556 m_hStripNosRatio->SetBinError( stripId + 1, nosRatioErr );
2557 m_hStripNos->Fill( stripId, noise );
2558 m_hStripCnt->Fill( stripId, cnt );
2559
2560 // Fill Tree
2561 m_fStripId = stripId;
2562 m_fStripPart = part;
2563 m_fStripSegment = segment;
2564 m_fStripLayer = layer;
2565 m_fStripEff = eff;
2566 m_fStripEffErr = effErr;
2567 m_fStripNosRatio = nosRatio;
2568 m_fStripDigi = digi;
2569 m_fStripNos = noise;
2570 m_fStripCnt = cnt;
2571 m_fStripEffHit = effHit;
2572 m_fStripExpHit = recHit;
2573 m_fStripNosHit = nosHit;
2574 m_fStripTrkNum = trackNum;
2575 m_tStrConst->Fill();
2576
2577 } // End stripMax
2578 } // End BOX_MAX
2579
2580 return StatusCode::SUCCESS;
2581}
2582
2583StatusCode MucCalibMgr::PadEff() {
2584 MsgStream log( msgSvc, "MucCalibMgr" );
2585
2586 int xBinStart, xBinEnd, yBinStart, yBinEnd;
2587 double expHit, firedHit, eff;
2588 eff = expHit = firedHit = 0.;
2589
2590 for ( int i = 0; i < PART_MAX; i++ )
2591 for ( int j = 0; j < ( ( i == BRID ) ? B_SEG_NUM : E_SEG_NUM ); j++ )
2592 for ( int k = 0; k < ( ( i == BRID ) ? B_LAY_NUM : E_LAY_NUM ); k++ )
2593 {
2594 xBinStart = m_h2DExpMap[i][j][k]->GetXaxis()->GetFirst();
2595 xBinEnd = m_h2DExpMap[i][j][k]->GetXaxis()->GetLast() + 1;
2596 yBinStart = m_h2DExpMap[i][j][k]->GetYaxis()->GetFirst();
2597 yBinEnd = m_h2DExpMap[i][j][k]->GetYaxis()->GetLast() + 1;
2598
2599 for ( int xi = xBinStart; xi < xBinEnd; xi++ )
2600 for ( int yi = yBinStart; yi < yBinEnd; yi++ )
2601 {
2602 expHit = m_h2DExpMap[i][j][k]->GetBinContent( xi, yi );
2603 firedHit = m_h2DHitMap[i][j][k]->GetBinContent( xi, yi );
2604
2605 if ( expHit != 0 ) eff = firedHit / expHit;
2606 else eff = 0;
2607
2608 if ( eff > 1.0 )
2609 cout << "Eff error:\t[" << i << "\t" << j << "\t" << k << ",\t" << xi << "\t"
2610 << yi << "]:\t" << eff << "\t," << firedHit << " " << expHit << endl;
2611
2612 m_h2DEffMap[i][j][k]->SetBinContent( xi, yi, eff );
2613 }
2614 }
2615 return StatusCode::SUCCESS;
2616}
2617
2618StatusCode MucCalibMgr::AnalyseCluster() {
2619 MsgStream log( msgSvc, "MucCalibMgr" );
2620
2621 return StatusCode::SUCCESS;
2622}
2623
2624StatusCode MucCalibMgr::AnalyseRes() {
2625 MsgStream log( msgSvc, "MucCalibMgr" );
2626 log << MSG::INFO << "Analyse spacial resolution" << endmsg;
2627
2628 double resMean, resMeanErr, resSigma, resSigmaErr;
2629 resMean = resMeanErr = resSigma = resSigmaErr = 0.;
2630
2631 for ( int i = 0; i < B_LAY_NUM; i++ )
2632 {
2633 m_hBarrelResDist[i]->Fit( "gaus" );
2634 resMean = m_hBarrelResDist[i]->GetFunction( "gaus" )->GetParameter( "Mean" );
2635 resSigma = m_hBarrelResDist[i]->GetFunction( "gaus" )->GetParameter( "Sigma" );
2636 resMeanErr = m_hBarrelResDist[i]->GetFunction( "gaus" )->GetParError( 1 );
2637 resSigmaErr = m_hBarrelResDist[i]->GetFunction( "gaus" )->GetParError( 2 );
2638
2639 m_hBarrelResComp[0]->Fill( i, resMean );
2640 m_hBarrelResComp[0]->SetBinError( i + 1, resMeanErr );
2641 m_hBarrelResComp[1]->Fill( i, resSigma );
2642 m_hBarrelResComp[1]->SetBinError( i + 1, resSigmaErr );
2643 }
2644
2645 for ( int i = 0; i < E_LAY_NUM; i++ )
2646 {
2647 m_hEndcapResDist[i]->Fit( "gaus" );
2648 resMean = m_hEndcapResDist[i]->GetFunction( "gaus" )->GetParameter( "Mean" );
2649 resSigma = m_hEndcapResDist[i]->GetFunction( "gaus" )->GetParameter( "Sigma" );
2650 resMeanErr = m_hEndcapResDist[i]->GetFunction( "gaus" )->GetParError( 1 );
2651 resSigmaErr = m_hEndcapResDist[i]->GetFunction( "gaus" )->GetParError( 2 );
2652
2653 m_hEndcapResComp[0]->Fill( i, resMean );
2654 m_hEndcapResComp[0]->SetBinError( i + 1, resMeanErr );
2655 m_hEndcapResComp[1]->Fill( i, resSigma );
2656 m_hEndcapResComp[1]->SetBinError( i + 1, resSigmaErr );
2657 }
2658
2659 return StatusCode::SUCCESS;
2660}
2661
2662StatusCode MucCalibMgr::SaveConst() {
2663 MsgStream log( msgSvc, "MucCalibMgr" );
2664 log << MSG::INFO << "Save calibration constants" << endmsg;
2665
2666 // Save calibrated eff in graphes
2667 // LV0
2668 double layerXY[2][LAYER_MAX];
2669 double layerEXY[2][LAYER_MAX];
2670 for ( int i = 0; i < LAYER_MAX; i++ )
2671 {
2672 layerXY[0][i] = i;
2673 layerEXY[0][i] = 0;
2674 if ( m_layerResults[5][i] >= 100 * TRACK_THRESHOLD )
2675 {
2676 layerXY[1][i] = m_layerResults[0][i];
2677 layerEXY[1][i] = m_layerResults[1][i];
2678 }
2679 else
2680 {
2681 layerXY[1][i] = 0;
2682 layerEXY[1][i] = 0;
2683 }
2684 }
2685 m_geLayerEff =
2686 new TGraphErrors( LAYER_MAX, layerXY[0], layerXY[1], layerEXY[0], layerEXY[1] );
2687 m_geLayerEff->SetMarkerStyle( 25 );
2688 m_geLayerEff->SetMarkerSize( 0.5 );
2689 m_cv[0] = new TCanvas( "GoodLayerEff", "Layer efficiency", 50, 50, 800, 600 );
2690 m_cv[0]->SetFillColor( 0 );
2691 m_cv[0]->SetBorderMode( 0 );
2692 m_geLayerEff->Draw( "AP" );
2693 m_cv[0]->Write();
2694
2695 // LV1
2696 double boxXY[2][BOX_MAX];
2697 double boxEXY[2][BOX_MAX];
2698 for ( int i = 0; i < BOX_MAX; i++ )
2699 {
2700 boxXY[0][i] = i;
2701 boxEXY[0][i] = 0;
2702 if ( m_boxResults[5][i] >= 10 * TRACK_THRESHOLD )
2703 {
2704 boxXY[1][i] = m_boxResults[0][i];
2705 boxEXY[1][i] = m_boxResults[1][i];
2706 }
2707 else
2708 {
2709 boxXY[1][i] = 0;
2710 boxEXY[1][i] = 0;
2711 }
2712 }
2713 m_geBoxEff = new TGraphErrors( BOX_MAX, boxXY[0], boxXY[1], boxEXY[0], boxEXY[1] );
2714 m_geBoxEff->SetMarkerStyle( 25 );
2715 m_geBoxEff->SetMarkerSize( 0.5 );
2716 m_cv[1] = new TCanvas( "GoodBoxEff", "Box efficiency", 75, 75, 800, 600 );
2717 m_cv[1]->SetFillColor( 0 );
2718 m_cv[1]->SetBorderMode( 0 );
2719 m_geBoxEff->Draw( "AP" );
2720 m_cv[1]->Write();
2721
2722 // LV2
2723 double stripXY[2][STRIP_MAX];
2724 double stripEXY[2][STRIP_MAX];
2725 for ( int i = 0; i < STRIP_MAX; i++ )
2726 {
2727 stripXY[0][i] = i;
2728 stripEXY[0][i] = 0;
2729 if ( m_stripResults[5][i] >= TRACK_THRESHOLD )
2730 {
2731 stripXY[1][i] = m_stripResults[0][i];
2732 stripEXY[1][i] = m_stripResults[1][i];
2733 }
2734 else
2735 {
2736 stripXY[1][i] = 0;
2737 stripEXY[1][i] = 0;
2738 }
2739 }
2740 m_geStripEff =
2741 new TGraphErrors( STRIP_MAX, stripXY[0], stripXY[1], stripEXY[0], stripEXY[1] );
2742 m_geStripEff->SetMarkerStyle( 25 );
2743 m_geStripEff->SetMarkerSize( 0.5 );
2744 m_cv[2] = new TCanvas( "GoodStripEff", "Strip efficiency", 100, 100, 800, 600 );
2745 m_cv[2]->SetFillColor( 0 );
2746 m_cv[2]->SetBorderMode( 0 );
2747 m_geStripEff->Draw( "AP" );
2748 m_cv[2]->Write();
2749
2750 // Save histograms
2751 for ( int i = 0; i < B_LAY_NUM; i++ )
2752 {
2753 m_hHitMapBarrel_Lay[i]->Write();
2754
2755 if ( i < E_LAY_NUM )
2756 {
2757 m_hHitMapEndcap_Lay[0][i]->Write();
2758 m_hHitMapEndcap_Lay[1][i]->Write();
2759 }
2760 }
2761
2762 for ( int i = 0; i < B_SEG_NUM; i++ )
2763 {
2764 m_hHitMapBarrel_Seg[i]->Write();
2765
2766 if ( i < E_SEG_NUM )
2767 {
2768 m_hHitMapEndcap_Seg[0][i]->Write();
2769 m_hHitMapEndcap_Seg[1][i]->Write();
2770 }
2771 }
2772 m_hTrackDistance->Fit( "gaus" );
2773 m_hTrackPosPhiDiff->Fit( "gaus" );
2774 m_hTrackPosThetaDiff->Fit( "gaus" );
2775 m_hTrackMomPhiDiff->Fit( "gaus" );
2776 m_hTrackMomThetaDiff->Fit( "gaus" );
2777
2778 m_hTrackDistance->Write();
2779 m_hTrackPosPhiDiff->Write();
2780 m_hTrackPosThetaDiff->Write();
2781 m_hTrackMomPhiDiff->Write();
2782 m_hTrackMomThetaDiff->Write();
2783
2784 for ( int i = 0; i < B_LAY_NUM; i++ ) m_hBarrelResDist[i]->Write();
2785 for ( int i = 0; i < E_LAY_NUM; i++ ) m_hEndcapResDist[i]->Write();
2786
2787 m_hBarrelResComp[0]->Write();
2788 m_hBarrelResComp[1]->Write();
2789 m_hEndcapResComp[0]->Write();
2790 m_hEndcapResComp[1]->Write();
2791
2792 if ( m_usePad != 0 ) m_histArray->Write();
2793
2794 for ( int i = 0; i < BOX_MAX; i++ )
2795 {
2796 m_hStripFireMap[i]->Write();
2797 m_hStripExpHitMap[i]->Write();
2798 m_hStripEffHitMap[i]->Write();
2799 m_hStripNosHitMap[i]->Write();
2800 m_hStripEffMap[i]->Write();
2801 m_hStripNosRatioMap[i]->Write();
2802 }
2803 m_hStripFire->Write();
2804 m_hStripExpHit->Write();
2805 m_hStripEffHit->Write();
2806 m_hStripNosHit->Write();
2807 m_hStripEff->Write();
2808 m_hStripArea->Write();
2809 m_hStripNos->Write();
2810 m_hStripNosRatio->Write();
2811 log << MSG::INFO << "Save LV2 histograms done!" << endmsg;
2812
2813 m_hBoxFire->Write();
2814 m_hBoxExpHit->Write();
2815 m_hBoxEffHit->Write();
2816 m_hBoxNosHit->Write();
2817 m_hBoxEff->Write();
2818 m_hBoxArea->Write();
2819 m_hBoxNos->Write();
2820 m_hBoxNosRatio->Write();
2821 log << MSG::INFO << "Save LV1 histograms done!" << endmsg;
2822
2823 m_hBrLayerFire->Write();
2824 m_hEcLayerFire->Write();
2825 m_hLayerFire->Write();
2826 m_hLayerExpHit->Write();
2827 m_hLayerEffHit->Write();
2828 m_hLayerNosHit->Write();
2829 m_hLayerEff->Write();
2830 m_hLayerArea->Write();
2831 m_hLayerNos->Write();
2832 m_hLayerNosRatio->Write();
2833
2834 for ( int i = 0; i < LAYER_MAX; i++ ) m_hLayerCluster[i]->Write();
2835 for ( int i = 0; i < BOX_MAX; i++ ) m_hBoxCluster[i]->Write();
2836 m_hLayerClusterCmp->Write();
2837 m_hBoxClusterCmp->Write();
2838
2839 log << MSG::INFO << "Save histograms done!" << endmsg;
2840
2841 // Save trees
2842 m_fLayerCoverage = 100 * (double)m_fCalibLayerNum / LAYER_MAX;
2843 m_fBoxCoverage = 100 * (double)m_fCalibBoxNum / BOX_MAX;
2844 m_fStripCoverage = 100 * (double)m_fCalibStripNum / STRIP_MAX;
2845
2846 long digi_num, trk_num, eff_hit, nos_hit, exp_hit;
2847 m_tStatLog->Branch( "digi_num", &digi_num, "digi_num/I" );
2848 m_tStatLog->Branch( "trk_num", &trk_num, "trk_num/I" );
2849 m_tStatLog->Branch( "eff_hit", &eff_hit, "eff_hit/I" );
2850 m_tStatLog->Branch( "nos_hit", &nos_hit, "nos_hit/I" );
2851 m_tStatLog->Branch( "exp_hit", &exp_hit, "exp_hit/I" );
2852
2853 int stripMax;
2854 for ( int i = 0; i < PART_MAX; i++ )
2855 for ( int j = 0; j < ( ( i == BRID ) ? B_SEG_NUM : E_SEG_NUM ); j++ )
2856 for ( int k = 0; k < ( ( i == BRID ) ? B_LAY_NUM : E_LAY_NUM ); k++ )
2857 {
2858 stripMax = m_ptrIdTr->GetStripMax( i, j, k );
2859 for ( int n = 0; n < stripMax; n++ )
2860 {
2861 digi_num = m_record[i][j][k][n][0];
2862 trk_num = m_record[i][j][k][n][1];
2863 eff_hit = m_record[i][j][k][n][2];
2864 nos_hit = m_record[i][j][k][n][3];
2865 exp_hit = m_record[i][j][k][n][4];
2866 m_tStatLog->Fill();
2867 }
2868 }
2869
2870 m_jobFinish = clock();
2871 m_fTotalJobTime = (double)( m_jobFinish - m_jobStart ) / CLOCKS_PER_SEC;
2872
2873 m_tJobLog->Fill();
2874 m_tJobLog->Write();
2875 m_tStatLog->Write();
2876 m_tLayConst->Write();
2877 m_tBoxConst->Write();
2878 m_tStrConst->Write();
2879
2880 // Close cluster output file
2881 if ( m_fdata != NULL ) m_fdata->close();
2882
2883 return StatusCode::SUCCESS;
2884}
2885
2886StatusCode MucCalibMgr::EndRun() {
2887 MsgStream log( msgSvc, "MucCalibMgr" );
2888 log << MSG::INFO << endmsg;
2889 log << MSG::INFO << "Total events : " << m_fTotalEvent << endmsg;
2890 log << MSG::INFO << "Total digis : " << m_fTotalDigi << endmsg;
2891 log << MSG::INFO << "Total rec hits : " << m_fTotalExpHit << endmsg;
2892 log << MSG::INFO << "Total eff hits : " << m_fTotalEffHit << endmsg;
2893 log << MSG::INFO << "Total inc hits : " << m_fTotalNosHit << endmsg;
2894 log << MSG::INFO << "Total clusters : " << m_fTotalClstNum << endmsg;
2895
2896 log << MSG::INFO
2897 << "Strip calibrated percentage: " << 100 * (double)m_fCalibStripNum / STRIP_MAX << "%"
2898 << endmsg;
2899 log << MSG::INFO << "Box calibrated percentage: " << 100 * (double)m_fCalibBoxNum / BOX_MAX
2900 << "%" << endmsg;
2901 log << MSG::INFO
2902 << "Layer calibrated percentage: " << 100 * (double)m_fCalibLayerNum / LAYER_MAX << "%"
2903 << endmsg;
2904
2905 log << MSG::INFO << "Calibration run successfully" << endmsg << endmsg;
2906
2907 return StatusCode::SUCCESS;
2908}
2909
2910// END
sprintf
sprintf(cut, "kal_costheta0_em>-0.93&&kal_costheta0_em<0.93&&kal_pxy0_em>=0.05+%d*0.1&&kal_" "pxy0_em<0.15+%d*0.1&&NGch>=2", j, j)
n
const Int_t n
Definition DataBase/tau_mode.c:57
phi2
Double_t phi2
Definition DataBase/tau_mode.c:8
phi1
Double_t phi1
Definition DataBase/tau_mode.c:8
e1
Double_t e1
Definition DataBase/tau_mode.c:7
e2
Double_t e2
Definition DataBase/tau_mode.c:7
PI
#define PI
Definition EvtD0ToKKpi0.cc:40
title
titledef title[20]
Definition EvtPhokharaDef.hh:58
mark_col
vector< MucMark * > mark_col
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MucCalib/MucMark.h:17
RecMucTrackCol
ObjectVector< RecMucTrack > RecMucTrackCol
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MucRecEvent/RecMucTrack.h:357
theta2
@ theta2
Definition InstallArea/x86_64-el9-gcc13-dbg/include/TrkBase/TrkKalDeriv.h:24
theta1
@ theta1
Definition InstallArea/x86_64-el9-gcc13-dbg/include/TrkBase/TrkKalDeriv.h:24
Segment
#define Segment
Definition InstallArea/x86_64-el9-gcc13-dbg/include/TrkReco/TTrackBase.h:31
MucCalibMgr::ClearHistoLV2
StatusCode ClearHistoLV2()
Definition MucCalibMgr.cxx:265
MucCalibMgr::InitResHisto
StatusCode InitResHisto()
Definition MucCalibMgr.cxx:882
MucCalibMgr::FillEffHit
StatusCode FillEffHit(int part, int segment, int layer, int strip)
Definition MucCalibMgr.cxx:2196
MucCalibMgr::DimuSelect
StatusCode DimuSelect()
Definition MucCalibMgr.cxx:1048
MucCalibMgr::InitOnlineHisto
StatusCode InitOnlineHisto()
Definition MucCalibMgr.cxx:596
MucCalibMgr::Init2DEffHisto
StatusCode Init2DEffHisto()
Definition MucCalibMgr.cxx:805
MucCalibMgr::SaveConst
StatusCode SaveConst()
Definition MucCalibMgr.cxx:2662
MucCalibMgr::FillExpHit
StatusCode FillExpHit(int part, int segment, int layer, int strip)
Definition MucCalibMgr.cxx:2184
MucCalibMgr::ClearResHisto
StatusCode ClearResHisto()
Definition MucCalibMgr.cxx:323
MucCalibMgr::ClearHistoLV0
StatusCode ClearHistoLV0()
Definition MucCalibMgr.cxx:233
MucCalibMgr::ClearClusterHisto
StatusCode ClearClusterHisto()
Definition MucCalibMgr.cxx:305
MucCalibMgr::AnalyseCluster
StatusCode AnalyseCluster()
Definition MucCalibMgr.cxx:2618
MucCalibMgr::ClearHistoLV1
StatusCode ClearHistoLV1()
Definition MucCalibMgr.cxx:250
MucCalibMgr::PadEff
StatusCode PadEff()
Definition MucCalibMgr.cxx:2583
MucCalibMgr::InitHistoLV1
StatusCode InitHistoLV1()
Definition MucCalibMgr.cxx:733
MucCalibMgr::InitHistoLV2
StatusCode InitHistoLV2()
Definition MucCalibMgr.cxx:749
MucCalibMgr::InitClusterHisto
StatusCode InitClusterHisto()
Definition MucCalibMgr.cxx:852
MucCalibMgr::FillCluster
StatusCode FillCluster(int part, int segment, int layer, int size)
Definition MucCalibMgr.cxx:2220
MucCalibMgr::ClearOnlineHisto
StatusCode ClearOnlineHisto()
Definition MucCalibMgr.cxx:213
MucCalibMgr::InitHisto
StatusCode InitHisto()
Definition MucCalibMgr.cxx:571
MucCalibMgr::FillEvent
StatusCode FillEvent()
Definition MucCalibMgr.cxx:1985
MucCalibMgr::EffAndNoiseLV2
StatusCode EffAndNoiseLV2()
Definition MucCalibMgr.cxx:2475
MucCalibMgr::MucCalibMgr
MucCalibMgr(std::vector< double > jobInfo, std::vector< int > configInfo, std::string outputFile)
Definition MucCalibMgr.cxx:59
MucCalibMgr::InitHistoLV0
StatusCode InitHistoLV0()
Definition MucCalibMgr.cxx:707
MucCalibMgr::EndRun
StatusCode EndRun()
Definition MucCalibMgr.cxx:2886
MucCalibMgr::ReadEvent
StatusCode ReadEvent()
Definition MucCalibMgr.cxx:1193
MucCalibMgr::EffAndNoiseLV1
StatusCode EffAndNoiseLV1()
Definition MucCalibMgr.cxx:2364
MucCalibMgr::AnalyseRes
StatusCode AnalyseRes()
Definition MucCalibMgr.cxx:2624
MucCalibMgr::CheckEvent
StatusCode CheckEvent()
Definition MucCalibMgr.cxx:1930
MucCalibMgr::FillNosHit
StatusCode FillNosHit(int part, int segment, int layer, int strip)
Definition MucCalibMgr.cxx:2208
MucCalibMgr::EffAndNoiseLV0
StatusCode EffAndNoiseLV0()
Definition MucCalibMgr.cxx:2251
MucCalibMgr::InitConstTree
StatusCode InitConstTree()
Definition MucCalibMgr.cxx:913
MucCalibMgr::ClearConstTree
StatusCode ClearConstTree()
Definition MucCalibMgr.cxx:342
MucCalibMgr::InitArea
StatusCode InitArea()
Definition MucCalibMgr.cxx:1007
MucCalibMgr::AnalyseEffAndNoise
StatusCode AnalyseEffAndNoise()
Definition MucCalibMgr.cxx:2234
MucCalibMgr::InitNtuple
StatusCode InitNtuple()
Definition MucCalibMgr.cxx:359
MucCalibMgr::Clear2DEffHisto
StatusCode Clear2DEffHisto()
Definition MucCalibMgr.cxx:290
MucCalibMgr::FillDigi
StatusCode FillDigi(int part, int segment, int layer, int strip)
Definition MucCalibMgr.cxx:2118
MucEntityCal::GetArea
double GetArea()
Definition MucEntityCal.cxx:88
MucID::barrel_ec
static int barrel_ec(const Identifier &id)
Values of different levels.
Definition MucID.cxx:38
MucID::layer
static int layer(const Identifier &id)
Definition MucID.cxx:58
MucID::channel
static int channel(const Identifier &id)
Definition MucID.cxx:68
MucID::segment
static int segment(const Identifier &id)
Definition MucID.cxx:48
MucMark::IsInSegWith
bool IsInSegWith(MucMark &other)
Definition MucMark.cxx:140
MucMark::IsInCol
int IsInCol(int part, int segment, int layer, int strip, mark_col &aCol)
Definition MucMark.cxx:98
TofHitStatus::setStatus
void setStatus(unsigned int status)
Definition TofHitStatus.cxx:115