]>
Commit | Line | Data |
---|---|---|
1 | /************************************************************************** | |
2 | * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line 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. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | /* History of cvs commits: | |
16 | * | |
17 | * $Log$ | |
18 | * Revision 1.3 2007/10/16 14:36:39 pavlinov | |
19 | * fixed code violation (almost) | |
20 | * | |
21 | * Revision 1.2 2007/09/11 19:38:15 pavlinov | |
22 | * added pi0 calibration, linearity, shower profile | |
23 | * co: warning: `$Log' is obsolescent; use ` * $Log'. | |
24 | * Revision 1.1 2007/08/08 15:58:01 hristov | |
25 | */ | |
26 | ||
27 | ||
28 | //_________________________________________________________________________ | |
29 | // Calibration coefficients | |
30 | // The place for holding all information after calibration | |
31 | // - not only calibration coefficients. | |
32 | // For flash Adc we should keep at least ratio of high/low gains | |
33 | // | |
34 | //*-- Author: Aleksei Pavlinov (WSU, Detroit, USA) | |
35 | ||
36 | #include "AliEMCALCalibCoefs.h" | |
37 | ||
38 | #include "AliRun.h" | |
39 | #include "AliEMCALCalibData.h" | |
40 | #include "AliCDBMetaData.h" | |
41 | #include "AliCDBId.h" | |
42 | #include "AliCDBEntry.h" | |
43 | #include "AliCDBManager.h" | |
44 | #include "AliCDBStorage.h" | |
45 | #include "AliEMCALGeometry.h" | |
46 | ||
47 | #include "TH1F.h" | |
48 | #include <TString.h> | |
49 | ||
50 | ClassImp(AliEMCALCalibCoef) | |
51 | // ---------------------------------------------------------------------- | |
52 | AliEMCALCalibCoef::AliEMCALCalibCoef() : fAbsId(-1), fCc(-1), fECc(-1) | |
53 | { | |
54 | // default constructor | |
55 | } | |
56 | ||
57 | // ---------------------------------------------------------------------- | |
58 | AliEMCALCalibCoef::AliEMCALCalibCoef(const Int_t id, const Double_t c, const Double_t ec) : | |
59 | fAbsId(id), fCc(c), fECc(ec) | |
60 | { | |
61 | // Oct 16, 2007 | |
62 | } | |
63 | ||
64 | ||
65 | ClassImp(AliEMCALCalibCoefs) | |
66 | ||
67 | // ---------------------------------------------------------------------- | |
68 | AliEMCALCalibCoefs::AliEMCALCalibCoefs() : TNamed("",""), fTable(0), fCurrentInd(0), fCalibMethod(0) | |
69 | { | |
70 | // default constructor | |
71 | } | |
72 | ||
73 | // ---------------------------------------------------------------------- | |
74 | AliEMCALCalibCoefs::AliEMCALCalibCoefs(const AliEMCALCalibCoefs& coefs) | |
75 | : TNamed(coefs), fTable(coefs.fTable), | |
76 | fCurrentInd(coefs.fCurrentInd), fCalibMethod(coefs.fCalibMethod) | |
77 | { | |
78 | // copy constructor | |
79 | } | |
80 | ||
81 | // ---------------------------------------------------------------------- | |
82 | AliEMCALCalibCoefs::AliEMCALCalibCoefs(const char* name, const Int_t nrow) : TNamed(name,"table of cell information") , fTable(0), fCurrentInd(0), fCalibMethod(0) | |
83 | { | |
84 | // Oct 16, 2007 | |
85 | fTable = new TObjArray(nrow); | |
86 | } | |
87 | ||
88 | // ---------------------------------------------------------------------- | |
89 | void AliEMCALCalibCoefs::AddAt(AliEMCALCalibCoef* r) | |
90 | { | |
91 | // Oct 16, 2007 | |
92 | (*fTable)[fCurrentInd] = new AliEMCALCalibCoef(*r); | |
93 | fCurrentInd++; | |
94 | } | |
95 | ||
96 | // ---------------------------------------------------------------------- | |
97 | AliEMCALCalibCoefs::~AliEMCALCalibCoefs() | |
98 | { | |
99 | // Destructor | |
100 | if(fTable) { | |
101 | fTable->Delete(); | |
102 | delete fTable; | |
103 | } | |
104 | } | |
105 | ||
106 | // ---------------------------------------------------------------------- | |
107 | AliEMCALCalibCoef* AliEMCALCalibCoefs::GetTable(Int_t i) const | |
108 | { | |
109 | // Oct 16, 2007 | |
110 | return (AliEMCALCalibCoef*)fTable->At(i); | |
111 | } | |
112 | ||
113 | // ---------------------------------------------------------------------- | |
114 | // Get initial Calib Data from DB | |
115 | AliEMCALCalibCoefs* AliEMCALCalibCoefs::GetCalibTableFromDb(const char *tn, AliEMCALCalibData **calData) | |
116 | { | |
117 | // | |
118 | // See ~/macros/ALICE/sim.C for choice of CDB | |
119 | // Get calib. table which was used than calculated rec.points | |
120 | // | |
121 | static char *calibType = "EMCAL/Calib/*"; | |
122 | static char *calibTypeData = "EMCAL/Calib/Data"; | |
123 | // Initial cc | |
124 | calData[0] = 0; | |
125 | ||
126 | AliCDBManager* man = AliCDBManager::Instance(); | |
127 | AliCDBStorage* specificStorage = man->GetSpecificStorage(calibType); | |
128 | ||
129 | AliEMCALCalibData* caldata = (AliEMCALCalibData*) | |
130 | specificStorage->Get(calibTypeData, gAlice->GetRunNumber())->GetObject(); | |
131 | if(caldata == 0) return 0; | |
132 | ||
133 | AliEMCALGeometry *g = AliEMCALGeometry::GetInstance(); | |
134 | ||
135 | AliEMCALCalibCoefs *tab = new AliEMCALCalibCoefs(tn,g->GetNCells()); | |
136 | tab->SetCalibMethod(AliEMCALCalibCoefs::kMC); | |
137 | ||
138 | for(Int_t id=0; id<g->GetNCells(); id++){ | |
139 | Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0, iphiCell=0, ietaCell=0; | |
140 | g->GetCellIndex(id, nSupMod, nModule, nIphi, nIeta); | |
141 | g->GetCellPhiEtaIndexInSModule(nSupMod, nModule, nIphi, nIeta, iphiCell, ietaCell); | |
142 | ||
143 | AliEMCALCalibCoef r; | |
144 | r.fAbsId = id; | |
145 | r.fCc = caldata->GetADCchannel(nSupMod, ietaCell, iphiCell); // column(ietaCell) : row(iphiCell) | |
146 | r.fECc = 0.0; | |
147 | ||
148 | tab->AddAt(&r); | |
149 | } | |
150 | // tab->Purge(); | |
151 | tab->SetCalibMethod(AliEMCALCalibCoefs::kPI0); | |
152 | calData[0] = caldata; | |
153 | ||
154 | printf("\n <I> AliEMCALCalibCoefs::GetCalibTableFromDb \n name |%s| title |%s| | storage |%s|\n", | |
155 | caldata->GetName(), caldata->GetTitle(), specificStorage->GetURI().Data()); | |
156 | ||
157 | return tab; | |
158 | } | |
159 | ||
160 | // ---------------------------------------------------------------------- | |
161 | TH1F* AliEMCALCalibCoefs::GetHistOfCalibTableFromDb(const char *tn) | |
162 | { | |
163 | // First SM only | |
164 | AliEMCALCalibData *calData[1]; // unused here | |
165 | ||
166 | AliEMCALCalibCoefs* tab = GetCalibTableFromDb(tn, calData); | |
167 | if(tab==0) return 0; | |
168 | ||
169 | TH1F *h = new TH1F("hCCfirst", " fCc first (in MeV)", 70, 12., 19.); | |
170 | AliEMCALCalibCoef *r; | |
171 | for(Int_t i=0; i<tab->GetSize(); i++){ | |
172 | r = tab->GetTable(i); | |
173 | if(i>=1152) break; | |
174 | h->Fill(r->fCc*1000.); // GEV ->MeV | |
175 | } | |
176 | delete tab; | |
177 | return h; | |
178 | } | |
179 | ||
180 | // ---------------------------------------------------------------------- | |
181 | AliEMCALCalibData* AliEMCALCalibCoefs::GetCalibTableForDb(const AliEMCALCalibCoefs *tab, const char* dbLocation, | |
182 | const char* coment) | |
183 | { | |
184 | // See EMCAL/macros/CalibrationDB/AliEMCALSetCDB.C | |
185 | // Define and save to CDB | |
186 | printf("<I> AliEMCALCalibCoefs::GetCalibTableForDb started \n"); | |
187 | AliEMCALCalibData* caldata=0; | |
188 | if(tab==0) return caldata; | |
189 | ||
190 | Int_t firstRun = 0; | |
191 | Int_t lastRun = 10; | |
192 | Int_t beamPeriod = 1; | |
193 | char* objFormat = ""; | |
194 | caldata = new AliEMCALCalibData("EMCAL"); | |
195 | caldata->SetTitle(coment); | |
196 | ||
197 | AliEMCALGeometry *g = AliEMCALGeometry::GetInstance(); | |
198 | ||
199 | for(int id=0; id<tab->GetSize(); id++){ | |
200 | Float_t ped=0.; | |
201 | ||
202 | Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0, iphiCell=0, ietaCell=0; | |
203 | g->GetCellIndex(id, nSupMod, nModule, nIphi, nIeta); | |
204 | g->GetCellPhiEtaIndexInSModule(nSupMod, nModule, nIphi, nIeta, iphiCell, ietaCell); | |
205 | ||
206 | AliEMCALCalibCoef *r = tab->GetTable(id); | |
207 | // ietaCell - column; iphiCell - row | |
208 | caldata->SetADCchannel (nSupMod, ietaCell, iphiCell, r->fCc); | |
209 | caldata->SetADCpedestal(nSupMod, ietaCell, iphiCell, ped); | |
210 | } | |
211 | printf("<I> Fill AliEMCALCalibData table \n"); | |
212 | //Store calibration data into database | |
213 | ||
214 | AliCDBMetaData md; | |
215 | md.SetComment(objFormat); | |
216 | md.SetBeamPeriod(beamPeriod); | |
217 | md.SetResponsible("Aleksei Pavlinov"); | |
218 | ||
219 | AliCDBManager* man = AliCDBManager::Instance(); | |
220 | if(man == 0) { | |
221 | printf("<E> AliEMCALCalibCoefs::GetCalibTableForDb : define AliCDBManager, NO saving !! \n"); | |
222 | } else { | |
223 | printf("<I> AliCDBManager %p \n", man); | |
224 | AliCDBId id("EMCAL/Calib/Data",firstRun,lastRun); // create in EMCAL/Calib/Data DBFolder | |
225 | TString dBFolder(dbLocation); | |
226 | AliCDBStorage* loc = man->GetStorage(dBFolder.Data()); | |
227 | loc->Put(caldata, id, &md); | |
228 | } | |
229 | ||
230 | return caldata; | |
231 | } | |
232 | ||
233 | // ---------------------------------------------------------------------- | |
234 | AliEMCALCalibCoef *AliEMCALCalibCoefs::GetRow(const int absId) | |
235 | { | |
236 | // Oct 16, 2007 | |
237 | AliEMCALCalibCoef *r=0; | |
238 | for(int id=0; id<fTable->GetSize(); id++){ | |
239 | r = GetTable(id); | |
240 | if(r->fAbsId == absId) return r; | |
241 | } | |
242 | return 0; | |
243 | } | |
244 | ||
245 | // ---------------------------------------------------------------------- | |
246 | void AliEMCALCalibCoefs::PrintTable() | |
247 | { | |
248 | // Oct 16, 2007 | |
249 | printf(" Table : %s : nrows %i \n", GetName(), int(fTable->GetSize())); | |
250 | for(int i=0; i<fTable->GetSize(); i++) PrintTable(i); | |
251 | } | |
252 | ||
253 | // ---------------------------------------------------------------------- | |
254 | void AliEMCALCalibCoefs::PrintTable(const Int_t i) | |
255 | { | |
256 | // Oct 16, 2007 | |
257 | if(i>=fTable->GetSize()) return; | |
258 | printf("row %i \n", i); | |
259 | PrintRec(GetTable(i)); | |
260 | } | |
261 | ||
262 | // ---------------------------------------------------------------------- | |
263 | void AliEMCALCalibCoefs::PrintRec(AliEMCALCalibCoef* r) | |
264 | { | |
265 | // Oct 16, 2007 | |
266 | if(r==0) return; | |
267 | printf(" abs Id %5.5i fCc %7.6f fECc %7.6f \n", r->fAbsId, r->fCc, r->fECc); | |
268 | } |