BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
PreT0MdcCalib.cxx
Go to the documentation of this file.
1#include "MdcCalibAlg/PreT0MdcCalib.h"
2
3#include "GaudiKernel/Bootstrap.h"
4#include "GaudiKernel/IMessageSvc.h"
5#include "GaudiKernel/ISvcLocator.h"
6#include "GaudiKernel/MsgStream.h"
7#include "GaudiKernel/StatusCode.h"
8
9#include "GaudiKernel/IDataProviderSvc.h"
10#include "GaudiKernel/PropertyMgr.h"
11#include "GaudiKernel/SmartDataPtr.h"
12
13#include "EvTimeEvent/RecEsTime.h"
14#include "EventModel/Event.h"
15#include "Identifier/Identifier.h"
16#include "Identifier/MdcID.h"
17#include "MdcRawEvent/MdcDigi.h"
18#include "TStyle.h"
19
20#include <cstring>
21#include <fstream>
22#include <iomanip>
23#include <iostream>
24
25#include "TF1.h"
26#include "TFolder.h"
27#include "TH1F.h"
28#include "TH2F.h"
29#include <math.h>
30
31PreT0MdcCalib::PreT0MdcCalib() { m_nzbin = 11; }
32
33PreT0MdcCalib::~PreT0MdcCalib() {}
34
35void PreT0MdcCalib::clear() {
36 int lay;
37 int lr;
38 int bin;
39 for ( lay = 0; lay < MdcCalNLayer; lay++ )
40 {
41 for ( lr = 0; lr < MdcCalLR; lr++ )
42 {
43 delete m_hTrec[lay][lr];
44 for ( bin = 0; bin < m_nzbin; bin++ ) { delete m_hTrecZ[lay][lr][bin]; }
45 }
46 }
47 for ( lay = 0; lay < MdcCalNLayer; lay++ )
48 {
49 for ( bin = 0; bin < 2; bin++ ) delete m_hTrecCosm[lay][bin];
50 }
51 delete m_fdTrec;
52 delete m_fdTrecZ;
53
54 MdcCalib::clear();
55}
56
57void PreT0MdcCalib::initialize( TObjArray* hlist, IMdcGeomSvc* mdcGeomSvc,
58 IMdcCalibFunSvc* mdcFunSvc, IMdcUtilitySvc* mdcUtilitySvc ) {
59 IMessageSvc* msgSvc;
60 Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
61 MsgStream log( msgSvc, "PreT0MdcCalib" );
62 log << MSG::INFO << "PreT0MdcCalib::initialize()" << endmsg;
63
64 m_hlist = hlist;
65 m_mdcGeomSvc = mdcGeomSvc;
66 m_mdcFunSvc = mdcFunSvc;
67 m_mdcUtilitySvc = mdcUtilitySvc;
68
69 // MdcCalib::initialize(m_hlist, m_mdcGeomSvc, m_mdcFunSvc, m_mdcUtilitySvc);
70
71 int lay;
72 int lr;
73 int bin;
74 char hname[200];
75
76 m_fdTrec = new TFolder( "Trec", "Trec" );
77 m_hlist->Add( m_fdTrec );
78
79 m_fdTrecZ = new TFolder( "TrecZ", "TrecZ" );
80 m_hlist->Add( m_fdTrecZ );
81
82 for ( lay = 0; lay < MdcCalNLayer; lay++ )
83 {
84 for ( lr = 0; lr < MdcCalLR; lr++ )
85 {
86 if ( 0 == lr ) sprintf( hname, "Trec%02d_L", lay );
87 else if ( 1 == lr ) sprintf( hname, "Trec%02d_R", lay );
88 else sprintf( hname, "Trec%02d_C", lay );
89
90 if ( lay < 8 ) m_hTrec[lay][lr] = new TH1F( hname, "", 100, 0, 400 );
91 else m_hTrec[lay][lr] = new TH1F( hname, "", 125, 0, 500 );
92 m_fdTrec->Add( m_hTrec[lay][lr] );
93 }
94 }
95
96 for ( lay = 0; lay < MdcCalNLayer; lay++ )
97 {
98 for ( int iud = 0; iud < 2; iud++ )
99 {
100 if ( 0 == iud ) sprintf( hname, "TrecCosm%02d_Up", lay );
101 else sprintf( hname, "TrecCosm%02d_Dw", lay );
102 if ( lay < 8 ) m_hTrecCosm[lay][iud] = new TH1F( hname, "", 100, 0, 400 );
103 else m_hTrecCosm[lay][iud] = new TH1F( hname, "", 125, 0, 500 );
104 m_fdTrec->Add( m_hTrecCosm[lay][iud] );
105 }
106 }
107
108 for ( lay = 0; lay < MdcCalNLayer; lay++ )
109 {
110 for ( lr = 0; lr < MdcCalLR; lr++ )
111 {
112 for ( bin = 0; bin < m_nzbin; bin++ )
113 {
114 if ( 0 == lr ) sprintf( hname, "Trec%02d_z%02d_L", lay, bin );
115 else if ( 1 == lr ) sprintf( hname, "Trec%02d_z%02d_R", lay, bin );
116 else sprintf( hname, "Trec%02d_z%02d_C", lay, bin );
117
118 if ( lay < 8 ) m_hTrecZ[lay][lr][bin] = new TH1F( hname, "", 100, 0, 400 );
119 else m_hTrecZ[lay][lr][bin] = new TH1F( hname, "", 125, 0, 500 );
120 m_fdTrecZ->Add( m_hTrecZ[lay][lr][bin] );
121 }
122 }
123 }
124
125 double zeast;
126 double zwest;
127 for ( lay = 0; lay < MdcCalNLayer; lay++ )
128 {
129 zwest = m_mdcGeomSvc->Wire( lay, 0 )->Forward().z();
130 zeast = m_mdcGeomSvc->Wire( lay, 0 )->Backward().z();
131 m_zwid[lay] = ( zeast - zwest ) / (double)m_nzbin;
132
133 if ( lay < 8 ) m_vp[lay] = 220.0; // *10^9 mm/s
134 else m_vp[lay] = 240.0; // *10^9 mm/s
135
136 if ( 0 == ( lay % 2 ) )
137 { // west end
138 m_zst[lay] = zwest;
139 }
140 else
141 { // east end
142 m_zst[lay] = zeast;
143 }
144 }
145}
146
147int PreT0MdcCalib::fillHist( MdcCalEvent* event ) {
148 IMessageSvc* msgSvc;
149 Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
150 MsgStream log( msgSvc, "PreT0MdcCalib" );
151 log << MSG::DEBUG << "PreT0MdcCalib::fillHist()" << endmsg;
152
153 // MdcCalib::fillHist(event);
154
155 int i;
156 int k;
157 int lay;
158 int cel;
159 int lr;
160 int bin;
161
162 double tdc;
163 double traw;
164 double trec;
165 double tdr;
166 double t0;
167 double tp = 0.0;
168 double tof = 0.0;
169 double zhit;
170 double zprop;
171
172 MdcCalRecTrk* rectrk;
173 MdcCalRecHit* rechit;
174
175 IDataProviderSvc* eventSvc = NULL;
176 Gaudi::svcLocator()->service( "EventDataSvc", eventSvc );
177
178 // get EsTimeCol
179 double tes = event->getTes();
180 // cout << "tes " << tes << endl;
181 bool esCutFg = event->getEsCutFlag();
182 if ( !esCutFg ) return -1;
183
184 int nhit;
185 int ntrk = event->getNTrk();
186 for ( i = 0; i < ntrk; i++ )
187 {
188 rectrk = event->getRecTrk( i );
189
190 // dr cut
191 double dr = rectrk->getDr();
192 if ( fabs( dr ) > m_param.drCut ) continue;
193
194 // dz cut
195 double dz = rectrk->getDz();
196 if ( fabs( dz ) > m_param.dzCut ) continue;
197
198 // momentum cut
199 double p = rectrk->getP();
200 if ( ( fabs( p ) < m_param.pCut[0] ) || ( fabs( p ) > m_param.pCut[1] ) ) continue;
201
202 // select cosmic track with y<0
203 double phi0 = rectrk->getPhi0();
204 double phiTrk = phi0 + CLHEP::halfpi;
205 if ( phiTrk > CLHEP::twopi ) phiTrk -= CLHEP::twopi;
206 if ( m_param.cosmicDwTrk && ( phiTrk < CLHEP::pi ) ) continue;
207 // cout << "cosmicDwTrk " << m_param.cosmicDwTrk << setw(15) << phiTrk*180./3.14 <<
208 // endl;
209
210 nhit = rectrk->getNHits();
211 for ( k = 0; k < nhit; k++ )
212 {
213 rechit = rectrk->getRecHit( k );
214 lay = rechit->getLayid();
215 cel = rechit->getCellid();
216 lr = rechit->getLR();
217 zhit = rechit->getZhit();
218 tdc = rechit->getTdc();
219 tdr = rechit->getTdrift();
220
221 traw = tdc * MdcCalTdcCnv;
222 // traw = tdc; // ns
223
224 zprop = fabs( zhit - m_zst[lay] );
225 bin = (int)( zprop / m_zwid[lay] );
226 tp = zprop / m_vp[lay];
227 t0 = m_mdcFunSvc->getT0( lay, cel );
228 tof = rechit->getTof();
229
230 double adc = rechit->getQhit();
231 double tw = m_mdcFunSvc->getTimeWalk( lay, adc );
232 // cout << setw(15) << adc << setw(15) << tw << endl;
233
234 const MdcGeoWire* pWire = m_mdcGeomSvc->Wire( lay, cel );
235 double y1 = pWire->Backward().y();
236 double y2 = pWire->Forward().y();
237 double ymid = ( y1 + y2 ) * 0.5;
238 // if(5==m_param.particle){ // cosmic-ray
239 // if(ymid > 0) trec = traw - tp + tof - tes + m_param.timeShift - tw;
240 // else trec = traw - tp - tof - tes + m_param.timeShift - tw;
241 // } else{
242 // trec = traw - tp - tof - tes + m_param.timeShift - tw;
243 // }
244 trec = traw - tp - tof - tes + m_param.timeShift - tw;
245
246 m_hTrec[lay][lr]->Fill( trec );
247 m_hTrec[lay][2]->Fill( trec ); // l-r in common
248 if ( ymid > 0 ) m_hTrecCosm[lay][0]->Fill( trec );
249 else m_hTrecCosm[lay][1]->Fill( trec );
250
251 if ( bin < m_nzbin )
252 {
253 m_hTrecZ[lay][lr][bin]->Fill( trec );
254 m_hTrecZ[lay][2][bin]->Fill( trec );
255 }
256 }
257 }
258 return 1;
259}
260
261void PreT0MdcCalib::printCut() const {}
262
263int PreT0MdcCalib::updateConst( MdcCalibConst* calconst ) {
264 IMessageSvc* msgSvc;
265 Gaudi::svcLocator()->service( "MessageSvc", msgSvc );
266 MsgStream log( msgSvc, "PreT0MdcCalib" );
267 log << MSG::DEBUG << "PreT0MdcCalib::updateConst()" << endmsg;
268
269 // MdcCalib::updateConst(calconst);
270
271 // fit Tmin
272 int lay;
273 int wir;
274 int lr;
275 double t0Fit[MdcCalNLayer][MdcCalLR];
276 double t0Cal[MdcCalNLayer][MdcCalLR];
277 double tmax[MdcCalNLayer][MdcCalLR];
278 double initT0 = m_param.initT0;
279
280 int fitTminFg[MdcCalNLayer][MdcCalLR];
281 int fitTmaxFg[MdcCalNLayer][MdcCalLR];
282 double chisq;
283 double ndf;
284 double chindfTmin[MdcCalNLayer][MdcCalLR];
285 double chindfTmax[MdcCalNLayer][MdcCalLR];
286 char funname[200];
287
288 // add for cosmic-ray
289 TF1* ftminCosm[MdcCalNLayer][2];
290 double t0FitCosm[MdcCalNLayer][2];
291
292 TF1* ftmin[MdcCalNLayer][MdcCalLR];
293 // sprintf(funname, "ftmin");
294 // TF1* ftmin = new TF1(funname, funTmin, 0, 150, 6);
295 for ( lay = 0; lay < MdcCalNLayer; lay++ )
296 {
297 for ( lr = 0; lr < MdcCalLR; lr++ )
298 {
299 fitTminFg[lay][lr] = 0;
300 chindfTmin[lay][lr] = -1;
301 sprintf( funname, "ftmin%02d_%d", lay, lr );
302 ftmin[lay][lr] = new TF1( funname, funTmin, 0, 150, 6 );
303
304 if ( 1 == m_param.fgCalib[lay] )
305 {
306 Stat_t nEntryTot = 0;
307 for ( int ibin = 1; ibin <= 25; ibin++ )
308 {
309 Stat_t entry = m_hTrec[lay][lr]->GetBinContent( ibin );
310 nEntryTot += entry;
311 }
312 double c0Ini = (double)nEntryTot / 25.0;
313 double c1Ini = ( m_hTrec[lay][lr]->GetMaximum() ) - c0Ini;
314
315 ftmin[lay][lr]->SetParameter( 0, c0Ini );
316 ftmin[lay][lr]->SetParameter( 1, c1Ini );
317 ftmin[lay][lr]->SetParameter( 2, 0 );
318 ftmin[lay][lr]->SetParameter( 4, initT0 );
319 ftmin[lay][lr]->SetParameter( 5, 2 );
320
321 m_hTrec[lay][lr]->Fit( funname, "Q", "", m_param.tminFitRange[lay][0],
322 m_param.tminFitRange[lay][1] );
323 gStyle->SetOptFit( 11 );
324 // chisq = ftmin[lay][lr]->GetChisquare();
325 // ndf = ftmin[lay][lr]->GetNDF();
326 chisq = ftmin[lay][lr]->GetChisquare();
327 ndf = ftmin[lay][lr]->GetNDF();
328 chindfTmin[lay][lr] = chisq / ndf;
329
330 if ( chindfTmin[lay][lr] < m_param.tminFitChindf )
331 {
332 fitTminFg[lay][lr] = 1;
333 t0Fit[lay][lr] = ftmin[lay][lr]->GetParameter( 4 );
334 // t0Fit[lay][lr] = ftmin->GetParameter(4);
335 t0Fit[lay][lr] += m_param.t0Shift;
336 t0Cal[lay][lr] = t0Fit[lay][lr] - m_param.timeShift;
337 }
338 }
339
340 if ( 0 == fitTminFg[lay][lr] )
341 {
342 wir = m_mdcGeomSvc->Wire( lay, 0 )->Id();
343 t0Cal[lay][lr] = calconst->getT0( wir );
344 t0Fit[lay][lr] = t0Cal[lay][lr] + m_param.timeShift;
345 }
346 }
347
348 for ( int iud = 0; iud < 2; iud++ )
349 {
350 sprintf( funname, "ftminCosm_%02d_%d", lay, iud );
351 ftminCosm[lay][iud] = new TF1( funname, funTmin, 0, 150, 6 );
352 ftminCosm[lay][iud]->SetParameter( 0, 0 );
353 ftminCosm[lay][iud]->SetParameter( 4, initT0 );
354 ftminCosm[lay][iud]->SetParameter( 5, 1 );
355 m_hTrecCosm[lay][iud]->Fit( funname, "Q", "", m_param.tminFitRange[lay][0],
356 m_param.tminFitRange[lay][1] );
357 gStyle->SetOptFit( 11 );
358 t0FitCosm[lay][iud] += m_param.t0Shift;
359 t0FitCosm[lay][iud] = ftminCosm[lay][iud]->GetParameter( 4 );
360 }
361 }
362
363 // fit Tmax
364 TF1* ftmax[MdcCalNLayer][MdcCalLR];
365 for ( lay = 0; lay < MdcCalNLayer; lay++ )
366 {
367 for ( lr = 0; lr < MdcCalLR; lr++ )
368 {
369 fitTmaxFg[lay][lr] = 0;
370 chindfTmax[lay][lr] = -1;
371 sprintf( funname, "ftmax%02d_%d", lay, lr );
372 ftmax[lay][lr] = new TF1( funname, funTmax, 250, 500, 4 );
373
374 if ( 1 == m_param.fgCalib[lay] )
375 {
376 ftmax[lay][lr]->SetParameter( 2, m_param.initTm[lay] );
377 ftmax[lay][lr]->SetParameter( 3, 10 );
378 m_hTrec[lay][lr]->Fit( funname, "Q+", "", m_param.tmaxFitRange[lay][0],
379 m_param.tmaxFitRange[lay][1] );
380 gStyle->SetOptFit( 11 );
381 chisq = ftmax[lay][lr]->GetChisquare();
382 ndf = ftmax[lay][lr]->GetNDF();
383 chindfTmax[lay][lr] = chisq / ndf;
384 if ( chindfTmax[lay][lr] < m_param.tmaxFitChindf )
385 {
386 fitTmaxFg[lay][lr] = 1;
387 tmax[lay][lr] = ftmax[lay][lr]->GetParameter( 2 );
388 }
389 }
390
391 if ( 0 == fitTmaxFg[lay][lr] )
392 { tmax[lay][lr] = ( calconst->getXtpar( lay, 0, lr, 6 ) ) + t0Fit[lay][2]; }
393 }
394 }
395
396 // output for check
397 ofstream ft0( "preT0.dat" );
398 for ( lay = 0; lay < MdcCalNLayer; lay++ )
399 {
400 ft0 << setw( 5 ) << lay << setw( 3 ) << fitTminFg[lay][2] << setw( 15 ) << t0Cal[lay][2]
401 << setw( 15 ) << t0Fit[lay][2] << setw( 15 ) << chindfTmin[lay][2] << endl;
402 }
403 ft0 << endl;
404 for ( lay = 0; lay < MdcCalNLayer; lay++ )
405 {
406 ft0 << setw( 5 ) << lay << setw( 3 ) << fitTmaxFg[lay][0] << setw( 10 ) << tmax[lay][0]
407 << setw( 10 ) << chindfTmax[lay][0] << setw( 3 ) << fitTmaxFg[lay][1] << setw( 10 )
408 << tmax[lay][1] << setw( 10 ) << chindfTmax[lay][1] << setw( 3 ) << fitTmaxFg[lay][2]
409 << setw( 10 ) << tmax[lay][2] << setw( 10 ) << chindfTmax[lay][2] << setw( 10 )
410 << tmax[lay][0] - t0Fit[lay][2] << setw( 10 ) << tmax[lay][1] - t0Fit[lay][2]
411 << setw( 10 ) << tmax[lay][2] - t0Fit[lay][2] << endl;
412 }
413 ft0.close();
414 cout << "preT0.dat was written." << endl;
415
416 // output for cosmic T0
417 ofstream ft0cosm( "cosmicT0.dat" );
418 for ( lay = 0; lay < MdcCalNLayer; lay++ )
419 {
420 ft0cosm << setw( 5 ) << lay << setw( 15 ) << t0Fit[lay][2] << setw( 15 )
421 << t0FitCosm[lay][0] << setw( 15 ) << t0FitCosm[lay][1] << endl;
422 }
423 ft0cosm.close();
424
425 // set T0
426 int i;
427 int nwire = m_mdcGeomSvc->getWireSize();
428 for ( i = 0; i < nwire; i++ )
429 {
430 lay = m_mdcGeomSvc->Wire( i )->Layer();
431 if ( 1 == m_param.fgCalib[lay] )
432 {
433 calconst->resetT0( i, t0Cal[lay][2] );
434 calconst->resetDelT0( i, 0.0 );
435 }
436 }
437
438 // set tm of X-T
439 if ( m_param.preT0SetTm )
440 {
441 int iEntr;
442 double tm;
443 for ( lay = 0; lay < MdcCalNLayer; lay++ )
444 {
445 if ( 1 != m_param.fgCalib[lay] ) continue;
446
447 for ( iEntr = 0; iEntr < MdcCalNENTRXT; iEntr++ )
448 {
449 for ( lr = 0; lr < MdcCalLR; lr++ )
450 {
451 tm = tmax[lay][lr] - t0Fit[lay][2];
452 if ( ( tmax[lay][lr] > m_param.tmaxFitRange[lay][0] ) &&
453 ( tmax[lay][lr] < m_param.tmaxFitRange[lay][1] ) )
454 { calconst->resetXtpar( lay, iEntr, lr, 6, tm ); }
455 }
456 }
457 }
458 }
459
460 // set sigma
461 int bin;
462 double sdpar = m_param.initSigma; // mm
463 for ( lay = 0; lay < MdcCalNLayer; lay++ )
464 {
465 for ( int iEntr = 0; iEntr < MdcCalNENTRSD; iEntr++ )
466 {
467 for ( lr = 0; lr < 2; lr++ )
468 {
469 for ( bin = 0; bin < MdcCalSdNBIN; bin++ )
470 { calconst->resetSdpar( lay, iEntr, lr, bin, sdpar ); }
471 }
472 }
473 }
474
475 // delete ftmin;
476 for ( lay = 0; lay < MdcCalNLayer; lay++ )
477 {
478 for ( lr = 0; lr < MdcCalLR; lr++ )
479 {
480 delete ftmin[lay][lr];
481 delete ftmax[lay][lr];
482 }
483 }
484 return 1;
485}
486Double_t PreT0MdcCalib::funTmin( Double_t* x, Double_t* par ) {
487 Double_t fitval;
488 fitval = par[0] + par[1] * exp( -par[2] * ( x[0] - par[3] ) ) /
489 ( 1 + exp( -( x[0] - par[4] ) / par[5] ) );
490 return fitval;
491}
492
493Double_t PreT0MdcCalib::funTmax( Double_t* x, Double_t* par ) {
494 Double_t fitval;
495 fitval = par[0] + par[1] / ( 1 + exp( ( x[0] - par[2] ) / par[3] ) );
496 return fitval;
497}
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)
x
Double_t x[10]
Definition DataBase/tau_mode.c:49
exp
EvtComplex exp(const EvtComplex &c)
Definition EvtComplex.hh:209
bin
*******INTEGER m_nBinMax INTEGER m_NdiMax !No of bins in histogram for cell exploration division $ !Last vertex $ !Last active cell $ !Last cell in buffer $ !No of sampling when dividing cell $ !No of function total $ !Flag for random ceel for $ !Flag for type of for WtMax $ !Flag which decides whether vertices are included in the sampling $ entire domain is hyp !Maximum effective eevents per bin
Definition FoamA.h:85
MdcCalNLayer
const int MdcCalNLayer
Definition MdcCalParams.h:6
MdcCalNENTRSD
const int MdcCalNENTRSD
Definition MdcCalParams.h:19
MdcCalTdcCnv
const double MdcCalTdcCnv
Definition MdcCalParams.h:24
MdcCalSdNBIN
const int MdcCalSdNBIN
Definition MdcCalParams.h:20
MdcCalNENTRXT
const int MdcCalNENTRXT
Definition MdcCalParams.h:12
MdcCalLR
const int MdcCalLR
Definition MdcCalParams.h:10
msgSvc
IMessageSvc * msgSvc()
Definition ServiceAccessor.h:12
MdcCalRecHit::getCellid
int getCellid() const
Definition MdcCalRecHit.h:23
MdcCalRecHit::getTdrift
double getTdrift() const
Definition MdcCalRecHit.h:40
MdcCalRecHit::getQhit
double getQhit() const
Definition MdcCalRecHit.h:41
MdcCalRecHit::getLayid
int getLayid() const
Definition MdcCalRecHit.h:22
MdcCalRecHit::getTof
double getTof() const
Definition MdcCalRecHit.h:46
MdcCalRecHit::getZhit
double getZhit() const
Definition MdcCalRecHit.h:42
MdcCalRecHit::getLR
int getLR() const
Definition MdcCalRecHit.h:24
MdcCalRecHit::getTdc
double getTdc() const
Definition MdcCalRecHit.h:39
MdcCalRecTrk::getRecHit
MdcCalRecHit * getRecHit(int index) const
Definition MdcCalRecTrk.h:40
MdcCalRecTrk::getP
double getP() const
Definition MdcCalRecTrk.h:36
MdcCalRecTrk::getDz
double getDz() const
Definition MdcCalRecTrk.h:33
MdcCalRecTrk::getNHits
int getNHits() const
Definition MdcCalRecTrk.h:38
MdcCalRecTrk::getPhi0
double getPhi0() const
Definition MdcCalRecTrk.h:31
MdcCalRecTrk::getDr
double getDr() const
Definition MdcCalRecTrk.h:30
MdcCalibConst::resetSdpar
void resetSdpar(int lay, int entr, int lr, int bin, double val)
Definition MdcCalibConst.cpp:84
MdcCalibConst::resetXtpar
void resetXtpar(int lay, int entr, int lr, int order, double val)
Definition MdcCalibConst.cpp:24
MdcCalibConst::getT0
double getT0(int wireid) const
Definition include/MdcCalibAlg/MdcCalibConst.h:27
MdcCalibConst::resetDelT0
void resetDelT0(int wireid, double val)
Definition include/MdcCalibAlg/MdcCalibConst.h:26
MdcCalibConst::getXtpar
double getXtpar(int lay, int entr, int lr, int order)
Definition MdcCalibConst.cpp:29
MdcCalibConst::resetT0
void resetT0(int wireid, double val)
Definition include/MdcCalibAlg/MdcCalibConst.h:25
MdcCalib::clear
virtual void clear()=0
Definition MdcCalib.cxx:83
PreT0MdcCalib::updateConst
int updateConst(MdcCalibConst *calconst)
Definition PreT0MdcCalib.cxx:263
PreT0MdcCalib::fillHist
int fillHist(MdcCalEvent *event)
Definition PreT0MdcCalib.cxx:147
PreT0MdcCalib::initialize
void initialize(TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc, IMdcUtilitySvc *mdcUtilitySvc)
Definition PreT0MdcCalib.cxx:57
PreT0MdcCalib::printCut
void printCut() const
Definition PreT0MdcCalib.cxx:261