HYDRA_development_version
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
hmdccal2par.cc
Go to the documentation of this file.
1 //*-- AUTHOR : J. Markert
2 
3 //_HADES_CLASS_DESCRIPTION
4 ////////////////////////////////////////////////////////////////////////////
5 // HMdcCal2Par
6 //
7 // Container class for the calibration parameters from Cal1 to Cal2 of the MDC
8 // time -> distance.Contains functions for calculating time ->distance for santiago track fitter
9 // and Calibrater2 of Mdc
10 ////////////////////////////////////////////////////////////////////////////
11 
12 #include "hmdccal2par.h"
13 #include "hmdccal2parsim.h"
14 #include "hades.h"
15 #include "hruntimedb.h"
16 #include "hspectrometer.h"
17 #include "hmdcdetector.h"
18 #include "hpario.h"
19 #include "hdetpario.h"
20 #include "hdetector.h"
21 #include "hmessagemgr.h"
22 
23 #include "TH2.h"
24 #include "TStyle.h"
25 #include "TROOT.h"
26 #include "TCanvas.h"
27 #include "TGraphErrors.h"
28 #include "TF1.h"
29 #include "TMath.h"
30 
31 
32 using namespace std;
33 #include <stdlib.h>
34 #include <iostream>
35 #include <iomanip>
36 
37 ClassImp(HMdcCal2ParAngle)
38 ClassImp(HMdcCal2ParMod)
39 ClassImp(HMdcCal2ParSec)
40 ClassImp(HMdcCal2Par)
41 
42 
43 
44 void HMdcCal2ParAngle::fillDistance(HMdcCal2ParAngle& r) {
45  for(Int_t i=0;i<100;i++)
46  {
47  distance[i]=r.distance[i];
48  }
49 }
50 void HMdcCal2ParAngle::fillDistanceError(HMdcCal2ParAngle& r) {
51  for(Int_t i=0;i<100;i++)
52  {
53  distanceErr[i]=r.distanceErr[i];
54  }
55 }
56 HMdcCal2ParMod::HMdcCal2ParMod(Int_t sec, Int_t mod, Int_t angle) {
57  // constructor takes the sector, module and angle
58  array = new TObjArray(angle);
59  for (Int_t i=0; i<angle; ++i)
60  array->AddAt(new HMdcCal2ParAngle(),i);
61 }
62 
63 HMdcCal2ParMod::~HMdcCal2ParMod() {
64  // destructor
65  array->Delete();
66  delete array;
67 }
68 
69 HMdcCal2ParSec::HMdcCal2ParSec(Int_t sec, Int_t mod) {
70  // constructor takes the sector, module number
71  array = new TObjArray(mod);
72  for (Int_t i=0; i<mod; i++)
73  array->AddAt(new HMdcCal2ParMod(sec,i),i);
74 }
75 
76 HMdcCal2ParSec::~HMdcCal2ParSec() {
77  // destructor
78  array->Delete();
79  delete array;
80 }
81 
82 HMdcCal2Par::HMdcCal2Par(const Char_t* name,const Char_t* title,
83  const Char_t* context,Int_t n)
84  : HParSet(name,title,context)
85 {
86  // constructor
87  comment="no comment";
88 
89  cal2parsim=0;
90  cal2parsim=(HMdcCal2ParSim*)gHades->getRuntimeDb()->getContainer("MdcCal2ParSim");
91  if(!cal2parsim)
92  {
93  Error("HMdcCal2Par()","ZERO POINTER RETRIEVED FOR HMDCCAL2PARSIM!");
94  exit(1);
95  }
96  strcpy(detName,"Mdc");
97  if (gHades) {
98  fMdc = (HMdcDetector*)(((HSpectrometer*)(gHades->getSetup()))->getDetector("Mdc"));
99  } else {
100  fMdc = 0;
101  }
102  array = new TObjArray(n);
103  for (Int_t i=0; i<n; i++) array->AddAt(new HMdcCal2ParSec(i),i);
104  linecounter=0;
105  linecounterwrite=0;
106  type=0;
107  myslopeOutside=0.01;
108 }
109 
110 HMdcCal2Par::~HMdcCal2Par() {
111  // destructor
112  array->Delete();
113  delete array;
114 }
115 
116 Bool_t HMdcCal2Par::init(HParIo* inp) {
117  // intitializes the container from an input
118  linecounter=0;
119  linecounterwrite=0;
120  type=0;
121 
122  if (!cal2parsim) return kFALSE;
123  Int_t v1=cal2parsim->getInputVersion(1);
124  Int_t v2=cal2parsim->getInputVersion(2);
125  if (v1==versions[1] && v2==versions[2]) return kTRUE;
126  // needs reinitialization
127 
128  HDetector *mdcDet = (HMdcDetector*)(((HSpectrometer*)(gHades->getSetup()))->getDetector("Mdc"));
129  if (!mdcDet)
130  {
131  Error("HMdcCal2Par:init()","Detector setup (gHades->getSetup()->getDetector(\"Mdc\")) missing.");
132  }
133  else
134  {
135  INFO_msg(10,HMessageMgr::DET_MDC,"HMdcCal2Par initialized from HMdcCal2ParSim for modules ");
136  Char_t *buf;
137  buf = new char[200];
138  strcpy(buf,"\n");
139  for(Int_t s=0; s<6; s++)
140  { //loop over sectors
141  for(Int_t m=0; m<4; m++)
142  { //loop over modules
143  if (!mdcDet->getModule(s, m)) continue;
144  sprintf(buf,"%s %i",buf,s*4+m);
145  for(Int_t a=0;a<18;a++)
146  {
147  cal2parsim->transformToDistance(s,m,a,4.0,this);
148  }
149  }
150  }
151  gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName(),"%s ",buf);
152  delete []buf;
153  }
154  myslopeOutside=cal2parsim->getSlopeOutside();
155 
156  versions[1]=v1;
157  versions[2]=v2;
158  changed=kTRUE;
159  return kTRUE;
160 }
161 void HMdcCal2Par::plot(Int_t s,Int_t m)
162 {
163  // plots data into TGraphErrors for distance including errors
164 
165  cout<<"HMdcCal2Par: plotting sector "<<s<<" module "<<m<<endl;
166  gStyle->SetOptStat(0);
167  gStyle->SetOptTitle(0);
168 
169  Char_t nameCanvas[300];
170  sprintf(nameCanvas,"%s %i %s %i","time -> distance sector ",s," module ",m);
171  TH2F* dummy=new TH2F("dummy","dummy",2,0,410,2,0,10.1);
172  dummy->SetXTitle("drift time [ns]");
173  dummy->SetYTitle("distance from wire [mm]");
174 
175  TCanvas* result=new TCanvas(nameCanvas,nameCanvas,1000,800);
176  result->Divide(6,3);
177  result->Draw();
178  Float_t x[100];
179  Float_t y[100];
180  Float_t ex[100];
181  Float_t ey[100];
182 
183  for(Int_t a=0;a<18;a++)
184  {
185  for(Int_t i=0;i<100;i++)
186  {
187  x[i] =i*4.0;
188  y[i] =(*this)[s][m][a].distance[i];
189  ex[i]=0;
190  ey[i]=(*this)[s][m][a].distanceErr[i];
191  }
192  result->cd(a+1);
193  dummy->DrawCopy();
194  TGraphErrors* g=new TGraphErrors(100,x,y,ex,ey);
195  g->SetLineColor(2);
196  g->Draw();
197  }
198  result->Update();
199  delete dummy;
200 }
201 void HMdcCal2Par::plot2D(Int_t s,Int_t m,Int_t type)
202 {
203  // Plots data into 2d-Hists
204  // type = 0 ->distance
205  // type = 1 ->Error distance
206 
207  cout<<"HMdcCal2Par: plotting 2D sector "<<s<<" module "<<m<<endl;
208 
209  gStyle->SetOptStat(0);
210  gStyle->SetOptTitle(0);
211  gStyle->SetPalette(1);
212 
213  Char_t nameCanvas[300];
214  if(type==0)sprintf(nameCanvas,"%s %i %s %i","distance sector ",s," module ",m);
215  if(type==1)sprintf(nameCanvas,"%s %i %s %i","Error distance sector ",s," module ",m);
216 
217  TH2F* dummy=new TH2F("dummy","dummy",18,0,90,100,0,400);
218 
219  dummy->SetXTitle("angle");
220  dummy->SetYTitle("drift time [ns]");
221 
222  if(type==0)dummy->SetZTitle("distance [mm]");
223  if(type==1)dummy->SetZTitle("Error distance [mm]");
224 
225  TCanvas* result=new TCanvas(nameCanvas,nameCanvas,1000,800);
226 
227  for(Int_t a=0;a<18;a++)
228  {
229  for(Int_t i=0;i<100;i++)
230  {
231  if(type==0)dummy->SetBinContent(a+1,i,(*this)[s][m][a].distance[i]);
232  if(type==1)dummy->SetBinContent(a+1,i,(*this)[s][m][a].distanceErr[i]);
233  }
234  }
235  result->cd();
236  dummy->DrawCopy("lego2");
237 
238  result->Update();
239  delete dummy;
240 }
241 Double_t HMdcCal2Par::calcDistance(Int_t s,Int_t m,Double_t a,Double_t time)
242 {
243  // This function calculates the distance from sense wire for a given drift time.
244  // A Interpolation between the two closest angle steps
245  // is performed and the distance value returned.
246  // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
247  // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
248  // perpendicular impact).
249  // y ^
250  // | |------------*----| cathod plane
251  // | | cell * |
252  // | | / * |
253  // | | /90 * |
254  // | | driftDist/ *|
255  // | | / | *
256  // --|--|--------*^-|-----|*---------> sense/potential plane
257  // | | | | * x
258  // | | alphaDrDist| *
259  // | |/ * alphaDriftDist=90-alphaTrack
260  // | alphaTrack / *
261  // |-----------------| * track cathod plane
262  //
263  // angles must be between 0 and 90 degree, all other angles have to be shifted
264  // before calling the function.
265  if(time<0)
266  {
267  return -1;
268  }
269  Double_t angle=90.-a;
270  Double_t angleStepD=angle/5;
271  Int_t angleStepI=Int_t(angleStepD);
272  if(angleStepI==18)angleStepI=17; // if angle==90, angleStepI=18 ->not defined
273 
274  HMdcCal2ParAngle& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
275  HMdcCal2ParAngle& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;
276 
277  Double_t dminF=time/4.;
278  Int_t dminI=Int_t(dminF);
279 
280  Double_t finalDistance;
281  if(dminI>98)
282  { // drift time outside matrix
283  Double_t y1=(time-396)/myslopeOutside + rAngle.distance[99];
284  Double_t y2=(time-396)/myslopeOutside + rAngle2.distance[99];
285 
286  Double_t t=angleStepD - angleStepI;
287 
288  finalDistance=y1-t*(y1-y2);
289  return finalDistance;
290  }
291 
292  //#################################### calc distance ######################
293  Double_t y1=rAngle.distance [dminI];
294  Double_t y2=rAngle2.distance[dminI];
295  Double_t y3=rAngle2.distance[dminI+1];
296  Double_t y4=rAngle.distance [dminI+1];
297 
298  Double_t t=angleStepD - angleStepI;
299  Double_t u=dminF - dminI;
300 
301  finalDistance=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
302  return finalDistance;
303 }
304 Double_t HMdcCal2Par::calcDistanceErr(Int_t s,Int_t m,Double_t a,Double_t time) {
305  // This function calculates the Error of distance from sense wire for a given drift time.
306  // A Interpolation between the two closest angle steps
307  // is performed and the distance value returned.
308  // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
309  // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
310  // perpendicular impact).
311  // y ^
312  // | |------------*----| cathod plane
313  // | | cell * |
314  // | | / * |
315  // | | /90 * |
316  // | | driftDist/ *|
317  // | | / | *
318  // --|--|--------*^-|-----|*---------> sense/potential plane
319  // | | | | * x
320  // | | alphaDrDist| *
321  // | |/ * alphaDriftDist=90-alphaTrack
322  // | alphaTrack / *
323  // |-----------------| * track cathod plane
324  //
325  // angles must be between 0 and 90 degree, all other angles have to be shifted
326  // before calling the function.
327  if(time<0)
328  {
329  return -1;
330  }
331  Double_t angle=90.-a;
332  Double_t angleStepD=angle/5;
333  Int_t angleStepI=Int_t(angleStepD);
334  if(angleStepI==18)angleStepI=17; // if angle==90, angleStepI=18 ->not defined
335 
336  HMdcCal2ParAngle& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
337  HMdcCal2ParAngle& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;
338 
339  Double_t dminF=time/4.;
340  Int_t dminI=Int_t(dminF);
341 
342  Double_t finalErr;
343  if(dminI>98)
344  { // drift time outside matrix
345  Double_t y1= rAngle.distance[99];
346  Double_t y2= rAngle2.distance[99];
347 
348  Double_t t=angleStepD - angleStepI;
349 
350  finalErr=y1-t*(y1-y2);
351  return finalErr;
352  }
353 
354  //#################################### calc distance Error ######################
355  Double_t y1=rAngle.distanceErr [dminI];
356  Double_t y2=rAngle2.distanceErr[dminI];
357  Double_t y3=rAngle2.distanceErr[dminI+1];
358  Double_t y4=rAngle.distanceErr [dminI+1];
359 
360  Double_t t=angleStepD - angleStepI;
361  Double_t u=dminF - dminI;
362 
363  finalErr=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
364  return finalErr;
365 }
366 void HMdcCal2Par::calcDistance(Int_t s,Int_t m,Double_t a,Double_t time
367  ,Double_t*dist,Double_t*distErr)
368 {
369  // This function calculates the distance from sense wire for a given drift time.
370  // A Interpolation between the two closest angle steps
371  // is performed and the distance value returned.
372  // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
373  // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
374  // perpendicular impact).
375  // y ^
376  // | |------------*----| cathod plane
377  // | | cell * |
378  // | | / * |
379  // | | /90 * |
380  // | | driftDist/ *|
381  // | | / | *
382  // --|--|--------*^-|-----|*---------> sense/potential plane
383  // | | | | * x
384  // | | alphaDrDist| *
385  // | |/ * alphaDriftDist=90-alphaTrack
386  // | alphaTrack / *
387  // |-----------------| * track cathod plane
388  //
389  // angles must be between 0 and 90 degree, all other angles have to be shifted
390  // before calling the function.
391  // Distance and Error of Distance are returned to Float pointers
392  if(time<0)
393  {
394  *dist =-1;
395  *distErr=-1;
396  }
397  else
398  {
399  Double_t angle=90.-a;
400  Double_t angleStepD=angle/5;
401  Int_t angleStepI=Int_t(angleStepD);
402  if(angleStepI==18)angleStepI=17; // if angle==90, angleStepI=18 ->not defined
403 
404  HMdcCal2ParAngle& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
405  HMdcCal2ParAngle& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;
406 
407  Double_t dminF=time/4.;
408  Int_t dminI=Int_t(dminF);
409 
410  if(dminI>98)
411  { // drift time outside matrix
412  Double_t y1=(time-396)/myslopeOutside + rAngle.distance[99];
413  Double_t y2=(time-396)/myslopeOutside + rAngle2.distance[99];
414 
415  Double_t t=angleStepD - angleStepI;
416 
417  *dist=y1-t*(y1-y2);
418 
419  y1=rAngle.distance[99];
420  y2=rAngle2.distance[99];
421 
422  *distErr=y1-t*(y1-y2);
423  }
424  else
425  {
426  //#################################### calc distance ######################
427  Double_t y1=rAngle.distance [dminI];
428  Double_t y2=rAngle2.distance[dminI];
429  Double_t y3=rAngle2.distance[dminI+1];
430  Double_t y4=rAngle.distance [dminI+1];
431 
432  Double_t t=angleStepD - angleStepI;
433  Double_t u=dminF - dminI;
434 
435  *dist=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
436 
437  //################################ calc errors ######################################
438  y1=rAngle.distanceErr [dminI];
439  y2=rAngle2.distanceErr[dminI];
440  y3=rAngle2.distanceErr[dminI+1];
441  y4=rAngle.distanceErr [dminI+1];
442 
443  *distErr=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
444  }
445  }
446 }
447 Int_t HMdcCal2Par::write(HParIo* output) {
448  // writes the container to an output
449  if (strcmp(output->IsA()->GetName(),"HParAsciiFileIo")==0)
450  {
451  HDetParIo* out=output->getDetParIo("HMdcParIo");
452  if (out) return out->write(this);
453  }
454  changed=kFALSE;
455  return 0;
456 }
457 void HMdcCal2Par::putAsciiHeader(TString& header) {
458  // puts the ascii header to the string used in HMdcParAsciiFileIo
459  header=
460  "# Cal2 Calibration parameters of the MDC\n"
461  "# time -> distance\n"
462  "# Format: type: 0=dist, 1=distErr\n"
463  "# sector module angle type par0 par1 par2 par3 par4 par5 pa6 par7 par8 par9 par10\n";
464 }
465 
466 Bool_t HMdcCal2Par::writeline(Char_t *buf, Int_t sec, Int_t mod, Int_t angle) {
467  // writes one line to the buffer used by ascii file I/O
468  Bool_t r = kTRUE;
469  if (fMdc) {
470  if (fMdc->getModule(sec,mod) != 0) {
471  if (sec>-1 && sec<getSize()) {
472  HMdcCal2ParSec &sector = (*this)[sec];
473  if (mod>-1 && mod<sector.getSize()) {
474 
475  HMdcCal2ParAngle& rAngle=(*this)[sec][mod][angle];
476  Char_t dummy[20];
477 
478  if(linecounterwrite%10==0&&linecounterwrite>1)
479  {
480  linecounterwrite=0;
481  type++;
482  }
483  if(type>1)
484  {
485  type=0;
486  }
487  sprintf(dummy,"%1i %1i %2i %1i",sec, mod, angle, type);
488  switch (type){
489  case 0:
490  sprintf(buf,"%s %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f\n",
491  dummy,
492  rAngle.getDistance(linecounterwrite,0),rAngle.getDistance(linecounterwrite,1),
493  rAngle.getDistance(linecounterwrite,2),rAngle.getDistance(linecounterwrite,3),
494  rAngle.getDistance(linecounterwrite,4),rAngle.getDistance(linecounterwrite,5),
495  rAngle.getDistance(linecounterwrite,6),rAngle.getDistance(linecounterwrite,7),
496  rAngle.getDistance(linecounterwrite,8),rAngle.getDistance(linecounterwrite,9) );
497  break;
498  case 1:
499  sprintf(buf,"%s %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f\n",
500  dummy,
501  rAngle.getDistanceError(linecounterwrite,0),rAngle.getDistanceError(linecounterwrite,1),
502  rAngle.getDistanceError(linecounterwrite,2),rAngle.getDistanceError(linecounterwrite,3),
503  rAngle.getDistanceError(linecounterwrite,4),rAngle.getDistanceError(linecounterwrite,5),
504  rAngle.getDistanceError(linecounterwrite,6),rAngle.getDistanceError(linecounterwrite,7),
505  rAngle.getDistanceError(linecounterwrite,8),rAngle.getDistanceError(linecounterwrite,9) );
506  break;
507  default:Error("HMdcCal2Par::writeline()","argument \"type\" out of range ");
508  break;
509  }
510 
511  linecounterwrite++;
512  } else r = kFALSE;
513  } else r = kFALSE;
514  } else { strcpy(buf,""); }
515  }
516 
517  return r;
518 }
519 
520 void HMdcCal2Par::clear() {
521  // clears the container
522  for(Int_t s=0;s<getSize();s++) {
523  HMdcCal2ParSec& sec=(*this)[s];
524  for(Int_t m=0;m<sec.getSize();m++) {
525  HMdcCal2ParMod& mod=sec[m];
526  for(Int_t l=0;l<18;l++) {
527  HMdcCal2ParAngle& angle=mod[l];
528  angle.clear();
529  }
530  }
531  }
532  status=kFALSE;
533  resetInputVersions();
534 }
535 void HMdcCal2Par::printParam() {
536  // prints the container
537  for(Int_t s=0;s<getSize();s++) {
538  HMdcCal2ParSec& sec=(*this)[s];
539  for(Int_t m=0;m<sec.getSize();m++) {
540  HMdcCal2ParMod& mod=sec[m];
541  for(Int_t l=0;l<18;l++) {
542  HMdcCal2ParAngle& rAngle=mod[l];
543  for(Int_t mytype=0;mytype<2;mytype++){
544  for(Int_t myline=0;myline<10;myline++){
545  gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName(),"%1i %1i %2i %1i",s, m, l, mytype);
546  switch (mytype){
547  case 0:
548  gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName(),
549  "%7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f\n",
550  rAngle.getDistance(myline,0),rAngle.getDistance(myline,1),
551  rAngle.getDistance(myline,2),rAngle.getDistance(myline,3),
552  rAngle.getDistance(myline,4),rAngle.getDistance(myline,5),
553  rAngle.getDistance(myline,6),rAngle.getDistance(myline,7),
554  rAngle.getDistance(myline,8),rAngle.getDistance(myline,9) );
555  break;
556  case 1:
557  gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName(),
558  "%7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f\n",
559  rAngle.getDistanceError(myline,0),rAngle.getDistanceError(myline,1),
560  rAngle.getDistanceError(myline,2),rAngle.getDistanceError(myline,3),
561  rAngle.getDistanceError(myline,4),rAngle.getDistanceError(myline,5),
562  rAngle.getDistanceError(myline,6),rAngle.getDistanceError(myline,7),
563  rAngle.getDistanceError(myline,8),rAngle.getDistanceError(myline,9) );
564  break;
565  default:Error("HMdcCal2Par::printParam()","argument \"type\" out of range ");
566  break;
567  }
568  }
569  }
570  }
571  }
572  }
573 }
HMdcCal2Par::printParam
void printParam()
Definition: hmdccal2par.cc:535
HMdcCal2ParAngle::fillDistanceError
void fillDistanceError(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: hmdccal2par.h:51
HMdcCal2Par::putAsciiHeader
void putAsciiHeader(TString &)
Definition: hmdccal2par.cc:457
HMdcCal2ParAngle::getDistanceError
Float_t getDistanceError(Int_t line, Int_t i)
Definition: hmdccal2par.h:30
HMdcCal2Par::HMdcCal2Par
HMdcCal2Par(const Char_t *name="MdcCal2Par", const Char_t *title="cal2 calibration parameters for Mdc [time->distance]", const Char_t *context="MdcCal2ParSimProduction", Int_t n=6)
Definition: hmdccal2par.cc:82
HMdcCal2ParAngle::getDistance
Float_t getDistance(Int_t line, Int_t i)
Definition: hmdccal2par.h:29
ClassImp
ClassImp(HMdcCal2ParAngle) ClassImp(HMdcCal2ParMod) ClassImp(HMdcCal2ParSec) ClassImp(HMdcCal2Par) void HMdcCal2ParAngle
Definition: hmdccal2par.cc:37
HParSet::detName
Text_t detName[20]
Definition: hparset.h:11
HMdcCal2Par::getSize
Int_t getSize()
Definition: hmdccal2par.h:137
Hades::getRuntimeDb
HRuntimeDb * getRuntimeDb(void)
Definition: hades.h:111
HMdcCal2Par::writeline
Bool_t writeline(Char_t *, Int_t, Int_t, Int_t)
Definition: hmdccal2par.cc:466
HMdcCal2ParAngle::distanceErr
Float_t distanceErr[100]
Definition: hmdccal2par.h:22
HDetector::getModule
virtual Int_t getModule(Int_t sector, Int_t mod)
Definition: hdetector.cc:85
n
Int_t n
Definition: drawResolution.C:34
HMdcCal2Par::cal2parsim
HMdcCal2ParSim * cal2parsim
Definition: hmdccal2par.h:122
HMdcCal2Par::linecounter
Int_t linecounter
Definition: hmdccal2par.h:119
HParIo::getDetParIo
virtual HDetParIo * getDetParIo(const Text_t *)
Definition: hpario.cc:50
HMessageMgr::info
void info(Char_t level, Int_t det, const Char_t *className, const Char_t *text)
Definition: hmessagemgr.cc:473
HMdcCal2Par::plot2D
void plot2D(Int_t, Int_t, Int_t)
Definition: hmdccal2par.cc:201
HParIo
Definition: hpario.h:11
HParSet::resetInputVersions
void resetInputVersions()
Definition: hparset.cc:144
HParSet::write
virtual Int_t write()
Definition: hparset.cc:119
HMdcCal2Par::plot
void plot(Int_t, Int_t)
Definition: hmdccal2par.cc:161
HMdcCal2ParSim::transformToDistance
void transformToDistance(Int_t, Int_t, Int_t, Float_t, HMdcCal2Par *)
Definition: hmdccal2parsim.cc:859
Hades::getSetup
HSpectrometer * getSetup(void)
Definition: hades.h:112
HParSet::changed
Bool_t changed
static flag
Definition: hparset.h:14
HMdcCal2ParAngle::distance
Float_t distance[100]
Definition: hmdccal2par.h:21
HMdcCal2ParSec::HMdcCal2ParSec
HMdcCal2ParSec(Int_t sec=0, Int_t mod=4)
Definition: hmdccal2par.cc:69
HParSet
Definition: hparset.h:9
HMdcCal2Par::myslopeOutside
Float_t myslopeOutside
Definition: hmdccal2par.h:123
gHades
Hades * gHades
Definition: hades.cc:1213
INFO_msg
#define INFO_msg(level, det, text)
Definition: hmessagemgr.h:54
output
return output
Definition: hrichpadsignal.cc:32
HRuntimeDb::getContainer
HParSet * getContainer(const Text_t *)
Definition: hruntimedb.cc:124
HMdcCal2ParSec::getSize
Int_t getSize()
Definition: hmdccal2par.h:106
HParSet::status
Bool_t status
versions of container in the 2 possible inputs
Definition: hparset.h:13
HMdcCal2Par::array
TObjArray * array
Definition: hmdccal2par.h:114
HMdcCal2Par::sector
Int_t sector
Definition: hmdccal2par.h:117
HMdcCal2ParMod::HMdcCal2ParMod
HMdcCal2ParMod(Int_t sec=0, Int_t mod=0, Int_t angle=18)
Definition: hmdccal2par.cc:56
HMdcCal2ParSim::getSlopeOutside
Float_t getSlopeOutside()
Definition: hmdccal2parsim.h:229
HMdcCal2Par::fMdc
HMdcDetector * fMdc
Definition: hmdccal2par.h:115
HDetParIo::write
virtual Int_t write(HParSet *)
Definition: hdetpario.h:30
HMdcCal2Par::clear
void clear()
Definition: hmdccal2par.cc:520
HMdcCal2Par::comment
TString comment
Definition: hmdccal2par.h:116
HMdcCal2Par::calcDistanceErr
Double_t calcDistanceErr(Int_t, Int_t, Double_t, Double_t)
Definition: hmdccal2par.cc:304
Hades::getMsg
HMessageMgr * getMsg(void)
Definition: hades.h:113
HParSet::versions
Int_t versions[3]
name of the detector the container belongs to
Definition: hparset.h:12
HParSet::getInputVersion
Int_t getInputVersion(Int_t i)
Definition: hparset.h:34
HMdcCal2Par::calcDistance
Double_t calcDistance(Int_t, Int_t, Double_t, Double_t)
Definition: hmdccal2par.cc:241
HMdcCal2Par::linecounterwrite
Int_t linecounterwrite
Definition: hmdccal2par.h:120
HParSet::init
virtual Bool_t init(void)
Definition: hparset.h:21