TPC/AliTPCComposedCorrection.cxx

   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>
  58 #include <TTimeStamp.h>
  59 #include <TIterator.h>
  60 #include "AliLog.h"
  61
  62 #include "AliTPCComposedCorrection.h"
  63
  64
  65 AliTPCComposedCorrection::AliTPCComposedCorrection()
  66   : AliTPCCorrection("composed_correction",
  67                      "composition of corrections"),
  68     fCorrections(0),
  69     fMode(kParallel),
  70     fWeights(0)  // weights of corrections
  71 {
  72   //
  73   // default constructor
  74   //
  75 }
  76
  77 AliTPCComposedCorrection::AliTPCComposedCorrection(TCollection *corrections,
  78                                                    AliTPCComposedCorrection::CompositionType mode)
  79   : AliTPCCorrection("composed_correction",
  80                      "composition of corrections"),
  81     fCorrections(corrections),
  82     fMode(mode),
  83     fWeights(0) //weights of correction
  84 {
  85   //
  86   // Constructor that defines the set of corrections, this one is composed of.
  87   //
  88 }
  89
  90 AliTPCComposedCorrection::~AliTPCComposedCorrection() {
  91   //
  92   // destructor
  93   //
  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   }
 104   if (fWeights) delete fWeights;
 105 }
 106
 107
 108 void 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   //
 113
 114   if (!fCorrections) {
 115     AliInfo("No Corrections-models were set: can not calculate distortions");
 116     return;
 117   }
 118   TIterator *i=fCorrections->MakeIterator();
 119   AliTPCCorrection *c;
 120   Int_t weightIndex=0;
 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);
 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];
 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);
 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];
 140     }
 141     for (Int_t j=0;j<3;++j) dx[j]=xi[j]-x[j];
 142     break;
 143   }
 144   delete i;
 145 }
 146
 147 void 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
 153   if (!fCorrections) {
 154     AliInfo("No Corrections-models were set: can not calculate distortions");
 155     return;
 156   }
 157   TIterator *i=fCorrections->MakeReverseIterator();
 158   AliTPCCorrection *c;
 159   Int_t weightIndex=0;
 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);
 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];
 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);
 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];
 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
 187 void 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;
 197   if (!fCorrections) {
 198     printf("   - composed correction is empty!\n");
 199     return;
 200   }
 201   TIterator *i=fCorrections->MakeIterator();
 202   AliTPCCorrection *c;
 203   while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) {
 204     if (opt.Contains("d")) {
 205       printf("\n");
 206       printf("%d. %s\t%s\n",in,c->GetTitle(), c->GetName());
 207       c->Print(option);
 208     } else {
 209       printf("%d. %s\t%s\n",in,c->GetTitle(), c->GetName());
 210     }
 211     ++in;
 212   }
 213   if (in==1) printf("  Info: The correction compound is empty: No corrections set\n");
 214   delete i;
 215 }
 216
 217
 218 void AliTPCComposedCorrection::Init() {
 219   //
 220   // Initialization funtion (not used at the moment)
 221   //
 222   if (!fCorrections) {
 223     AliInfo("No Correction-models were set");
 224     return;
 225   }
 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
 234 void AliTPCComposedCorrection::Update(const TTimeStamp &timeStamp) {
 235   //
 236   // Update function
 237   //
 238   if (!fCorrections) {
 239     AliInfo("No Correction-models were set");
 240     return;
 241   }
 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
 253 void 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
 266   if (!fCorrections) {
 267     AliInfo("No Correction-models were set");
 268     return;
 269   }
 270
 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
 279 ClassImp(AliTPCComposedCorrection)