HYDRA_development_version
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
hmdcparrootfileio.cc
Go to the documentation of this file.
1 //*-- AUTHOR : Ilse Koenig
2 //*-- Modified : 19/01/2001 by I. Koenig
3 
4 //_HADES_CLASS_DESCRIPTION
5 /////////////////////////////////////////////////////////////
6 // HMdcParRootFileIo
7 //
8 // Class for Mdc parameter input/output from/into ROOT file
9 //
10 // It is derived from the base class HDetParRootFileIo and
11 // inherits from it basic functions e.g. write(...)
12 //
13 // This class replaces the former class HMdcParFileIo.
14 /////////////////////////////////////////////////////////////
15 using namespace std;
16 #include "hmdcparrootfileio.h"
17 #include "hparrootfileio.h"
18 #include "hades.h"
19 #include "hmdcrawstruct.h"
20 #include "hmdcgeomstruct.h"
21 #include "hmdccalparraw.h"
22 #include "hmdctdcthreshold.h"
23 #include "hmdctdcchannel.h"
24 #include "hmdccal2parsim.h"
25 #include "hmdccelleff.h"
26 #include "hmdclookupgeom.h"
27 #include "hmdclayergeompar.h"
28 #include "hmdcgeompar.h"
29 #include "hmdctimecut.h"
30 #include <iostream>
31 #include <iomanip>
32 
33 
34 ClassImp(HMdcParRootFileIo)
35 
36 HMdcParRootFileIo::HMdcParRootFileIo(HParRootFile* f) : HDetParRootFileIo(f) {
37  // constructor sets the name of the detector I/O "HMdcParIo"
38  fName="HMdcParIo";
39  initModules=new TArrayI(24);
40  initModuleTypes=new TArrayI(4);
41 }
42 
43 
44 HMdcParRootFileIo::~HMdcParRootFileIo() {
45  // destructor
46  if (modulesFound) {
47  delete modulesFound;
48  modulesFound=0;
49  }
50  if (initModules) {
51  delete initModules;
52  initModules=0;
53  }
54  if (initModuleTypes) {
55  delete initModuleTypes;
56  initModuleTypes=0;
57  }
58 }
59 
60 
61 Bool_t HMdcParRootFileIo::init(HParSet* pPar,Int_t* set) {
62  // initializes a container called by name, but only the modules
63  // defined in the array 'set'
64  // calls the special read function for this container
65  // If it is called the first time it reads the setup found in the file
66  if (!isActiv) readModules("Mdc");
67  const Text_t* name=pPar->GetName();
68  if (pFile) {
69  if (strcmp(name,"MdcRawStruct")==0) return read((HMdcRawStruct*)pPar,set);
70  if (strcmp(name,"MdcGeomStruct")==0) return read((HMdcGeomStruct*)pPar,set);
71  if (strncmp(name,"MdcCalParRaw",strlen("MdcCalParRaw"))==0) return read((HMdcCalParRaw*)pPar,set);
72  if (strncmp(name,"MdcTdcThreshold",strlen("MdcTdcThreshold"))==0) return read((HMdcTdcThreshold*)pPar,set);
73  if (strncmp(name,"MdcTdcChannel",strlen("MdcTdcChannel"))==0) return read((HMdcTdcChannel*)pPar,set);
74  if (strcmp(name,"MdcCal2ParSim")==0) return read((HMdcCal2ParSim*)pPar,set);
75  if (strncmp(name,"MdcCellEff",strlen("MdcCellEff"))==0) return read((HMdcCellEff*)pPar,set);
76  if (strncmp(name,"MdcTimeCut",strlen("MdcTimeCut"))==0) return read((HMdcTimeCut*)pPar,set);
77  if (strcmp(name,"MdcLookupGeom")==0) return read((HMdcLookupGeom*)pPar,set);
78  if (strcmp(name,"MdcLayerGeomPar")==0) return read((HMdcLayerGeomPar*)pPar,set);
79  if (strcmp(name,"MdcGeomPar")==0) return HDetParRootFileIo::read((HMdcGeomPar*)pPar,set);
80  }
81  Error("HMdcParRootFileIo::init()","initialization of %s not possible from ROOT file!",name);
82  return kFALSE;
83 }
84 
85 
86 Bool_t HMdcParRootFileIo::read(HMdcRawStruct* pPar,Int_t* set) {
87  // reads and fills the container "MdcRawStruct"
88  // ( names of the motherboards (characterizes the position) and
89  // the maximum number of TDCs on each of it )
90  Text_t* name=(Char_t*)pPar->GetName();
91  Int_t version=getMaxVersion(name);
92  if (version<=0)
93  {
94  pPar->setInputVersion(-1,inputNumber);
95  return kFALSE;
96  } // not in ROOT file
97  if (pPar->getInputVersion(inputNumber)==version
98  && pPar->getInputVersion(inputNumber)!=-1) return kTRUE;
99  // needs reinitialization
100  HMdcRawStruct* r=(HMdcRawStruct*)findContainer(name,version);
101  Bool_t allFound=kTRUE;
102  Int_t pos;
103  initModules->Reset();
104  HMdcRawStruct& rMdc=*r;
105  HMdcRawStruct& pMdc=*pPar;
106  for(Int_t s=0;s<pMdc.getSize();s++) {
107  HMdcRawSecStru& rSec=rMdc[s];
108  HMdcRawSecStru& pSec=pMdc[s];
109  for(Int_t m=0;m<pSec.getSize();m++) {
110  HMdcRawModStru& rMod=rSec[m];
111  HMdcRawModStru& pMod=pSec[m];
112  pos=s*4+m;
113  if (set[pos]) {
114  if (modulesFound->At(pos)) {
115  for(Int_t n=0;n<pMod.getSize();n++) {
116  pMod[n].SetName(rMod[n].GetName());
117  pMod[n].setNTdcs(rMod[n].getNTdcs());
118  }
119  set[pos]=0;
120  initModules->AddAt(pos+1,pos);
121  } else allFound=kFALSE;
122  }
123  }
124  }
125  pPar->setInputVersion(version,inputNumber);
126  pPar->setChanged();
127 
128  Char_t message[200];
129  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
130  printInfo(message);
131 
132  delete r;
133  return allFound;
134 }
135 
136 
137 Bool_t HMdcParRootFileIo::read(HMdcGeomStruct* pPar,Int_t* set) {
138  // reads and fills the container "MdcGeomStruct"
139  // (number of the cells in each layer)
140  Text_t* name=(Char_t*)pPar->GetName();
141  Int_t version=getMaxVersion(name);
142  if (version<=0)
143  {
144  pPar->setInputVersion(-1,inputNumber);
145  return kFALSE;
146  } // not in ROOT file
147  if (pPar->getInputVersion(inputNumber)==version
148  && pPar->getInputVersion(inputNumber)!=-1) return kTRUE;
149  // needs reinitialization
150  HMdcGeomStruct* r=(HMdcGeomStruct*)findContainer(name,version);
151  Bool_t allFound=kTRUE;
152  Int_t pos;
153  initModules->Reset();
154  HMdcGeomStruct& pP=*pPar;
155  HMdcGeomStruct& rP=*r;
156  for(Int_t i=0;i<pP.getSize();i++) {
157  HMdcGeomSecStru& pSec=pP[i];
158  HMdcGeomSecStru& rSec=rP[i];
159  for(Int_t j=0;j<pSec.getSize();j++) {
160  pos=i*4+j;
161  if (set[pos]) {
162  if (modulesFound->At(pos)) {
163  HMdcGeomModStru& pMod=pSec[j];
164  HMdcGeomModStru& rMod=rSec[j];
165  for(Int_t k=0;k<pMod.getSize();k++) pMod.fill(k,rMod[k]);
166  set[pos]=0;
167  initModules->AddAt(pos+1,pos);
168  } else allFound=kFALSE;
169  }
170  }
171  }
172  pPar->setInputVersion(version,inputNumber);
173  pPar->setChanged();
174 
175  Char_t message[200];
176  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
177  printInfo(message);
178 
179  delete r;
180  return allFound;
181 }
182 
183 
184 Bool_t HMdcParRootFileIo::read(HMdcCalParRaw* pCalPar,Int_t* set) {
185  // reads and fills the container "MdcCalParRaw" for calibration parameters
186  // on raw level
187  Text_t* name=(Char_t*)pCalPar->GetName();
188  Int_t version=findInputVersion(name);
189  if (version<=0)
190  {
191  pCalPar->setInputVersion(-1,inputNumber);
192  return kFALSE;
193  } // not in ROOT file
194  if (pCalPar->getInputVersion(inputNumber)==version
195  && pCalPar->getInputVersion(inputNumber)!=-1) return kTRUE;
196  // needs reinitialization
197  HMdcCalParRaw* r=(HMdcCalParRaw*)findContainer(name,version);
198  Bool_t allFound=kTRUE;
199  Int_t pos;
200  initModules->Reset();
201  HMdcCalParRaw& rMdc=*r;
202  HMdcCalParRaw& pMdc=*pCalPar;
203  for(Int_t s=0;s<pMdc.getSize();s++) {
204  HMdcCalParRawSec& rSec=rMdc[s];
205  HMdcCalParRawSec& pSec=pMdc[s];
206  for(Int_t m=0;m<pSec.getSize();m++) {
207  HMdcCalParRawMod& rMod=rSec[m];
208  HMdcCalParRawMod& pMod=pSec[m];
209  pos=s*4+m;
210  if (set[pos]) {
211  for(Int_t l=0;l<pMod.getSize();l++) {
212  HMdcCalParMbo& rMbo=rMod[l];
213  HMdcCalParMbo& pMbo=pMod[l];
214  Int_t pMboSize=pMbo.getSize();
215  if (pMboSize>0) {
216  if (rMbo.getSize()==pMboSize) {
217  for(Int_t c=0;c<pMboSize;c++) pMbo[c].fill(rMbo[c]);
218  set[pos]=0;
219  initModules->AddAt(pos+1,pos);
220  } else allFound=kFALSE;
221  }
222  }
223  }
224  }
225  }
226  pCalPar->setInputVersion(version,inputNumber);
227  pCalPar->setChanged();
228 
229  Char_t message[200];
230  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
231  printInfo(message);
232 
233  delete r;
234  return allFound;
235 }
236 
237 Bool_t HMdcParRootFileIo::read(HMdcTdcThreshold* pCalPar,Int_t* set) {
238  // reads and fills the container "MdcTdcThreshold" for threshold parameters of Mdc
239  Text_t* name=(Char_t*)pCalPar->GetName();
240  Int_t version=findInputVersion(name);
241  if (version<=0)
242  {
243  pCalPar->setInputVersion(-1,inputNumber);
244  return kFALSE;
245  } // not in ROOT file
246  if (pCalPar->getInputVersion(inputNumber)==version
247  && pCalPar->getInputVersion(inputNumber)!=-1) return kTRUE;
248  // needs reinitialization
249  HMdcTdcThreshold* r=(HMdcTdcThreshold*)findContainer(name,version);
250  Bool_t allFound=kTRUE;
251  Int_t pos;
252  initModules->Reset();
253  HMdcTdcThreshold& rMdc=*r;
254  HMdcTdcThreshold& pMdc=*pCalPar;
255  for(Int_t s=0;s<pMdc.getSize();s++) {
256  HMdcTdcThresholdSec& rSec=rMdc[s];
257  HMdcTdcThresholdSec& pSec=pMdc[s];
258  for(Int_t m=0;m<pSec.getSize();m++) {
259  HMdcTdcThresholdMod& rMod=rSec[m];
260  HMdcTdcThresholdMod& pMod=pSec[m];
261  pos=s*4+m;
262  if (set[pos]) {
263  for(Int_t l=0;l<pMod.getSize();l++) {
264  HMdcTdcThresholdMbo& rMbo=rMod[l];
265  HMdcTdcThresholdMbo& pMbo=pMod[l];
266  Int_t pMboSize=pMbo.getSize();
267  if (pMboSize>0) {
268  if (rMbo.getSize()==pMboSize) {
269  for(Int_t c=0;c<pMboSize;c++) pMbo[c].fill(rMbo[c]);
270  set[pos]=0;
271  initModules->AddAt(pos+1,pos);
272  } else allFound=kFALSE;
273  }
274  }
275  }
276  }
277  }
278  pCalPar->setInputVersion(version,inputNumber);
279  pCalPar->setChanged();
280 
281  Char_t message[200];
282  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
283  printInfo(message);
284 
285  delete r;
286  return allFound;
287 }
288 
289 Bool_t HMdcParRootFileIo::read(HMdcTdcChannel* pCalPar,Int_t* set) {
290  // reads and fills the container "MdcTdcChannel" for threshold parameters of Mdc
291  Text_t* name=(Char_t*)pCalPar->GetName();
292  Int_t version=findInputVersion(name);
293  if (version<=0)
294  {
295  pCalPar->setInputVersion(-1,inputNumber);
296  return kFALSE;
297  } // not in ROOT file
298  if (pCalPar->getInputVersion(inputNumber)==version
299  && pCalPar->getInputVersion(inputNumber)!=-1) return kTRUE;
300  // needs reinitialization
301  HMdcTdcChannel* r=(HMdcTdcChannel*)findContainer(name,version);
302  Bool_t allFound=kTRUE;
303  Int_t pos;
304  initModules->Reset();
305  HMdcTdcChannel& rMdc=*r;
306  HMdcTdcChannel& pMdc=*pCalPar;
307  for(Int_t s=0;s<pMdc.getSize();s++) {
308  HMdcTdcChannelSec& rSec=rMdc[s];
309  HMdcTdcChannelSec& pSec=pMdc[s];
310  for(Int_t m=0;m<pSec.getSize();m++) {
311  HMdcTdcChannelMod& rMod=rSec[m];
312  HMdcTdcChannelMod& pMod=pSec[m];
313  pos=s*4+m;
314  if (set[pos]) {
315  for(Int_t l=0;l<pMod.getSize();l++) {
316  HMdcTdcChannelMbo& rMbo=rMod[l];
317  HMdcTdcChannelMbo& pMbo=pMod[l];
318  Int_t pMboSize=pMbo.getSize();
319  if (pMboSize>0) {
320  if (rMbo.getSize()==pMboSize) {
321  for(Int_t c=0;c<pMboSize;c++) pMbo[c].fill(rMbo[c]);
322  set[pos]=0;
323  initModules->AddAt(pos+1,pos);
324  } else allFound=kFALSE;
325  }
326  }
327  }
328  }
329  }
330  pCalPar->setInputVersion(version,inputNumber);
331  pCalPar->setChanged();
332 
333  Char_t message[200];
334  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
335  printInfo(message);
336 
337  delete r;
338  return allFound;
339 }
340 
341 Bool_t HMdcParRootFileIo::read(HMdcTimeCut* pTimeCut,Int_t* set) {
342  // reads and fills the container "MdcTimeCut" for time cut parameters
343  Text_t* name=(Char_t*)pTimeCut->GetName();
344  Int_t version=findInputVersion(name);
345  if (version<=0)
346  {
347  pTimeCut->setInputVersion(-1,inputNumber);
348  return kFALSE;
349  } // not in ROOT file
350  if (pTimeCut->getInputVersion(inputNumber)==version
351  && pTimeCut->getInputVersion(inputNumber)!=-1) return kTRUE;
352  // needs reinitialization
353  HMdcTimeCut* r=(HMdcTimeCut*)findContainer(name,version);
354  Bool_t allFound=kTRUE;
355  Int_t pos;
356  initModules->Reset();
357 
358  HMdcTimeCut& rMdc=*r;
359  HMdcTimeCut& pMdc=*pTimeCut;
360 
361  for(Int_t s=0;s<pMdc.getSize();s++) {
362  HMdcTimeCutSec& rSec=rMdc[s];
363  HMdcTimeCutSec& pSec=pMdc[s];
364  for(Int_t m=0;m<pSec.getSize();m++) {
365  HMdcTimeCutMod& rMod=rSec[m];
366  HMdcTimeCutMod& pMod=pSec[m];
367  pos=s*4+m;
368  if (set[pos]) {
369  pMod.fill(rMod);
370  set[pos]=0;
371  initModules->AddAt(pos+1,pos);
372  }
373  }
374  }
375  pTimeCut->setInputVersion(version,inputNumber);
376  pTimeCut->setChanged();
377 
378  Char_t message[200];
379  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
380  printInfo(message);
381 
382  delete r;
383  return allFound;
384 }
385 Bool_t HMdcParRootFileIo::read(HMdcCal2ParSim* pCalPar,Int_t* set) {
386  // reads and fills the container "MdcCal2ParSim" for calibration parameters
387  Text_t* name=(Char_t*)pCalPar->GetName();
388  Int_t version=findInputVersion(name);
389  if (version<=0)
390  {
391  pCalPar->setInputVersion(-1,inputNumber);
392  return kFALSE;
393  } // not in ROOT file
394  if (pCalPar->getInputVersion(inputNumber)==version
395  && pCalPar->getInputVersion(inputNumber)!=-1) return kTRUE;
396  // needs reinitialization
397  HMdcCal2ParSim* r=(HMdcCal2ParSim*)findContainer(name,version);
398  Bool_t allFound=kTRUE;
399  Int_t pos;
400  initModules->Reset();
401  HMdcCal2ParSim& rMdc=*r;
402  HMdcCal2ParSim& pMdc=*pCalPar;
403  for(Int_t s=0;s<pMdc.getSize();s++) {
404  HMdcCal2ParSecSim& rSec=rMdc[s];
405  HMdcCal2ParSecSim& pSec=pMdc[s];
406  for(Int_t m=0;m<pSec.getSize();m++) {
407  HMdcCal2ParModSim& rMod=rSec[m];
408  HMdcCal2ParModSim& pMod=pSec[m];
409  pos=s*4+m;
410  if (set[pos]) {
411  for(Int_t l=0;l<18;l++) {
412  HMdcCal2ParAngleSim& rAngle=rMod[l];
413  HMdcCal2ParAngleSim& pAngle=pMod[l];
414  pAngle.fillTime1(rAngle);
415  pAngle.fillTime2(rAngle);
416  pAngle.fillTime1Error(rAngle);
417  pAngle.fillTime2Error(rAngle);
418  set[pos]=0;
419  initModules->AddAt(pos+1,pos);
420  }
421  }
422  }
423  }
424  pCalPar->setInputVersion(version,inputNumber);
425  pCalPar->setChanged();
426 
427  Char_t message[200];
428  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
429  printInfo(message);
430 
431  delete r;
432  return allFound;
433 }
434 
435 Bool_t HMdcParRootFileIo::read(HMdcCellEff* pCellEff,Int_t* set) {
436  // reads and fills the container "MdcCellEffPar" for efficiency cuts of the digitizer
437  Text_t* name=(Char_t*)pCellEff->GetName();
438  Int_t version=findInputVersion(name);
439  if (version<=0)
440  {
441  pCellEff->setInputVersion(-1,inputNumber);
442  return kFALSE;
443  } // not in ROOT file
444  if (pCellEff->getInputVersion(inputNumber)==version
445  && pCellEff->getInputVersion(inputNumber)!=-1) return kTRUE;
446  // needs reinitialization
447  HMdcCellEff* r=(HMdcCellEff*)findContainer(name,version);
448  Bool_t allFound=kTRUE;
449  Int_t pos;
450  initModuleTypes->Reset();
451  HMdcCellEff& rMdc=*r;
452  HMdcCellEff& pMdc=*pCellEff;
453  for(Int_t m=0;m<pMdc.getSize();m++) {
454  HMdcCellEffMod& rMod=rMdc[m];
455  HMdcCellEffMod& pMod=pMdc[m];
456  pos=m;
457  if (set[pos]) {
458  for(Int_t l=0;l<18;l++) {
459  HMdcCellEffAngle& rAngle=rMod[l];
460  HMdcCellEffAngle& pAngle=pMod[l];
461  pAngle.fill(rAngle);
462  set[pos]=0;
463  initModuleTypes->AddAt(pos+1,pos);
464  }
465  }
466  }
467  pCellEff->setInputVersion(version,inputNumber);
468  pCellEff->setChanged();
469 
470  Char_t message[200];
471  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
472  printInfo(message);
473  delete r;
474  return allFound;
475 }
476 
477 Bool_t HMdcParRootFileIo::read(HMdcLookupGeom* pPar,Int_t* set) {
478  // reads and fills the container "MdcLookupGeom" for mapping of
479  Text_t* name=(Char_t*)pPar->GetName();
480  Int_t version=findInputVersion(name);
481  if (version<=0)
482  {
483  pPar->setInputVersion(-1,inputNumber);
484  return kFALSE;
485  } // not in ROOT file
486  if (pPar->getInputVersion(inputNumber)==version
487  && pPar->getInputVersion(inputNumber)!=-1) return kTRUE;
488  // needs reinitialization
489  HMdcLookupGeom* r=(HMdcLookupGeom*)findContainer(name,version);
490  Bool_t allFound=kTRUE;
491  Int_t pos;
492  initModules->Reset();
493  HMdcLookupGeom& rMdc=*r;
494  HMdcLookupGeom& pMdc=*pPar;
495  for(Int_t s=0;s<pMdc.getSize();s++) {
496  HMdcLookupGSec& rSec=rMdc[s];
497  HMdcLookupGSec& pSec=pMdc[s];
498  for(Int_t m=0;m<pSec.getSize();m++) {
499  HMdcLookupGMod& rMod=rSec[m];
500  HMdcLookupGMod& pMod=pSec[m];
501  pos=s*4+m;
502  if (set[pos]) {
503  for(Int_t l=0;l<pMod.getSize();l++) {
504  HMdcLookupMoth& rMoth=rMod[l];
505  HMdcLookupMoth& pMoth=pMod[l];
506  Int_t pMothSize=pMoth.getSize();
507  if (pMothSize>0) {
508  if (rMoth.getSize()==pMothSize) {
509  for(Int_t c=0;c<pMothSize;c++) pMoth[c].fill(rMoth[c]);
510  set[pos]=0;
511  initModules->AddAt(pos+1,pos);
512  } else allFound=kFALSE;
513  }
514  }
515  }
516  }
517  }
518  pPar->setInputVersion(version,inputNumber);
519  pPar->setChanged();
520 
521  Char_t message[200];
522  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
523  printInfo(message);
524 
525  delete r;
526  return allFound;
527 }
528 
529 Bool_t HMdcParRootFileIo::read(HMdcLayerGeomPar* pPar,Int_t* set) {
530  // reads and fills the container "MdcLayerGeomPar"
531  Text_t* name=(Char_t*)pPar->GetName();
532  Int_t version=findInputVersion(name);
533  if (version<=0)
534  {
535  pPar->setInputVersion(-1,inputNumber);
536  return kFALSE;
537  } // not in ROOT file
538  if (pPar->getInputVersion(inputNumber)==version
539  && pPar->getInputVersion(inputNumber)!=-1) return kTRUE;
540  // needs reinitialization
541  HMdcLayerGeomPar* r=(HMdcLayerGeomPar*)findContainer(name,version);
542  Bool_t allFound=kTRUE;
543  Int_t pos;
544  initModules->Reset();
545  HMdcLayerGeomPar& rMdc=*r;
546  HMdcLayerGeomPar& pMdc=*pPar;
547  for(Int_t s=0;s<6;s++) {
548  HMdcLayerGeomParSec& rSec=rMdc[s];
549  HMdcLayerGeomParSec& pSec=pMdc[s];
550  for(Int_t m=0;m<4;m++) {
551  HMdcLayerGeomParMod& rMod=rSec[m];
552  HMdcLayerGeomParMod& pMod=pSec[m];
553  pos=s*4+m;
554  if (set[pos]) {
555  Int_t pModSize=pMod.getSize();
556  if (pModSize && rMod.getSize()==pModSize) {
557  for(Int_t l=0;l<pModSize;l++) pMod[l].fill(rMod[l]);
558  set[pos]=0;
559  initModules->AddAt(pos+1,pos);
560  } else allFound=kFALSE;
561  }
562  }
563  }
564  pPar->setInputVersion(version,inputNumber);
565  pPar->setChanged();
566 
567  Char_t message[200];
568  sprintf(message,"%s%s",name,": module(s) initialized from Root file ");
569  printInfo(message);
570 
571  delete r;
572  return allFound;
573 }
HMdcTimeCutSec::getSize
Int_t getSize()
Definition: hmdctimecut.h:133
HMdcCellEff::getSize
Int_t getSize()
Definition: hmdccelleff.h:68
ClassImp
ClassImp(HMdcParRootFileIo) HMdcParRootFileIo
Definition: hmdcparrootfileio.cc:34
pCalPar
HMdcCal2ParSim * pCalPar
Definition: editCal2ParSim.C:13
HMdcCalParMbo::getSize
Int_t getSize()
Definition: hmdccalparraw.h:64
HMdcTimeCut::getSize
Int_t getSize()
Definition: hmdctimecut.h:205
HDetParRootFileIo::read
virtual Bool_t read(HParSet *)
Definition: hdetparrootfileio.cc:96
HMdcCal2ParAngleSim::fillTime2
void fillTime2(Int_t p0, Float_t p1, Float_t p2, Float_t p3, Float_t p4, Float_t p5, Float_t p6, Float_t p7, Float_t p8, Float_t p9, Float_t p10)
Definition: hmdccal2parsim.h:68
HMdcCal2ParAngleSim::fillTime1
void fillTime1(Int_t p0, Float_t p1, Float_t p2, Float_t p3, Float_t p4, Float_t p5, Float_t p6, Float_t p7, Float_t p8, Float_t p9, Float_t p10)
Definition: hmdccal2parsim.h:49
HMdcParRootFileIo::init
Bool_t init(HParSet *, Int_t *)
Definition: hmdcparrootfileio.cc:61
n
Int_t n
Definition: drawResolution.C:34
HParSet::setInputVersion
void setInputVersion(Int_t v=-1, Int_t i=0)
Definition: hparset.h:31
HMdcCal2ParAngleSim::fillTime2Error
void fillTime2Error(Int_t p0, Float_t p1, Float_t p2, Float_t p3, Float_t p4, Float_t p5, Float_t p6, Float_t p7, Float_t p8, Float_t p9, Float_t p10)
Definition: hmdccal2parsim.h:106
HParSet
Definition: hparset.h:9
HMdcCal2ParAngleSim::fillTime1Error
void fillTime1Error(Int_t p0, Float_t p1, Float_t p2, Float_t p3, Float_t p4, Float_t p5, Float_t p6, Float_t p7, Float_t p8, Float_t p9, Float_t p10)
Definition: hmdccal2parsim.h:87
HMdcCellEffAngle::fill
void fill(HMdcCellEffAngle &r)
Definition: hmdccelleff.h:22
HParSet::setChanged
void setChanged(Bool_t flag=kTRUE)
Definition: hparset.h:40
HMdcGeomModStru::fill
void fill(Int_t i, Int_t n)
Definition: hmdcgeomstruct.h:18
HMdcRawStruct::getSize
Int_t getSize()
Definition: hmdcrawstruct.h:73
HMdcParRootFileIo::read
Bool_t read(HMdcRawStruct *, Int_t *)
Definition: hmdcparrootfileio.cc:86
HMdcTimeCutMod::fill
void fill(HMdcTimeCutMod &tc)
Definition: hmdctimecut.h:68
HParSet::getInputVersion
Int_t getInputVersion(Int_t i)
Definition: hparset.h:34