]>
Commit | Line | Data |
---|---|---|
216d1d91 | 1 | /******************************************************************************* |
2 | * Copyright(c) 2003, IceCube Experiment at the South Pole. All rights reserved. | |
3 | * | |
4 | * Author: The IceCube RALICE-based Offline Project. | |
5 | * Contributors are mentioned in the code where appropriate. | |
6 | * | |
7 | * Permission to use, copy, modify and distribute this software and its | |
8 | * documentation strictly for non-commercial purposes is hereby granted | |
9 | * without fee, provided that the above copyright notice appears in all | |
10 | * copies and that both the copyright notice and this permission notice | |
11 | * appear in the supporting documentation. | |
12 | * The authors make no claims about the suitability of this software for | |
13 | * any purpose. It is provided "as is" without express or implied warranty. | |
14 | *******************************************************************************/ | |
15 | ||
16 | // $Id$ | |
17 | ||
18 | /////////////////////////////////////////////////////////////////////////// | |
19 | // Class IceCal2Root | |
95f2b820 | 20 | // Conversion of Amanda (ascii) calibration data into a AliObjMatrix objects |
216d1d91 | 21 | // containing the complete OM position, calibration, Xtalk etc... database. |
95f2b820 | 22 | // Via specification of the various input files, various AliObjMatrix objects |
23 | // are created and (optionally) stored in a single output file. | |
24 | // The names of the AliObjMatrix objects indicate the type of database they | |
25 | // contain. | |
26 | // For example : | |
27 | // The name "MuDaq-OMDBASE" indicates the database info for MuDaq data, | |
28 | // whereas TWRDaq calibration data is in the object named "TWRDaq-OMDBASE". | |
29 | // Note that a MuDaq Amacalib ascii input file has always to be provided, | |
30 | // since the geometry data for all the other databases is obtained from there. | |
216d1d91 | 31 | // In addition a PDG particle database, extended with some specific Amanda |
32 | // entries, is provided as well. | |
33 | // This class is derived from AliJob providing task-based processing. | |
216d1d91 | 34 | // Note that the data structures are only written out if an outputfile has |
35 | // been specified via the SetOutputFile memberfunction. | |
36 | // In case no outputfile has been specified, this class provides a facility | |
37 | // to investigate/use the dbase data directly in subsequent (sub)tasks. | |
38 | // | |
39 | // The OM database information in the AliObjMatrix has the following structure : | |
40 | // | |
41 | // (j,1) : Pointer to OM with identifier "j" | |
42 | // (j,k+1) : Pointer to a TF1* being the probability function for Xtalk | |
43 | // with OM "j" as transmitter and OM "k" as receiver. | |
44 | // | |
95f2b820 | 45 | // The latter is only available for MuDaq databases. |
46 | // | |
216d1d91 | 47 | // The geometry information is directly available from the OM pointer |
48 | // in the form of its position and data words like "ORIENT" for orientation etc... | |
49 | // Just use the OM memberfunction Data() to obtain a full overview. | |
50 | // | |
51 | // Note : Position coordinates are indicated in meters and times are in nanoseconds, | |
52 | // in accordance with the convention used previously for Amanda. | |
53 | // | |
54 | // From the OM pointer also the various (de)calibration functions for | |
55 | // ADC, LE and TOT can be obtained as TF1* pointers. | |
56 | // The actual values of the calibration constants are stored as parameters | |
57 | // of these (de)calibration functions and can be investigated via the | |
58 | // usual TF1::Print() or TF1::GetParameter() facilities. | |
59 | // The last two parameters of the Xtalk probability function have no effect | |
60 | // on the evaluated probability value. However, these two parameters provide | |
61 | // the minimum and maximum allowed LE differences between the transmitter | |
62 | // and receiver hits, respectively (as can be seen from the parameter names). | |
63 | // | |
64 | // The (de)calibration of signals and/or determination of the Xtalk probability | |
65 | // can be performed via the standard TF1::Eval(x) functionality, where "x" | |
66 | // represents the input argument of the function (e.g. an uncalibrated ADC value). | |
67 | // | |
68 | // In general the database is not directly accessed by the user in performing | |
69 | // physics analysis, since all the necessary information is contained in the | |
70 | // event data itself and available via the GetSignal() memberfunction of the hits. | |
71 | // However, specific tasks like e.g. calibration, Xtalk correction, | |
72 | // bad module removal, noise hit removal etc... might need explicit database access. | |
73 | // So, at the end of the example below some functionality is indicated for clarity. | |
74 | // The user may use exactly the same procedures to obtain explicit access to the calibration | |
75 | // functions etc... from the various OMs and/or hits within the actual event data which he/she | |
76 | // is analysing. | |
77 | // | |
78 | // The PDG particle database is a standard ROOT TDatabasePDG object | |
79 | // with the following extensions : | |
80 | // | |
81 | // Name PDG code | |
82 | // ---- -------- | |
83 | // brems 10001001 | |
84 | // deltae 10001002 | |
85 | // pairprod 10001003 | |
86 | // nucl_int 10001004 | |
87 | // mu_pair 10001005 | |
88 | // hadrons 10001006 | |
89 | // fiberlaser 10002100 | |
90 | // n2laser 10002101 | |
91 | // yaglaser 10002201 | |
92 | // z_primary 10003000 | |
93 | // a_primary 10003500 | |
94 | // | |
95 | // Usage example : | |
96 | // --------------- | |
97 | // | |
98 | // gSystem->Load("ralice"); | |
99 | // gSystem->Load("icepack"); | |
100 | // gSystem->Load("iceconvert"); | |
101 | // | |
102 | // IceCal2Root q("IceCal2Root","Amacalib to IcePack data structure conversion"); | |
103 | // | |
95f2b820 | 104 | // // The MuDaq Amacalib input filename |
105 | // q.SetAmacalibFile("amacalib_amanda2_2005.txt"); | |
106 | // | |
145a0fb7 | 107 | // // The TWRDaq input filename with the newly determined TWR T0 and ADC calibs. |
108 | // q.SetTWRDaqFile("twr-cal-2005.txt"); | |
216d1d91 | 109 | // |
110 | // // Output file for the event structures | |
95f2b820 | 111 | // q.SetOutputFile("cal2005.root"); |
216d1d91 | 112 | // |
113 | // /////////////////////////////////////////////////////////////////// | |
114 | // // Here the user can specify his/her sub-tasks to be executed | |
115 | // // after the database structures have been filled and before the | |
116 | // // data is written out. | |
117 | // // Sub-tasks (i.e. a user classes derived from TTask) are entered | |
118 | // // as follows : | |
119 | // // | |
120 | // // MyTask1 task1("task1","Some modifications to specific OMs"); | |
121 | // // MyTask2 task2("task2","Removal of specific OMs"); | |
122 | // // MyTask3 task3("task3","Add private objects to the output file"); | |
123 | // // q.Add(&task1); | |
124 | // // q.Add(&task2); | |
125 | // // q.Add(&task3); | |
126 | // // | |
127 | // // The sub-tasks will be executed in the order as they are entered. | |
128 | // /////////////////////////////////////////////////////////////////// | |
129 | // | |
130 | // // Perform the conversion and execute subtasks (if any) | |
131 | // q.ExecuteJob(); | |
132 | // | |
133 | // // Outline of dbase usage for (de)calibration and Xtalk | |
134 | // | |
95f2b820 | 135 | // AliObjMatrix* omdb=q.GetOMdbase("MuDaq"); |
216d1d91 | 136 | // IceAOM* om=(IceAOM*)omdb->GetObject(9,1); // Pointer to OM 9 |
137 | // om->Data(); // Overview of generic module parameters | |
138 | // TF1* fcal=0; // Calibration function | |
139 | // TF1* fdecal=0; // De-calibration function | |
140 | // fcal=om->GetCalFunction("ADC"); | |
141 | // Float_t adc=248; // Uncalibrated ADC | |
142 | // Float_t cadc=0; // Calibrated ADC | |
143 | // if (fcal) cadc=fcal->Eval(adc); | |
144 | // fcal=om->GetCalFunction("TOT"); | |
145 | // Float_t tot=1538; // Uncalibrated TOT | |
146 | // Float_t ctot=0; // Calibrated TOT | |
147 | // if (fcal) ctot=fcal->Eval(tot); | |
148 | // fdecal=om->GetDecalFunction("LE"); | |
149 | // Float_t le=21697; // Uncalibrated LE | |
150 | // Float_t cle=0; // Calibrated LE | |
151 | // if (fcal) cle=fcal->Eval(le); | |
152 | // | |
153 | // // Xtalk probability between (trans) OM 90 and (rec) OM 113 | |
154 | // // for a transmitter signal of uncalibrated amplitude "adc". | |
155 | // TF1* fxtalkp=(TF1*)omdb->GetObject(90,113+1); | |
156 | // Float_t prob=0; | |
157 | // adc=378; | |
158 | // if (fxtalkp) prob=fxtalkp->Eval(adc); | |
159 | // | |
160 | //--- Author: Nick van Eijndhoven 09-aug-2005 Utrecht University | |
161 | //- Modified: NvE $Date$ Utrecht University | |
162 | /////////////////////////////////////////////////////////////////////////// | |
163 | ||
164 | #include "IceCal2Root.h" | |
165 | #include "Rstrstream.h" | |
166 | ||
167 | ClassImp(IceCal2Root) // Class implementation to enable ROOT I/O | |
168 | ||
169 | IceCal2Root::IceCal2Root(const char* name,const char* title) : AliJob(name,title) | |
170 | { | |
171 | // Default constructor. | |
172 | fAmacalFileName=""; | |
95f2b820 | 173 | fTWRDaqFileName=""; |
216d1d91 | 174 | fRootFileName=""; |
175 | fOutfile=0; | |
176 | ||
177 | fPdg=0; | |
95f2b820 | 178 | fMuDaqdb=0; |
179 | fTWRDaqdb=0; | |
216d1d91 | 180 | } |
181 | /////////////////////////////////////////////////////////////////////////// | |
182 | IceCal2Root::~IceCal2Root() | |
183 | { | |
184 | // Default destructor. | |
185 | ||
186 | if (fPdg) | |
187 | { | |
188 | delete fPdg; | |
189 | fPdg=0; | |
190 | } | |
191 | ||
95f2b820 | 192 | if (fMuDaqdb) |
216d1d91 | 193 | { |
95f2b820 | 194 | delete fMuDaqdb; |
195 | fMuDaqdb=0; | |
196 | } | |
197 | ||
198 | if (fTWRDaqdb) | |
199 | { | |
200 | delete fTWRDaqdb; | |
201 | fTWRDaqdb=0; | |
216d1d91 | 202 | } |
203 | } | |
204 | /////////////////////////////////////////////////////////////////////////// | |
205 | void IceCal2Root::SetAmacalibFile(TString name) | |
206 | { | |
95f2b820 | 207 | // Set the name of the Amacalib MuDaq input file. |
216d1d91 | 208 | fAmacalFileName=name; |
209 | } | |
210 | /////////////////////////////////////////////////////////////////////////// | |
95f2b820 | 211 | void IceCal2Root::SetTWRDaqFile(TString name) |
212 | { | |
213 | // Set the name of the TWRDaq calibration input file. | |
214 | fTWRDaqFileName=name; | |
215 | } | |
216 | /////////////////////////////////////////////////////////////////////////// | |
216d1d91 | 217 | void IceCal2Root::SetOutputFile(TString name) |
218 | { | |
219 | // Set the name of the ROOT output file. | |
220 | fRootFileName=name; | |
221 | } | |
222 | /////////////////////////////////////////////////////////////////////////// | |
223 | TDatabasePDG* IceCal2Root::GetPDG() | |
224 | { | |
225 | // Provide pointer to the PDG database | |
226 | return fPdg; | |
227 | } | |
228 | /////////////////////////////////////////////////////////////////////////// | |
95f2b820 | 229 | AliObjMatrix* IceCal2Root::GetOMdbase(TString name) |
216d1d91 | 230 | { |
95f2b820 | 231 | // Provide pointer to the requested OM geometry, calib. etc... database. |
232 | // Options for the "name" specification are : MuDaq, TWRDaq. | |
233 | // For backward compatibility the default is name="MuDaq". | |
234 | ||
235 | if (name=="MuDaq") return fMuDaqdb; | |
236 | if (name=="TWRDaq") return fTWRDaqdb; | |
237 | return 0; | |
216d1d91 | 238 | } |
239 | /////////////////////////////////////////////////////////////////////////// | |
240 | void IceCal2Root::Exec(Option_t* opt) | |
241 | { | |
95f2b820 | 242 | // Job to convert the (ascii) database info into the IcePack structure. |
216d1d91 | 243 | // |
244 | // Notes : | |
245 | // ------- | |
246 | // 1) This class is derived from AliJob, allowing a task based processing. | |
95f2b820 | 247 | // After conversion of the (ascii) dbase data into the IcePack structure, |
216d1d91 | 248 | // the processing of all available sub-tasks (if any) is invoked. |
249 | // This provides a facility to investigate/use the dbase data in | |
250 | // subsequent (sub)tasks processing before the final data structures | |
251 | // are written out. | |
95f2b820 | 252 | // |
253 | // 2) Creation of a TFolder via the argument of the ExecuteJob statement | |
254 | // makes all created database objects accessible to subsequent tasks | |
255 | // via the TFolder::FindObject facility. | |
216d1d91 | 256 | |
257 | if (fOutfile) | |
258 | { | |
259 | delete fOutfile; | |
260 | fOutfile=0; | |
261 | } | |
262 | if (fRootFileName != "") | |
263 | { | |
264 | fOutfile=new TFile(fRootFileName.Data(),"RECREATE","Calibration data in IcePack structure"); | |
265 | } | |
266 | ||
216d1d91 | 267 | // Create the particle database and extend it with some F2000 specific definitions |
268 | if (fPdg) delete fPdg; | |
269 | fPdg=new TDatabasePDG(); | |
270 | fPdg->SetNameTitle("PDG-DBASE","The extended PDG particle database"); | |
271 | Double_t me=fPdg->GetParticle(11)->Mass(); | |
272 | fPdg->AddParticle("brems" ,"brems" ,0,1,0,0,"none",10001001,0,0); | |
273 | fPdg->AddParticle("deltae" ,"deltae" ,me,1,0,-3,"Lepton",10001002,0,0); | |
274 | fPdg->AddParticle("pairprod","pairprod",0,1,0,0,"none",10001003,0,0); | |
275 | fPdg->AddParticle("nucl_int","nucl_Int",0,1,0,0,"none",10001004,0,0); | |
276 | fPdg->AddParticle("mu_pair" ,"mu_pair" ,0,1,0,0,"none",10001005,0,0); | |
277 | fPdg->AddParticle("hadrons" ,"hadrons" ,0,1,0,0,"none",10001006,0,0); | |
278 | fPdg->AddParticle("fiberlaser","fiberlaser",0,1,0,0,"none",10002100,0,0); | |
279 | fPdg->AddParticle("n2laser" ,"n2laser" ,0,1,0,0,"none",10002101,0,0); | |
280 | fPdg->AddParticle("yaglaser" ,"yaglaser" ,0,1,0,0,"none",10002201,0,0); | |
281 | fPdg->AddParticle("z_primary","z_primary",0,1,0,0,"none",10003000,0,0); | |
282 | fPdg->AddParticle("a_primary","a_primary",0,1,0,0,"none",10003500,0,0); | |
283 | ||
284 | // Initialise the job working environment | |
216d1d91 | 285 | AddObject(fPdg); |
286 | if (fOutfile) AddObject(fOutfile); | |
287 | ||
288 | cout << " ***" << endl; | |
289 | cout << " *** Start processing of job " << GetName() << " ***" << endl; | |
290 | cout << " ***" << endl; | |
95f2b820 | 291 | cout << " Amacalib MuDaq input file : " << fAmacalFileName.Data() << endl; |
292 | cout << " TWRDaq input file : " << fTWRDaqFileName.Data() << endl; | |
216d1d91 | 293 | if (fOutfile) cout << " ROOT output file : " << fOutfile->GetName() << endl; |
294 | ||
95f2b820 | 295 | GetMuDaqData(); |
296 | if (fMuDaqdb) AddObject(fMuDaqdb); | |
216d1d91 | 297 | |
95f2b820 | 298 | GetTWRDaqData(); |
299 | if (fTWRDaqdb) AddObject(fTWRDaqdb); | |
300 | ||
301 | ListEnvironment(); | |
216d1d91 | 302 | |
303 | // Invoke all available sub-tasks (if any) | |
225085ba | 304 | CleanTasks(); |
216d1d91 | 305 | ExecuteTasks(opt); |
306 | ||
307 | // Write the datastructures to the output file | |
308 | if (fOutfile) | |
309 | { | |
310 | fOutfile->cd(); | |
95f2b820 | 311 | if (fMuDaqdb) fMuDaqdb->Write(); |
312 | if (fTWRDaqdb) fTWRDaqdb->Write(); | |
216d1d91 | 313 | if (fPdg) fPdg->Write(); |
314 | } | |
315 | ||
316 | // Flush remaining memory resident data to the output file | |
317 | if (fOutfile) fOutfile->Write(); | |
318 | } | |
319 | /////////////////////////////////////////////////////////////////////////// | |
95f2b820 | 320 | void IceCal2Root::GetMuDaqData() |
216d1d91 | 321 | { |
95f2b820 | 322 | // Obtain all the MuDaq geometry, calibration and Xtalk data. |
323 | ||
324 | if (fAmacalFileName=="") | |
325 | { | |
326 | cout << " *IceCal2Root GetMuDaqData* No amacalib input file specified." << endl; | |
327 | return; | |
328 | } | |
329 | ||
330 | fInput.clear(); | |
331 | fInput.open(fAmacalFileName.Data()); | |
332 | ||
333 | if (!fInput.good()) | |
334 | { | |
335 | cout << " *IceCal2Root GetMuDaqData* Bad input file : " << fAmacalFileName.Data() << endl; | |
336 | return; | |
337 | } | |
338 | ||
339 | // The MuDaq OM database object | |
340 | if (fMuDaqdb) | |
341 | { | |
342 | fMuDaqdb->Reset(); | |
343 | } | |
344 | else | |
345 | { | |
346 | fMuDaqdb=new AliObjMatrix(); | |
347 | fMuDaqdb->SetNameTitle("MuDaq-OMDBASE","The MuDaq OM geometry, calib. etc... database"); | |
348 | fMuDaqdb->SetOwner(); | |
349 | } | |
216d1d91 | 350 | |
351 | // Prescription of the various (de)calibration functions | |
352 | TF1 fadccal("fadccal","(x-[1])*[0]"); | |
353 | TF1 fadcdecal("fadcdecal","(x/[0])+[1]"); | |
354 | fadccal.SetParName(0,"BETA-ADC"); | |
355 | fadccal.SetParName(1,"PED-ADC"); | |
356 | fadcdecal.SetParName(0,"BETA-ADC"); | |
357 | fadcdecal.SetParName(1,"PED-ADC"); | |
358 | ||
359 | TF1 ftdccal("ftdccal","(x*[0])-[1]-([0]-1.)*32767.-[2]/sqrt([3])"); | |
360 | TF1 ftdcdecal("ftdcdecal","(x+([0]-1.)*32767.+[1]+[2]/sqrt([3]))/[0]"); | |
361 | ftdccal.SetParName(0,"BETA-TDC"); | |
362 | ftdccal.SetParName(1,"T0"); | |
363 | ftdccal.SetParName(2,"ALPHA-TDC"); | |
364 | ftdccal.SetParName(3,"ADC-SLEW"); | |
365 | ftdcdecal.SetParName(0,"BETA-TDC"); | |
366 | ftdcdecal.SetParName(1,"T0"); | |
367 | ftdcdecal.SetParName(2,"ALPHA-TDC"); | |
368 | ftdcdecal.SetParName(3,"ADC-SLEW"); | |
369 | ||
370 | TF1 ftotcal("ftotcal","x*[0]"); | |
371 | TF1 ftotdecal("ftotdecal","x/[0]"); | |
372 | ftotcal.SetParName(0,"BETA-TOT"); | |
373 | ftotdecal.SetParName(0,"BETA-TOT"); | |
374 | ||
375 | // The cross talk probability function | |
376 | TF1 fxtalkp("fxtalkp","(1.+[2]-[2]+[3]-[3])/(1.+exp(([0]-x)/[1]))"); | |
377 | fxtalkp.SetParName(0,"C"); | |
378 | fxtalkp.SetParName(1,"B"); | |
379 | fxtalkp.SetParName(2,"dLE-min"); | |
380 | fxtalkp.SetParName(3,"dLE-max"); | |
381 | ||
382 | // The basic OM contents | |
383 | IceAOM om; | |
384 | ||
5ae71069 | 385 | // Slots to hold the various (de)calibration functions |
8157e38c | 386 | om.AddNamedSlot("ADC"); |
387 | om.AddNamedSlot("LE"); | |
388 | om.AddNamedSlot("TOT"); | |
5ae71069 | 389 | // Slots with hardware parameters |
8157e38c | 390 | om.AddNamedSlot("TYPE"); |
391 | om.AddNamedSlot("ORIENT"); | |
392 | /// om.AddNamedSlot("THRESH"); | |
393 | /// om.AddNamedSlot("SENSIT"); | |
394 | /// om.AddNamedSlot("READOUT"); // 0=unknown 1=electrical 2=optical 3=digital | |
216d1d91 | 395 | |
396 | fInput.seekg(0); // Position at beginning of file | |
397 | fInput >> dec; // Make sure all integers starting with 0 are taken in decimal format | |
398 | ||
399 | TString s; | |
400 | Int_t jmod,type,serial,string,ix,iy,iz,ori; | |
401 | Float_t costh=0; | |
8157e38c | 402 | /// Float_t thresh=0; |
403 | /// Float_t sensit=1; | |
404 | /// Float_t readout=0; | |
216d1d91 | 405 | Double_t pos[3]={0,0,0}; |
e51b7d1a | 406 | Float_t ped,beta,alpha; |
216d1d91 | 407 | Int_t pol; |
408 | Float_t totped; | |
409 | Int_t jtrans,jrec; | |
410 | Float_t c,b,dlemin,dlemax; | |
411 | IceAOM* omx=0; | |
412 | TF1* fcal=0; | |
413 | TF1* fdecal=0; | |
414 | while (fInput >> s) | |
415 | { | |
416 | if (s == "P") // Read the Geom data | |
417 | { | |
418 | fInput >> jmod >> type >> serial >> string >> ix >> iy >> iz >> ori; | |
95f2b820 | 419 | omx=(IceAOM*)fMuDaqdb->GetObject(jmod,1); |
216d1d91 | 420 | if (!omx) |
421 | { | |
422 | omx=new IceAOM(om); | |
423 | omx->SetUniqueID(jmod); | |
95f2b820 | 424 | fMuDaqdb->EnterObject(jmod,1,omx); |
216d1d91 | 425 | } |
426 | pos[0]=double(ix)/1000.; | |
427 | pos[1]=double(iy)/1000.; | |
428 | pos[2]=double(iz)/1000.; | |
429 | omx->SetPosition(pos,"car"); | |
430 | costh=1; | |
431 | if (ori==2) costh=-1; | |
8157e38c | 432 | omx->SetSignal(type,"TYPE"); |
433 | omx->SetSignal(costh,"ORIENT"); | |
434 | /// omx->SetSignal(thresh,"THRESH"); | |
435 | /// omx->SetSignal(sensit,"SENSIT"); | |
436 | /// omx->SetSignal(readout,"READOUT"); | |
216d1d91 | 437 | } |
438 | else if (s == "T") // Read the Time calibration constants | |
439 | { | |
440 | fInput >> jmod >> ped >> beta >> alpha >> pol; | |
95f2b820 | 441 | omx=(IceAOM*)fMuDaqdb->GetObject(jmod,1); |
216d1d91 | 442 | if (!omx) |
443 | { | |
444 | omx=new IceAOM(om); | |
445 | omx->SetUniqueID(jmod); | |
95f2b820 | 446 | fMuDaqdb->EnterObject(jmod,1,omx); |
216d1d91 | 447 | } |
448 | ||
8157e38c | 449 | omx->SetCalFunction(&ftdccal,"LE"); |
450 | omx->SetDecalFunction(&ftdcdecal,"LE"); | |
451 | omx->SetCalFunction(&ftotcal,"TOT"); | |
452 | omx->SetDecalFunction(&ftotdecal,"TOT"); | |
216d1d91 | 453 | |
454 | // Flag time slots of bad OMs as dead and don't provide time (de)calib functions | |
455 | if (ped<-1e5 || beta<=0 || alpha<0) | |
456 | { | |
8157e38c | 457 | omx->SetDead("LE"); |
458 | omx->SetDead("TOT"); | |
459 | omx->SetCalFunction(0,"LE"); | |
460 | omx->SetDecalFunction(0,"LE"); | |
461 | omx->SetCalFunction(0,"TOT"); | |
462 | omx->SetDecalFunction(0,"TOT"); | |
216d1d91 | 463 | } |
464 | ||
8157e38c | 465 | fcal=omx->GetCalFunction("LE"); |
466 | fdecal=omx->GetDecalFunction("LE"); | |
216d1d91 | 467 | if (fcal) |
468 | { | |
469 | fcal->SetParameter(0,beta); | |
470 | fcal->SetParameter(1,ped); | |
471 | fcal->SetParameter(2,alpha); | |
472 | fcal->SetParameter(3,1.e20); | |
473 | } | |
474 | if (fdecal) | |
475 | { | |
476 | fdecal->SetParameter(0,beta); | |
477 | if (!beta) fdecal->SetParameter(0,1); | |
478 | fdecal->SetParameter(1,ped); | |
479 | fdecal->SetParameter(2,alpha); | |
480 | fdecal->SetParameter(3,1.e20); | |
481 | } | |
482 | ||
8157e38c | 483 | fcal=omx->GetCalFunction("TOT"); |
484 | fdecal=omx->GetDecalFunction("TOT"); | |
216d1d91 | 485 | if (fcal) |
486 | { | |
487 | fcal->SetParameter(0,beta); | |
488 | } | |
489 | if (fdecal) | |
490 | { | |
491 | fdecal->SetParameter(0,beta); | |
492 | } | |
493 | } | |
494 | else if (s == "A") // Read the Amplitude calibration constants | |
495 | { | |
496 | fInput >> jmod >> ped >> beta >> totped >> pol; | |
95f2b820 | 497 | omx=(IceAOM*)fMuDaqdb->GetObject(jmod,1); |
216d1d91 | 498 | if (!omx) |
499 | { | |
500 | omx=new IceAOM(om); | |
501 | omx->SetUniqueID(jmod); | |
95f2b820 | 502 | fMuDaqdb->EnterObject(jmod,1,omx); |
216d1d91 | 503 | } |
504 | ||
8157e38c | 505 | omx->SetCalFunction(&fadccal,"ADC"); |
506 | omx->SetDecalFunction(&fadcdecal,"ADC"); | |
216d1d91 | 507 | |
508 | // Flag amplitude slots of bad OMs as dead and don't provide amplitude (de)calib functions | |
509 | if (ped<-1e5 || beta<=0) | |
510 | { | |
8157e38c | 511 | omx->SetDead("ADC"); |
512 | omx->SetCalFunction(0,"ADC"); | |
513 | omx->SetDecalFunction(0,"ADC"); | |
216d1d91 | 514 | } |
515 | if (totped<-1e5) | |
516 | { | |
8157e38c | 517 | omx->SetDead("TOT"); |
518 | omx->SetCalFunction(0,"TOT"); | |
519 | omx->SetDecalFunction(0,"TOT"); | |
216d1d91 | 520 | } |
521 | ||
8157e38c | 522 | fcal=omx->GetCalFunction("ADC"); |
523 | fdecal=omx->GetDecalFunction("ADC"); | |
216d1d91 | 524 | if (fcal) |
525 | { | |
526 | fcal->SetParameter(0,beta); | |
527 | fcal->SetParameter(1,ped); | |
528 | } | |
529 | if (fdecal) | |
530 | { | |
531 | fdecal->SetParameter(0,beta); | |
532 | if (!beta) fdecal->SetParameter(0,1); | |
533 | fdecal->SetParameter(1,ped); | |
534 | } | |
535 | } | |
536 | else if (s == "K") // Read the cross talk probability constants | |
537 | { | |
538 | fInput >> jtrans >> jrec >> c >> b >> dlemin >> dlemax; | |
95f2b820 | 539 | omx=(IceAOM*)fMuDaqdb->GetObject(jtrans,1); |
216d1d91 | 540 | if (!omx) |
541 | { | |
542 | omx=new IceAOM(om); | |
543 | omx->SetUniqueID(jtrans); | |
95f2b820 | 544 | fMuDaqdb->EnterObject(jtrans,1,omx); |
216d1d91 | 545 | } |
546 | ||
547 | TF1* fx=new TF1(fxtalkp); | |
548 | fx->SetParameter(0,c); | |
549 | if (b) | |
550 | { | |
551 | fx->SetParameter(1,b); | |
552 | } | |
553 | else | |
554 | { | |
555 | fx->SetParameter(1,1); | |
556 | } | |
557 | fx->SetParameter(2,dlemin); | |
558 | fx->SetParameter(3,dlemax); | |
95f2b820 | 559 | fMuDaqdb->EnterObject(jtrans,jrec+1,fx); |
216d1d91 | 560 | } |
561 | else // Skip this line | |
562 | { | |
563 | fInput.ignore(99999,'\n'); | |
564 | } | |
565 | } | |
95f2b820 | 566 | |
567 | fInput.close(); | |
568 | } | |
569 | /////////////////////////////////////////////////////////////////////////// | |
570 | void IceCal2Root::GetTWRDaqData() | |
571 | { | |
572 | // Obtain all the TWRDaq geometry and calibration data. | |
573 | ||
574 | if (fTWRDaqFileName=="") | |
575 | { | |
576 | cout << " *IceCal2Root GetTWRDaqData* No TWRDaq calibration data will be produced." << endl; | |
577 | return; | |
578 | } | |
579 | ||
580 | fInput.clear(); | |
581 | fInput.open(fTWRDaqFileName.Data()); | |
582 | ||
583 | if (!fInput.good()) | |
584 | { | |
585 | cout << " *IceCal2Root GetTWRDaqData* Bad input file : " << fTWRDaqFileName.Data() << endl; | |
586 | return; | |
587 | } | |
588 | ||
589 | // The geometry info will be obtained from the MuDaq OM database | |
590 | if (!fMuDaqdb) | |
591 | { | |
592 | cout << " *IceCal2Root GetTWRDaqData* MuDaq OM geometry database is missing." << endl; | |
593 | return; | |
594 | } | |
595 | ||
596 | // The TWRDaq OM database object | |
597 | if (fTWRDaqdb) | |
598 | { | |
599 | fTWRDaqdb->Reset(); | |
600 | } | |
601 | else | |
602 | { | |
603 | fTWRDaqdb=new AliObjMatrix(); | |
604 | fTWRDaqdb->SetNameTitle("TWRDaq-OMDBASE","The TWRDaq OM geometry, calib. etc... database"); | |
605 | fTWRDaqdb->SetOwner(); | |
606 | } | |
607 | ||
608 | // Prescription of the various (de)calibration functions | |
9c52fc9b | 609 | TF1 fadccal("fadccal","x*(5./4096.)/(50.*[0])"); |
610 | TF1 fadcdecal("fadcdecal","x*(50.*[0])/(5./4096.)"); | |
611 | fadccal.SetParName(0,"nC/PE"); | |
612 | fadcdecal.SetParName(0,"nC/PE"); | |
95f2b820 | 613 | |
614 | TF1 ftdccal("ftdccal","x-[0]"); | |
615 | TF1 ftdcdecal("ftdcdecal","x+[0]"); | |
616 | ftdccal.SetParName(0,"T0"); | |
617 | ftdcdecal.SetParName(0,"T0"); | |
618 | ||
619 | TF1 ftotcal("ftotcal","x*[0]"); | |
620 | TF1 ftotdecal("ftotdecal","x/[0]"); | |
621 | ftotcal.SetParName(0,"TOT-FACT"); | |
622 | ftotdecal.SetParName(0,"TOT-FACT"); | |
623 | ||
624 | fInput.seekg(0); // Position at beginning of file | |
625 | fInput >> dec; // Make sure all integers starting with 0 are taken in decimal format | |
626 | ||
627 | Int_t jmod; | |
628 | Float_t t0; | |
9c52fc9b | 629 | Float_t ncpe; |
95f2b820 | 630 | IceAOM* omx=0; |
631 | TF1* fcal=0; | |
632 | TF1* fdecal=0; | |
9c52fc9b | 633 | while (fInput >> jmod >> t0 >> ncpe) |
95f2b820 | 634 | { |
635 | // Copy the Geom data from the MuDaq OM database | |
636 | IceAOM* omg=(IceAOM*)fMuDaqdb->GetObject(jmod,1); | |
637 | if (!omg) continue; | |
638 | ||
639 | omx=new IceAOM(*omg); | |
640 | ||
641 | // Reset all previous "dead" flags | |
642 | omx->SetAlive("ADC"); | |
643 | omx->SetAlive("LE"); | |
644 | omx->SetAlive("TOT"); | |
645 | ||
646 | // Enter the TWRDaq (de)calibration functions | |
647 | omx->SetCalFunction(&fadccal,"ADC"); | |
648 | omx->SetDecalFunction(&fadcdecal,"ADC"); | |
649 | omx->SetCalFunction(&ftdccal,"LE"); | |
650 | omx->SetDecalFunction(&ftdcdecal,"LE"); | |
651 | omx->SetCalFunction(&ftotcal,"TOT"); | |
652 | omx->SetDecalFunction(&ftotdecal,"TOT"); | |
653 | ||
9c52fc9b | 654 | // Flag slots of bad OMs as dead and don't provide time (de)calib functions |
655 | if (ncpe<=0) | |
656 | { | |
657 | omx->SetDead("ADC"); | |
658 | omx->SetCalFunction(0,"ADC"); | |
659 | omx->SetDecalFunction(0,"ADC"); | |
660 | } | |
95f2b820 | 661 | if (t0<-999) |
662 | { | |
663 | omx->SetDead("LE"); | |
664 | omx->SetDead("TOT"); | |
665 | omx->SetCalFunction(0,"LE"); | |
666 | omx->SetDecalFunction(0,"LE"); | |
667 | omx->SetCalFunction(0,"TOT"); | |
668 | omx->SetDecalFunction(0,"TOT"); | |
669 | } | |
670 | ||
671 | // Set the TWRDaq (de)calibration function parameters for the good OMs | |
672 | fcal=omx->GetCalFunction("ADC"); | |
673 | fdecal=omx->GetDecalFunction("ADC"); | |
674 | if (fcal) | |
675 | { | |
9c52fc9b | 676 | fcal->SetParameter(0,ncpe); |
95f2b820 | 677 | } |
678 | if (fdecal) | |
679 | { | |
9c52fc9b | 680 | fdecal->SetParameter(0,ncpe); |
95f2b820 | 681 | } |
682 | ||
683 | fcal=omx->GetCalFunction("LE"); | |
684 | fdecal=omx->GetDecalFunction("LE"); | |
685 | if (fcal) | |
686 | { | |
687 | fcal->SetParameter(0,t0); | |
688 | } | |
689 | if (fdecal) | |
690 | { | |
691 | fdecal->SetParameter(0,t0); | |
692 | } | |
693 | ||
694 | fcal=omx->GetCalFunction("TOT"); | |
695 | fdecal=omx->GetDecalFunction("TOT"); | |
696 | if (fcal) | |
697 | { | |
698 | fcal->SetParameter(0,1); | |
699 | } | |
700 | if (fdecal) | |
701 | { | |
702 | fdecal->SetParameter(0,1); | |
703 | } | |
704 | ||
705 | fTWRDaqdb->EnterObject(jmod,1,omx); | |
706 | ||
707 | } // End of reading loop | |
708 | ||
709 | fInput.close(); | |
216d1d91 | 710 | } |
711 | /////////////////////////////////////////////////////////////////////////// |