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

#include <MucCalibMgr.h>

Public Member Functions

 MucCalibMgr (std::vector< double > jobInfo, std::vector< int > configInfo, std::string outputFile)
 ~MucCalibMgr ()
StatusCode InitNtuple ()
StatusCode InitHisto ()
StatusCode InitArea ()
StatusCode DimuSelect ()
StatusCode ReadEvent ()
StatusCode CheckEvent ()
StatusCode FillEvent ()
StatusCode AnalyseEffAndNoise ()
StatusCode AnalyseCluster ()
StatusCode AnalyseRes ()
StatusCode SaveConst ()
StatusCode EndRun ()
 MucCalibMgr (std::vector< double > jobInfo, std::vector< int > configInfo, std::string outputFile)
 ~MucCalibMgr ()
StatusCode InitNtuple ()
StatusCode InitHisto ()
StatusCode InitArea ()
StatusCode DimuSelect ()
StatusCode ReadEvent ()
StatusCode CheckEvent ()
StatusCode FillEvent ()
StatusCode AnalyseEffAndNoise ()
StatusCode AnalyseCluster ()
StatusCode AnalyseRes ()
StatusCode SaveConst ()
StatusCode EndRun ()
 MucCalibMgr (std::vector< double > jobInfo, std::vector< int > configInfo, std::string outputFile)
 ~MucCalibMgr ()
StatusCode InitNtuple ()
StatusCode InitHisto ()
StatusCode InitArea ()
StatusCode DimuSelect ()
StatusCode ReadEvent ()
StatusCode CheckEvent ()
StatusCode FillEvent ()
StatusCode AnalyseEffAndNoise ()
StatusCode AnalyseCluster ()
StatusCode AnalyseRes ()
StatusCode SaveConst ()
StatusCode EndRun ()

Public Attributes

IMessageSvc * msgSvc
INTupleSvc * ntupleSvc
IDataProviderSvc * eventSvc

Protected Member Functions

StatusCode InitOnlineHisto ()
StatusCode InitHistoLV0 ()
StatusCode InitHistoLV1 ()
StatusCode InitHistoLV2 ()
StatusCode Init2DEffHisto ()
StatusCode InitClusterHisto ()
StatusCode InitResHisto ()
StatusCode InitConstTree ()
StatusCode FillDigi (int part, int segment, int layer, int strip)
StatusCode FillExpHit (int part, int segment, int layer, int strip)
StatusCode FillEffHit (int part, int segment, int layer, int strip)
StatusCode FillNosHit (int part, int segment, int layer, int strip)
StatusCode FillCluster (int part, int segment, int layer, int size)
StatusCode EffAndNoiseLV0 ()
StatusCode EffAndNoiseLV1 ()
StatusCode EffAndNoiseLV2 ()
StatusCode PadEff ()
StatusCode ClearOnlineHisto ()
StatusCode ClearHistoLV0 ()
StatusCode ClearHistoLV1 ()
StatusCode ClearHistoLV2 ()
StatusCode Clear2DEffHisto ()
StatusCode ClearClusterHisto ()
StatusCode ClearResHisto ()
StatusCode ClearConstTree ()
StatusCode InitOnlineHisto ()
StatusCode InitHistoLV0 ()
StatusCode InitHistoLV1 ()
StatusCode InitHistoLV2 ()
StatusCode Init2DEffHisto ()
StatusCode InitClusterHisto ()
StatusCode InitResHisto ()
StatusCode InitConstTree ()
StatusCode FillDigi (int part, int segment, int layer, int strip)
StatusCode FillExpHit (int part, int segment, int layer, int strip)
StatusCode FillEffHit (int part, int segment, int layer, int strip)
StatusCode FillNosHit (int part, int segment, int layer, int strip)
StatusCode FillCluster (int part, int segment, int layer, int size)
StatusCode EffAndNoiseLV0 ()
StatusCode EffAndNoiseLV1 ()
StatusCode EffAndNoiseLV2 ()
StatusCode PadEff ()
StatusCode ClearOnlineHisto ()
StatusCode ClearHistoLV0 ()
StatusCode ClearHistoLV1 ()
StatusCode ClearHistoLV2 ()
StatusCode Clear2DEffHisto ()
StatusCode ClearClusterHisto ()
StatusCode ClearResHisto ()
StatusCode ClearConstTree ()
StatusCode InitOnlineHisto ()
StatusCode InitHistoLV0 ()
StatusCode InitHistoLV1 ()
StatusCode InitHistoLV2 ()
StatusCode Init2DEffHisto ()
StatusCode InitClusterHisto ()
StatusCode InitResHisto ()
StatusCode InitConstTree ()
StatusCode FillDigi (int part, int segment, int layer, int strip)
StatusCode FillExpHit (int part, int segment, int layer, int strip)
StatusCode FillEffHit (int part, int segment, int layer, int strip)
StatusCode FillNosHit (int part, int segment, int layer, int strip)
StatusCode FillCluster (int part, int segment, int layer, int size)
StatusCode EffAndNoiseLV0 ()
StatusCode EffAndNoiseLV1 ()
StatusCode EffAndNoiseLV2 ()
StatusCode PadEff ()
StatusCode ClearOnlineHisto ()
StatusCode ClearHistoLV0 ()
StatusCode ClearHistoLV1 ()
StatusCode ClearHistoLV2 ()
StatusCode Clear2DEffHisto ()
StatusCode ClearClusterHisto ()
StatusCode ClearResHisto ()
StatusCode ClearConstTree ()

Detailed Description

Definition at line 42 of file InstallArea/x86_64-el9-gcc13-dbg/include/MucCalib/MucCalibMgr.h.

Constructor & Destructor Documentation

◆ MucCalibMgr() [1/3]

MucCalibMgr::MucCalibMgr ( std::vector< double > jobInfo,
std::vector< int > configInfo,
std::string outputFile )

Definition at line 59 of file MucCalibMgr.cxx.

60 {
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}
n
const Int_t n
Definition DataBase/tau_mode.c:57
STRIP_MAX
const int STRIP_MAX
Definition MucMappingAlg.h:25
MucCalibMgr::InitHisto
StatusCode InitHisto()
Definition MucCalibMgr.cxx:571
MucCalibMgr::InitConstTree
StatusCode InitConstTree()
Definition MucCalibMgr.cxx:913
MucCalibMgr::InitArea
StatusCode InitArea()
Definition MucCalibMgr.cxx:1007
MucCalibMgr::InitNtuple
StatusCode InitNtuple()
Definition MucCalibMgr.cxx:359

◆ ~MucCalibMgr() [1/3]

MucCalibMgr::~MucCalibMgr ( )

Definition at line 182 of file MucCalibMgr.cxx.

182 {
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}
MucCalibMgr::ClearHistoLV2
StatusCode ClearHistoLV2()
Definition MucCalibMgr.cxx:265
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::ClearHistoLV1
StatusCode ClearHistoLV1()
Definition MucCalibMgr.cxx:250
MucCalibMgr::ClearOnlineHisto
StatusCode ClearOnlineHisto()
Definition MucCalibMgr.cxx:213
MucCalibMgr::ClearConstTree
StatusCode ClearConstTree()
Definition MucCalibMgr.cxx:342
MucCalibMgr::Clear2DEffHisto
StatusCode Clear2DEffHisto()
Definition MucCalibMgr.cxx:290

◆ MucCalibMgr() [2/3]

MucCalibMgr::MucCalibMgr ( std::vector< double > jobInfo,
std::vector< int > configInfo,
std::string outputFile )

◆ ~MucCalibMgr() [2/3]

MucCalibMgr::~MucCalibMgr ( )

◆ MucCalibMgr() [3/3]

MucCalibMgr::MucCalibMgr ( std::vector< double > jobInfo,
std::vector< int > configInfo,
std::string outputFile )

◆ ~MucCalibMgr() [3/3]

MucCalibMgr::~MucCalibMgr ( )

Member Function Documentation

◆ AnalyseCluster() [1/3]

StatusCode MucCalibMgr::AnalyseCluster ( )

Definition at line 2618 of file MucCalibMgr.cxx.

2618 {
2619 MsgStream log( msgSvc, "MucCalibMgr" );
2620
2621 return StatusCode::SUCCESS;
2622}

◆ AnalyseCluster() [2/3]

StatusCode MucCalibMgr::AnalyseCluster ( )

◆ AnalyseCluster() [3/3]

StatusCode MucCalibMgr::AnalyseCluster ( )

◆ AnalyseEffAndNoise() [1/3]

StatusCode MucCalibMgr::AnalyseEffAndNoise ( )

Definition at line 2234 of file MucCalibMgr.cxx.

2234 {
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}
MucCalibMgr::PadEff
StatusCode PadEff()
Definition MucCalibMgr.cxx:2583
MucCalibMgr::EffAndNoiseLV2
StatusCode EffAndNoiseLV2()
Definition MucCalibMgr.cxx:2475
MucCalibMgr::EffAndNoiseLV1
StatusCode EffAndNoiseLV1()
Definition MucCalibMgr.cxx:2364
MucCalibMgr::EffAndNoiseLV0
StatusCode EffAndNoiseLV0()
Definition MucCalibMgr.cxx:2251

◆ AnalyseEffAndNoise() [2/3]

StatusCode MucCalibMgr::AnalyseEffAndNoise ( )

◆ AnalyseEffAndNoise() [3/3]

StatusCode MucCalibMgr::AnalyseEffAndNoise ( )

◆ AnalyseRes() [1/3]

StatusCode MucCalibMgr::AnalyseRes ( )

Definition at line 2624 of file MucCalibMgr.cxx.

2624 {
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}

◆ AnalyseRes() [2/3]

StatusCode MucCalibMgr::AnalyseRes ( )

◆ AnalyseRes() [3/3]

StatusCode MucCalibMgr::AnalyseRes ( )

◆ CheckEvent() [1/3]

StatusCode MucCalibMgr::CheckEvent ( )

Definition at line 1930 of file MucCalibMgr.cxx.

1930 {
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}
Segment
#define Segment
Definition InstallArea/x86_64-el9-gcc13-dbg/include/TrkReco/TTrackBase.h:31

◆ CheckEvent() [2/3]

StatusCode MucCalibMgr::CheckEvent ( )

◆ CheckEvent() [3/3]

StatusCode MucCalibMgr::CheckEvent ( )

◆ Clear2DEffHisto() [1/3]

StatusCode MucCalibMgr::Clear2DEffHisto ( )
protected

Definition at line 290 of file MucCalibMgr.cxx.

290 {
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}

Referenced by ~MucCalibMgr().

◆ Clear2DEffHisto() [2/3]

StatusCode MucCalibMgr::Clear2DEffHisto ( )
protected

◆ Clear2DEffHisto() [3/3]

StatusCode MucCalibMgr::Clear2DEffHisto ( )
protected

◆ ClearClusterHisto() [1/3]

StatusCode MucCalibMgr::ClearClusterHisto ( )
protected

Definition at line 305 of file MucCalibMgr.cxx.

305 {
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}

Referenced by ~MucCalibMgr().

◆ ClearClusterHisto() [2/3]

StatusCode MucCalibMgr::ClearClusterHisto ( )
protected

◆ ClearClusterHisto() [3/3]

StatusCode MucCalibMgr::ClearClusterHisto ( )
protected

◆ ClearConstTree() [1/3]

StatusCode MucCalibMgr::ClearConstTree ( )
protected

Definition at line 342 of file MucCalibMgr.cxx.

342 {
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}

Referenced by ~MucCalibMgr().

◆ ClearConstTree() [2/3]

StatusCode MucCalibMgr::ClearConstTree ( )
protected

◆ ClearConstTree() [3/3]

StatusCode MucCalibMgr::ClearConstTree ( )
protected

◆ ClearHistoLV0() [1/3]

StatusCode MucCalibMgr::ClearHistoLV0 ( )
protected

Definition at line 233 of file MucCalibMgr.cxx.

233 {
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}

Referenced by ~MucCalibMgr().

◆ ClearHistoLV0() [2/3]

StatusCode MucCalibMgr::ClearHistoLV0 ( )
protected

◆ ClearHistoLV0() [3/3]

StatusCode MucCalibMgr::ClearHistoLV0 ( )
protected

◆ ClearHistoLV1() [1/3]

StatusCode MucCalibMgr::ClearHistoLV1 ( )
protected

Definition at line 250 of file MucCalibMgr.cxx.

250 {
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}

Referenced by ~MucCalibMgr().

◆ ClearHistoLV1() [2/3]

StatusCode MucCalibMgr::ClearHistoLV1 ( )
protected

◆ ClearHistoLV1() [3/3]

StatusCode MucCalibMgr::ClearHistoLV1 ( )
protected

◆ ClearHistoLV2() [1/3]

StatusCode MucCalibMgr::ClearHistoLV2 ( )
protected

Definition at line 265 of file MucCalibMgr.cxx.

265 {
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}

Referenced by ~MucCalibMgr().

◆ ClearHistoLV2() [2/3]

StatusCode MucCalibMgr::ClearHistoLV2 ( )
protected

◆ ClearHistoLV2() [3/3]

StatusCode MucCalibMgr::ClearHistoLV2 ( )
protected

◆ ClearOnlineHisto() [1/3]

StatusCode MucCalibMgr::ClearOnlineHisto ( )
protected

Definition at line 213 of file MucCalibMgr.cxx.

213 {
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}

Referenced by ~MucCalibMgr().

◆ ClearOnlineHisto() [2/3]

StatusCode MucCalibMgr::ClearOnlineHisto ( )
protected

◆ ClearOnlineHisto() [3/3]

StatusCode MucCalibMgr::ClearOnlineHisto ( )
protected

◆ ClearResHisto() [1/3]

StatusCode MucCalibMgr::ClearResHisto ( )
protected

Definition at line 323 of file MucCalibMgr.cxx.

323 {
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}

Referenced by ~MucCalibMgr().

◆ ClearResHisto() [2/3]

StatusCode MucCalibMgr::ClearResHisto ( )
protected

◆ ClearResHisto() [3/3]

StatusCode MucCalibMgr::ClearResHisto ( )
protected

◆ DimuSelect() [1/3]

StatusCode MucCalibMgr::DimuSelect ( )

Definition at line 1048 of file MucCalibMgr.cxx.

1048 {
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}
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
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
TofHitStatus::setStatus
void setStatus(unsigned int status)
Definition TofHitStatus.cxx:115

Referenced by ReadEvent().

◆ DimuSelect() [2/3]

StatusCode MucCalibMgr::DimuSelect ( )

◆ DimuSelect() [3/3]

StatusCode MucCalibMgr::DimuSelect ( )

◆ EffAndNoiseLV0() [1/3]

StatusCode MucCalibMgr::EffAndNoiseLV0 ( )
protected

Definition at line 2251 of file MucCalibMgr.cxx.

2251 {
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}

Referenced by AnalyseEffAndNoise().

◆ EffAndNoiseLV0() [2/3]

StatusCode MucCalibMgr::EffAndNoiseLV0 ( )
protected

◆ EffAndNoiseLV0() [3/3]

StatusCode MucCalibMgr::EffAndNoiseLV0 ( )
protected

◆ EffAndNoiseLV1() [1/3]

StatusCode MucCalibMgr::EffAndNoiseLV1 ( )
protected

Definition at line 2364 of file MucCalibMgr.cxx.

2364 {
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}

Referenced by AnalyseEffAndNoise().

◆ EffAndNoiseLV1() [2/3]

StatusCode MucCalibMgr::EffAndNoiseLV1 ( )
protected

◆ EffAndNoiseLV1() [3/3]

StatusCode MucCalibMgr::EffAndNoiseLV1 ( )
protected

◆ EffAndNoiseLV2() [1/3]

StatusCode MucCalibMgr::EffAndNoiseLV2 ( )
protected

Definition at line 2475 of file MucCalibMgr.cxx.

2475 {
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}

Referenced by AnalyseEffAndNoise().

◆ EffAndNoiseLV2() [2/3]

StatusCode MucCalibMgr::EffAndNoiseLV2 ( )
protected

◆ EffAndNoiseLV2() [3/3]

StatusCode MucCalibMgr::EffAndNoiseLV2 ( )
protected

◆ EndRun() [1/3]

StatusCode MucCalibMgr::EndRun ( )

Definition at line 2886 of file MucCalibMgr.cxx.

2886 {
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}

◆ EndRun() [2/3]

StatusCode MucCalibMgr::EndRun ( )

◆ EndRun() [3/3]

StatusCode MucCalibMgr::EndRun ( )

◆ FillCluster() [1/3]

StatusCode MucCalibMgr::FillCluster ( int part,
int segment,
int layer,
int size )
protected

Definition at line 2220 of file MucCalibMgr.cxx.

2220 {
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}

Referenced by FillEvent().

◆ FillCluster() [2/3]

StatusCode MucCalibMgr::FillCluster ( int part,
int segment,
int layer,
int size )
protected

◆ FillCluster() [3/3]

StatusCode MucCalibMgr::FillCluster ( int part,
int segment,
int layer,
int size )
protected

◆ FillDigi() [1/3]

StatusCode MucCalibMgr::FillDigi ( int part,
int segment,
int layer,
int strip )
protected

Definition at line 2118 of file MucCalibMgr.cxx.

2118 {
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}

Referenced by FillEvent().

◆ FillDigi() [2/3]

StatusCode MucCalibMgr::FillDigi ( int part,
int segment,
int layer,
int strip )
protected

◆ FillDigi() [3/3]

StatusCode MucCalibMgr::FillDigi ( int part,
int segment,
int layer,
int strip )
protected

◆ FillEffHit() [1/3]

StatusCode MucCalibMgr::FillEffHit ( int part,
int segment,
int layer,
int strip )
protected

Definition at line 2196 of file MucCalibMgr.cxx.

2196 {
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}

Referenced by FillEvent().

◆ FillEffHit() [2/3]

StatusCode MucCalibMgr::FillEffHit ( int part,
int segment,
int layer,
int strip )
protected

◆ FillEffHit() [3/3]

StatusCode MucCalibMgr::FillEffHit ( int part,
int segment,
int layer,
int strip )
protected

◆ FillEvent() [1/3]

StatusCode MucCalibMgr::FillEvent ( )

Definition at line 1985 of file MucCalibMgr.cxx.

1985 {
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}
MucCalibMgr::FillEffHit
StatusCode FillEffHit(int part, int segment, int layer, int strip)
Definition MucCalibMgr.cxx:2196
MucCalibMgr::FillExpHit
StatusCode FillExpHit(int part, int segment, int layer, int strip)
Definition MucCalibMgr.cxx:2184
MucCalibMgr::FillCluster
StatusCode FillCluster(int part, int segment, int layer, int size)
Definition MucCalibMgr.cxx:2220
MucCalibMgr::FillNosHit
StatusCode FillNosHit(int part, int segment, int layer, int strip)
Definition MucCalibMgr.cxx:2208
MucCalibMgr::FillDigi
StatusCode FillDigi(int part, int segment, int layer, int strip)
Definition MucCalibMgr.cxx:2118

◆ FillEvent() [2/3]

StatusCode MucCalibMgr::FillEvent ( )

◆ FillEvent() [3/3]

StatusCode MucCalibMgr::FillEvent ( )

◆ FillExpHit() [1/3]

StatusCode MucCalibMgr::FillExpHit ( int part,
int segment,
int layer,
int strip )
protected

Definition at line 2184 of file MucCalibMgr.cxx.

2184 {
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}

Referenced by FillEvent().

◆ FillExpHit() [2/3]

StatusCode MucCalibMgr::FillExpHit ( int part,
int segment,
int layer,
int strip )
protected

◆ FillExpHit() [3/3]

StatusCode MucCalibMgr::FillExpHit ( int part,
int segment,
int layer,
int strip )
protected

◆ FillNosHit() [1/3]

StatusCode MucCalibMgr::FillNosHit ( int part,
int segment,
int layer,
int strip )
protected

Definition at line 2208 of file MucCalibMgr.cxx.

2208 {
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}

Referenced by FillEvent().

◆ FillNosHit() [2/3]

StatusCode MucCalibMgr::FillNosHit ( int part,
int segment,
int layer,
int strip )
protected

◆ FillNosHit() [3/3]

StatusCode MucCalibMgr::FillNosHit ( int part,
int segment,
int layer,
int strip )
protected

◆ Init2DEffHisto() [1/3]

StatusCode MucCalibMgr::Init2DEffHisto ( )
protected

Definition at line 805 of file MucCalibMgr.cxx.

805 {
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}
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)

Referenced by InitHisto().

◆ Init2DEffHisto() [2/3]

StatusCode MucCalibMgr::Init2DEffHisto ( )
protected

◆ Init2DEffHisto() [3/3]

StatusCode MucCalibMgr::Init2DEffHisto ( )
protected

◆ InitArea() [1/3]

StatusCode MucCalibMgr::InitArea ( )

Definition at line 1007 of file MucCalibMgr.cxx.

1007 {
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}
MucEntityCal::GetArea
double GetArea()
Definition MucEntityCal.cxx:88

Referenced by MucCalibMgr().

◆ InitArea() [2/3]

StatusCode MucCalibMgr::InitArea ( )

◆ InitArea() [3/3]

StatusCode MucCalibMgr::InitArea ( )

◆ InitClusterHisto() [1/3]

StatusCode MucCalibMgr::InitClusterHisto ( )
protected

Definition at line 852 of file MucCalibMgr.cxx.

852 {
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}
title
titledef title[20]
Definition EvtPhokharaDef.hh:58

Referenced by InitHisto().

◆ InitClusterHisto() [2/3]

StatusCode MucCalibMgr::InitClusterHisto ( )
protected

◆ InitClusterHisto() [3/3]

StatusCode MucCalibMgr::InitClusterHisto ( )
protected

◆ InitConstTree() [1/3]

StatusCode MucCalibMgr::InitConstTree ( )
protected

Definition at line 913 of file MucCalibMgr.cxx.

913 {
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}

Referenced by MucCalibMgr().

◆ InitConstTree() [2/3]

StatusCode MucCalibMgr::InitConstTree ( )
protected

◆ InitConstTree() [3/3]

StatusCode MucCalibMgr::InitConstTree ( )
protected

◆ InitHisto() [1/3]

StatusCode MucCalibMgr::InitHisto ( )

Definition at line 571 of file MucCalibMgr.cxx.

571 {
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}
MucCalibMgr::InitResHisto
StatusCode InitResHisto()
Definition MucCalibMgr.cxx:882
MucCalibMgr::InitOnlineHisto
StatusCode InitOnlineHisto()
Definition MucCalibMgr.cxx:596
MucCalibMgr::Init2DEffHisto
StatusCode Init2DEffHisto()
Definition MucCalibMgr.cxx:805
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::InitHistoLV0
StatusCode InitHistoLV0()
Definition MucCalibMgr.cxx:707

Referenced by MucCalibMgr().

◆ InitHisto() [2/3]

StatusCode MucCalibMgr::InitHisto ( )

◆ InitHisto() [3/3]

StatusCode MucCalibMgr::InitHisto ( )

◆ InitHistoLV0() [1/3]

StatusCode MucCalibMgr::InitHistoLV0 ( )
protected

Definition at line 707 of file MucCalibMgr.cxx.

707 {
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}

Referenced by InitHisto().

◆ InitHistoLV0() [2/3]

StatusCode MucCalibMgr::InitHistoLV0 ( )
protected

◆ InitHistoLV0() [3/3]

StatusCode MucCalibMgr::InitHistoLV0 ( )
protected

◆ InitHistoLV1() [1/3]

StatusCode MucCalibMgr::InitHistoLV1 ( )
protected

Definition at line 733 of file MucCalibMgr.cxx.

733 {
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}

Referenced by InitHisto().

◆ InitHistoLV1() [2/3]

StatusCode MucCalibMgr::InitHistoLV1 ( )
protected

◆ InitHistoLV1() [3/3]

StatusCode MucCalibMgr::InitHistoLV1 ( )
protected

◆ InitHistoLV2() [1/3]

StatusCode MucCalibMgr::InitHistoLV2 ( )
protected

Definition at line 749 of file MucCalibMgr.cxx.

749 {
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}

Referenced by InitHisto().

◆ InitHistoLV2() [2/3]

StatusCode MucCalibMgr::InitHistoLV2 ( )
protected

◆ InitHistoLV2() [3/3]

StatusCode MucCalibMgr::InitHistoLV2 ( )
protected

◆ InitNtuple() [1/3]

StatusCode MucCalibMgr::InitNtuple ( )

Definition at line 359 of file MucCalibMgr.cxx.

359 {
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}

Referenced by MucCalibMgr().

◆ InitNtuple() [2/3]

StatusCode MucCalibMgr::InitNtuple ( )

◆ InitNtuple() [3/3]

StatusCode MucCalibMgr::InitNtuple ( )

◆ InitOnlineHisto() [1/3]

StatusCode MucCalibMgr::InitOnlineHisto ( )
protected

Definition at line 596 of file MucCalibMgr.cxx.

596 {
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}

Referenced by InitHisto().

◆ InitOnlineHisto() [2/3]

StatusCode MucCalibMgr::InitOnlineHisto ( )
protected

◆ InitOnlineHisto() [3/3]

StatusCode MucCalibMgr::InitOnlineHisto ( )
protected

◆ InitResHisto() [1/3]

StatusCode MucCalibMgr::InitResHisto ( )
protected

Definition at line 882 of file MucCalibMgr.cxx.

882 {
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}

Referenced by InitHisto().

◆ InitResHisto() [2/3]

StatusCode MucCalibMgr::InitResHisto ( )
protected

◆ InitResHisto() [3/3]

StatusCode MucCalibMgr::InitResHisto ( )
protected

◆ PadEff() [1/3]

StatusCode MucCalibMgr::PadEff ( )
protected

Definition at line 2583 of file MucCalibMgr.cxx.

2583 {
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}

Referenced by AnalyseEffAndNoise().

◆ PadEff() [2/3]

StatusCode MucCalibMgr::PadEff ( )
protected

◆ PadEff() [3/3]

StatusCode MucCalibMgr::PadEff ( )
protected

◆ ReadEvent() [1/3]

StatusCode MucCalibMgr::ReadEvent ( )

Definition at line 1193 of file MucCalibMgr.cxx.

1193 {
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}
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
MucCalibMgr::DimuSelect
StatusCode DimuSelect()
Definition MucCalibMgr.cxx:1048
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

◆ ReadEvent() [2/3]

StatusCode MucCalibMgr::ReadEvent ( )

◆ ReadEvent() [3/3]

StatusCode MucCalibMgr::ReadEvent ( )

◆ SaveConst() [1/3]

StatusCode MucCalibMgr::SaveConst ( )

Definition at line 2662 of file MucCalibMgr.cxx.

2662 {
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}

◆ SaveConst() [2/3]

StatusCode MucCalibMgr::SaveConst ( )

◆ SaveConst() [3/3]

StatusCode MucCalibMgr::SaveConst ( )

Member Data Documentation

◆ eventSvc

IDataProviderSvc * MucCalibMgr::eventSvc

Definition at line 101 of file InstallArea/x86_64-el9-gcc13-dbg/include/MucCalib/MucCalibMgr.h.

Referenced by ClearConstTree(), DimuSelect(), MucCalibMgr(), and ReadEvent().

◆ msgSvc

IMessageSvc * MucCalibMgr::msgSvc

Definition at line 99 of file InstallArea/x86_64-el9-gcc13-dbg/include/MucCalib/MucCalibMgr.h.

Referenced by AnalyseCluster(), AnalyseEffAndNoise(), AnalyseRes(), CheckEvent(), ClearConstTree(), DimuSelect(), EffAndNoiseLV0(), EffAndNoiseLV1(), EffAndNoiseLV2(), EndRun(), FillEvent(), InitConstTree(), InitHisto(), InitNtuple(), MucCalibMgr(), PadEff(), ReadEvent(), and SaveConst().

◆ ntupleSvc

INTupleSvc * MucCalibMgr::ntupleSvc

Definition at line 100 of file InstallArea/x86_64-el9-gcc13-dbg/include/MucCalib/MucCalibMgr.h.

Referenced by ClearConstTree(), InitNtuple(), and MucCalibMgr().

The documentation for this class was generated from the following files: