coverity fix
[u/mrichter/AliRoot.git] / TPC / AliTPCComposedCorrection.cxx
CommitLineData
0116859c 1
2/**************************************************************************
3 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * *
5 * Author: The ALICE Off-line Project. *
6 * Contributors are mentioned in the code where appropriate. *
7 * *
8 * Permission to use, copy, modify and distribute this software and its *
9 * documentation strictly for non-commercial purposes is hereby granted *
10 * without fee, provided that the above copyright notice appears in all *
11 * copies and that both the copyright notice and this permission notice *
12 * appear in the supporting documentation. The authors make no claims *
13 * about the suitability of this software for any purpose. It is *
14 * provided "as is" without express or implied warranty. *
15 **************************************************************************/
16
17////////////////////////////////////////////////////////////////////////////////
18// //
19// AliTPCComposedCorrection class //
20// //
21// This class is creating a correction that is composed out of smaller //
22// corrections. //
23// There are two ways the sub-corrections can be combined into this one: //
24// 1. kParallel: All corrections are applied at the given position x and //
25// the dx terms are summed up (this commutes). //
26// 2. kQueue: The corrections are called in order. The first one at the //
27// given position x resulting in dx1, the second one is called at //
28// the corrected position (x+dx1) resulting in dx2, the third one //
29// is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+... //
30// is returned. //
31// For the inverse of the correction this is taken into account by reversing //
32// the order the corrections are applied in the kQueue case (no issue for //
33// kParallel). //
34// //
35// date: 27/04/2010 //
36// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas //
37// //
38// Example usage: //
39// //
40// AliMagF mag("mag","mag"); //
41// AliTPCExBBShape exb; // B field shape distortions //
42// exb.SetBField(&mag); //
43// //
44// AliTPCExBTwist twist; // ExB Twist distortions //
45// twist.SetXTwist(0.001); //
46// //
47// TObjArray cs; cs.Add(&exb); cs.Add(&twist); //
48// //
49// AliTPCComposedCorrection cc; //
50// cc.SetCorrections(&cs); //
51// cc.SetOmegaTauT1T2(wt,T1,T2); //
52// cc.Print("DA"); //
53// cc.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2"); //
54////////////////////////////////////////////////////////////////////////////////
55
56
57#include <TCollection.h>
e527a1b9 58#include <TTimeStamp.h>
b1f0a2a5 59#include <TIterator.h>
c9cbd2f2 60#include "AliLog.h"
0116859c 61
62#include "AliTPCComposedCorrection.h"
63
64
65AliTPCComposedCorrection::AliTPCComposedCorrection()
66 : AliTPCCorrection("composed_correction",
67 "composition of corrections"),
68 fCorrections(0),
cfe2c39a 69 fMode(kParallel),
70 fWeights(0) // weights of corrections
0116859c 71{
72 //
73 // default constructor
74 //
75}
76
77AliTPCComposedCorrection::AliTPCComposedCorrection(TCollection *corrections,
78 AliTPCComposedCorrection::CompositionType mode)
79 : AliTPCCorrection("composed_correction",
80 "composition of corrections"),
81 fCorrections(corrections),
cfe2c39a 82 fMode(mode),
83 fWeights(0) //weights of correction
0116859c 84{
85 //
86 // Constructor that defines the set of corrections, this one is composed of.
87 //
88}
89
90AliTPCComposedCorrection::~AliTPCComposedCorrection() {
91 //
c9cbd2f2 92 // destructor
0116859c 93 //
c9cbd2f2 94 if (!fCorrections) {
95 AliInfo("No Correction-models were set: can not delete them");
96 } else {
97 TIterator *i=fCorrections->MakeIterator();
98 AliTPCCorrection *c;
99 while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) {
100 delete c;
101 }
102 delete i;
103 }
cfe2c39a 104 if (fWeights) delete fWeights;
0116859c 105}
106
107
108void AliTPCComposedCorrection::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
109 //
110 // This applies all correction and the specified manner (see general
111 // class description for details).
112 //
c9cbd2f2 113
114 if (!fCorrections) {
115 AliInfo("No Corrections-models were set: can not calculate distortions");
116 return;
117 }
cfe2c39a 118 TIterator *i=fCorrections->MakeIterator();
0116859c 119 AliTPCCorrection *c;
cfe2c39a 120 Int_t weightIndex=0;
0116859c 121 switch (fMode) {
122 case kParallel:
123 Float_t dxi[3];
124 for (int j=0;j<3;++j) dx[j]=0.;
125 while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) {
126 c->GetCorrection(x,roc,dxi);
cfe2c39a 127 Double_t w=1;
128 if (fWeights) w=(*fWeights)[weightIndex++];
129 for (Int_t j=0;j<3;++j) dx[j]+=w*dxi[j];
0116859c 130 }
131 break;
132 case kQueue:
133 Float_t xi[3];
134 for (Int_t j=0;j<3;++j) xi[j]=x[j];
135 while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) {
136 c->GetCorrection(xi,roc,dx);
cfe2c39a 137 Double_t w=1;
138 if (fWeights) w=(*fWeights)[weightIndex++];
139 for (Int_t j=0;j<3;++j) xi[j]+=w*dx[j];
0116859c 140 }
141 for (Int_t j=0;j<3;++j) dx[j]=xi[j]-x[j];
142 break;
143 }
144 delete i;
145}
146
147void AliTPCComposedCorrection::GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]) {
148 //
149 // This applies all distortions and the specified manner (see general
150 // class descxiption for details).
151 //
152
c9cbd2f2 153 if (!fCorrections) {
154 AliInfo("No Corrections-models were set: can not calculate distortions");
155 return;
156 }
0116859c 157 TIterator *i=fCorrections->MakeReverseIterator();
158 AliTPCCorrection *c;
cfe2c39a 159 Int_t weightIndex=0;
0116859c 160 switch (fMode) {
161 case kParallel:
162 Float_t dxi[3];
163 for (int j=0;j<3;++j) dx[j]=0.;
164 while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) {
165 c->GetDistortion(x,roc,dxi);
cfe2c39a 166 Double_t w=1;
167 if (fWeights) w=(*fWeights)[weightIndex++];
168 for (Int_t j=0;j<3;++j) dx[j]+=w*dxi[j];
0116859c 169 }
170 break;
171 case kQueue:
172 Float_t xi[3];
173 for (Int_t j=0;j<3;++j) xi[j]=x[j];
174 while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) {
175 c->GetDistortion(xi,roc,dx);
cfe2c39a 176 Double_t w=1;
177 if (fWeights) w=(*fWeights)[weightIndex++];
178 for (Int_t j=0;j<3;++j) xi[j]+=w*dx[j];
0116859c 179 }
180 for (Int_t j=0;j<3;++j) dx[j]=xi[j]-x[j];
181 break;
182 }
183 delete i;
184}
185
186
187void AliTPCComposedCorrection::Print(Option_t* option) const {
188 //
189 // Print function to check which correction classes are used
190 // option=="d" prints details regarding the setted magnitude
191 // option=="a" prints the C0 and C1 coefficents for calibration purposes
192 //
193
194 printf("Composed TPC spacepoint correction \"%s\" -- composed of:\n",GetTitle());
195 TString opt = option; opt.ToLower();
196 Int_t in=1;
c9cbd2f2 197 if (!fCorrections) {
198 printf(" - composed correction is empty!\n");
199 return;
200 }
0116859c 201 TIterator *i=fCorrections->MakeIterator();
202 AliTPCCorrection *c;
203 while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) {
204 if (opt.Contains("d")) {
0b736a46 205 printf("\n");
206 printf("%d. %s\t%s\n",in,c->GetTitle(), c->GetName());
0116859c 207 c->Print(option);
208 } else {
0b736a46 209 printf("%d. %s\t%s\n",in,c->GetTitle(), c->GetName());
0116859c 210 }
211 ++in;
212 }
e527a1b9 213 if (in==1) printf(" Info: The correction compound is empty: No corrections set\n");
0116859c 214 delete i;
215}
216
217
e527a1b9 218void AliTPCComposedCorrection::Init() {
219 //
220 // Initialization funtion (not used at the moment)
221 //
c9cbd2f2 222 if (!fCorrections) {
223 AliInfo("No Correction-models were set");
224 return;
225 }
e527a1b9 226 TIterator *i=fCorrections->MakeIterator();
227 AliTPCCorrection *c;
228 while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next())))
229 c->Init();
230 delete i;
231
232}
233
234void AliTPCComposedCorrection::Update(const TTimeStamp &timeStamp) {
235 //
236 // Update function
237 //
c9cbd2f2 238 if (!fCorrections) {
239 AliInfo("No Correction-models were set");
240 return;
241 }
e527a1b9 242
243 TIterator *i=fCorrections->MakeIterator();
244 AliTPCCorrection *c;
245 while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next())))
246 c->Update(timeStamp);
247 delete i;
248
249}
250
251
252
0116859c 253void AliTPCComposedCorrection::SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2) {
254 //
255 // Gives the possibility to set the OmegaTau plus Tensor corrections T1 and T2 (effective omega Tau)
256 // to each subcorrection (since they might become event specific due to changing drift velocity)
257 //
258 // The omegaTau comes idealy from the Database, since it is a function of drift velocity, B and E field
259 // e.g. omegaTau = -10.0 * Bz * vdrift / Ez ; // with Bz in kG and Ez in V/cm
260 // omegaTau = -0.325 for Bz=5kG, Ez=400V/cm and vdrift = 2.6cm/muSec
261 // The T1 and T2 tensors were measured in a dedicated calibration run
262 //
263 // Note: overwrites previously set values!
264 //
265
c9cbd2f2 266 if (!fCorrections) {
267 AliInfo("No Correction-models were set");
268 return;
269 }
270
0116859c 271 TIterator *i=fCorrections->MakeIterator();
272 AliTPCCorrection *c;
273 while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) {
274 c->SetOmegaTauT1T2(omegaTau,t1,t2);
275 }
276 delete i;
277}
278
279ClassImp(AliTPCComposedCorrection)