]>
Commit | Line | Data |
---|---|---|
a4b77ddf | 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 IceCalibrate | |
20 | // TTask derived class to perform the various calibrations. | |
21 | // | |
22 | // This task takes the current event in memory and uses the attached | |
23 | // OM database to access the various calibration functions. | |
24 | // A specific OM database may be attached by means of the SetOMdbase() | |
25 | // or SetCalibFile() memberfunctions. | |
26 | // Further details about the OM database can be found in the docs | |
27 | // of IceCal2Root. | |
28 | // | |
29 | // In the calibration procedure, all event data in memory is scanned and | |
30 | // replaced by calibrated data if a calibration function is present. | |
31 | // When data is succesfully calibrated, the corresponding de-calibration | |
32 | // function is stored in the event data at the appropriate place to allow | |
33 | // access to uncalibrated data as well (see AliSignal::GetSignal for | |
34 | // further details). | |
35 | // When the input event in memory already contained calibrated data | |
36 | // (i.e. de-calibration functions are present in the event data), the event | |
37 | // data is first de-calibrated (using the corresponding de-calibration functions | |
38 | // contained in the event data) before the new calibration is performed. | |
39 | // In case no corresponding calibration function is present, the calibration | |
40 | // of those specific data will not be performed. | |
41 | // This implies that running this task on calibrated data without having | |
42 | // attached an OM database, will result in fully de-calibrated data. | |
43 | // In case an OM slot was flagged as bad in the OM database, this flag | |
44 | // will be copied into the event data for the corresponding OM. | |
45 | // | |
46 | //--- Author: Nick van Eijndhoven 18-sep-2005 Utrecht University | |
47 | //- Modified: NvE $Date$ Utrecht University | |
48 | /////////////////////////////////////////////////////////////////////////// | |
49 | ||
50 | #include "IceCalibrate.h" | |
51 | #include "Riostream.h" | |
52 | ||
53 | ClassImp(IceCalibrate) // Class implementation to enable ROOT I/O | |
54 | ||
55 | IceCalibrate::IceCalibrate(const char* name,const char* title) : TTask(name,title) | |
56 | { | |
57 | // Default constructor. | |
58 | fCalfile=0; | |
59 | fOmdb=0; | |
60 | } | |
61 | /////////////////////////////////////////////////////////////////////////// | |
62 | IceCalibrate::~IceCalibrate() | |
63 | { | |
64 | // Default destructor. | |
65 | if (fCalfile) | |
66 | { | |
67 | delete fCalfile; | |
68 | fCalfile=0; | |
69 | } | |
70 | } | |
71 | /////////////////////////////////////////////////////////////////////////// | |
72 | void IceCalibrate::SetOMdbase(AliObjMatrix* omdb) | |
73 | { | |
74 | // Set the pointer to the OM database. | |
75 | // Note : this will overrule a previously attached database. | |
76 | fOmdb=omdb; | |
77 | } | |
78 | /////////////////////////////////////////////////////////////////////////// | |
79 | void IceCalibrate::SetCalibFile(TString name) | |
80 | { | |
81 | // Set the calibration ROOT file as created with IceCal2Root. | |
82 | // Note : this will overrule a previously attached database. | |
83 | fCalfile=new TFile(name.Data()); | |
84 | if (fCalfile) | |
85 | { | |
27e6d856 | 86 | fOmdb=(AliObjMatrix*)fCalfile->Get("Cal-OMDBASE"); |
a4b77ddf | 87 | } |
88 | } | |
89 | /////////////////////////////////////////////////////////////////////////// | |
90 | void IceCalibrate::Exec(Option_t* opt) | |
91 | { | |
92 | // Implementation of the various calibration procedures. | |
93 | ||
94 | TString name=opt; | |
95 | AliJob* parent=(AliJob*)(gROOT->GetListOfTasks()->FindObject(name.Data())); | |
96 | ||
97 | if (!parent) return; | |
98 | ||
99 | IceEvent* evt=(IceEvent*)parent->GetObject("IceEvent"); | |
100 | if (!evt) return; | |
101 | ||
102 | IceGOM* ome=0; // The event OM pointer | |
103 | IceGOM* omd=0; // The database OM pointer | |
104 | Int_t id=0; | |
105 | Float_t sig=0; | |
106 | Float_t sigc=0; | |
107 | TF1* fcal=0; | |
108 | TF1* fdecal=0; | |
109 | ||
110 | Int_t ndev=evt->GetNdevices(); | |
111 | for (Int_t idev=1; idev<=ndev; idev++) | |
112 | { | |
113 | ome=(IceGOM*)evt->GetDevice(idev); | |
114 | if (!ome) continue; | |
115 | ||
116 | id=ome->GetUniqueID(); | |
117 | ||
118 | omd=0; | |
119 | if (fOmdb) omd=(IceGOM*)fOmdb->GetObject(id,1); | |
120 | ||
121 | // Set global OM constants | |
122 | if (omd) | |
123 | { | |
e51b7d1a | 124 | ome->SetPosition((Ali3Vector&)omd->GetPosition()); |
a4b77ddf | 125 | for (Int_t isd=4; isd<17; isd++) |
126 | { | |
127 | ome->SetSignal(omd->GetSignal(isd),isd); | |
128 | } | |
129 | } | |
130 | else | |
131 | { | |
132 | for (Int_t ise=8; ise<17; ise++) | |
133 | { | |
134 | ome->SetSignal(0,ise); | |
135 | } | |
136 | ome->SetSignal(1,8); | |
137 | ome->SetSignal(1,12); | |
138 | ome->SetSignal(1,15); | |
139 | } | |
140 | ||
141 | // Make signals of bad modules available | |
142 | ome->SetAlive("ADC"); | |
143 | ome->SetAlive("LE"); | |
144 | ome->SetAlive("TOT"); | |
145 | ||
146 | // (De)calibrate all hit signals for this OM | |
147 | for (Int_t ithit=1; ithit<=ome->GetNhits(); ithit++) | |
148 | { | |
149 | AliSignal* sx=ome->GetHit(ithit); | |
150 | if (!sx) continue; | |
151 | ||
152 | // ADC (de)calibration | |
153 | sig=sx->GetSignal("ADC",-7); // Get uncalibrated signal | |
154 | fcal=0; | |
155 | fdecal=0; | |
156 | if (omd) | |
157 | { | |
158 | fcal=omd->GetCalFunction("ADC"); | |
159 | fdecal=omd->GetDecalFunction("ADC"); | |
160 | } | |
161 | if (fcal) // Store calibrated signal | |
162 | { | |
163 | sigc=fcal->Eval(sig); | |
164 | sx->SetSignal(sigc,"ADC"); | |
165 | ome->SetCalFunction(0,"ADC"); | |
166 | ome->SetDecalFunction(fdecal,"ADC"); | |
167 | } | |
168 | else // Store uncalibrated signal | |
169 | { | |
170 | sx->SetSignal(sig,"ADC"); | |
171 | ome->SetCalFunction(fcal,"ADC"); | |
172 | ome->SetDecalFunction(0,"ADC"); | |
173 | } | |
174 | ||
175 | // LE (TDC) (de)calibration | |
176 | sig=sx->GetSignal("LE",-7); // Get uncalibrated signal | |
177 | fcal=0; | |
178 | fdecal=0; | |
179 | if (omd) | |
180 | { | |
181 | fcal=omd->GetCalFunction("LE"); | |
182 | fdecal=omd->GetDecalFunction("LE"); | |
183 | } | |
184 | // Store the ADC independent (de)calibration function in the OM | |
185 | if (fcal) | |
186 | { | |
187 | ome->SetCalFunction(0,"LE"); | |
188 | ome->SetDecalFunction(fdecal,"LE"); | |
189 | } | |
190 | else | |
191 | { | |
192 | ome->SetCalFunction(fcal,"LE"); | |
193 | ome->SetDecalFunction(0,"LE"); | |
194 | } | |
195 | // Store the hit-specific ADC dependent (de)calibration function in the hit itself | |
196 | sx->SetCalFunction(fcal,"LE"); | |
197 | sx->SetDecalFunction(fdecal,"LE"); | |
198 | fcal=sx->GetCalFunction("LE"); | |
199 | fdecal=sx->GetDecalFunction("LE"); | |
200 | sigc=sx->GetSignal("ADC",-7); | |
201 | if (sigc>0) | |
202 | { | |
203 | if (fcal) fcal->SetParameter(3,sigc); | |
204 | if (fdecal) fdecal->SetParameter(3,sigc); | |
205 | } | |
206 | else | |
207 | { | |
208 | if (fcal) fcal->SetParameter(3,1.e20); | |
209 | if (fdecal) fdecal->SetParameter(3,1.e20); | |
210 | } | |
211 | if (fcal) // Store calibrated signal | |
212 | { | |
213 | sigc=fcal->Eval(sig); | |
214 | sx->SetSignal(sigc,"LE"); | |
215 | sx->SetCalFunction(0,"LE"); | |
216 | sx->SetDecalFunction(fdecal,"LE"); | |
217 | } | |
218 | else // Store uncalibrated signal | |
219 | { | |
220 | sx->SetSignal(sig,"LE"); | |
221 | sx->SetCalFunction(fcal,"LE"); | |
222 | sx->SetDecalFunction(0,"LE"); | |
223 | } | |
224 | ||
225 | // TOT (de)calibration | |
226 | sig=sx->GetSignal("TOT",-7); // Get uncalibrated signal | |
227 | fcal=0; | |
228 | fdecal=0; | |
229 | if (omd) | |
230 | { | |
231 | fcal=omd->GetCalFunction("TOT"); | |
232 | fdecal=omd->GetDecalFunction("TOT"); | |
233 | } | |
234 | if (fcal) // Store calibrated signal | |
235 | { | |
236 | sigc=fcal->Eval(sig); | |
237 | sx->SetSignal(sigc,"TOT"); | |
238 | ome->SetCalFunction(0,"TOT"); | |
239 | ome->SetDecalFunction(fdecal,"TOT"); | |
240 | } | |
241 | else // Store uncalibrated signal | |
242 | { | |
243 | sx->SetSignal(sig,"TOT"); | |
244 | ome->SetCalFunction(fcal,"TOT"); | |
245 | ome->SetDecalFunction(0,"TOT"); | |
246 | } | |
247 | } | |
248 | ||
249 | if (omd) | |
250 | { | |
251 | if (omd->GetDeadValue("ADC")) ome->SetDead("ADC"); | |
252 | if (omd->GetDeadValue("LE")) ome->SetDead("LE"); | |
253 | if (omd->GetDeadValue("TOT")) ome->SetDead("TOT"); | |
254 | } | |
255 | } | |
256 | } | |
257 | /////////////////////////////////////////////////////////////////////////// |