o Add option for residual distortion

o Fix warnings
o Add macro to create composed correction for residual distortions

diff --git a/TPC/Base/AliTPCComposedCorrection.cxx b/TPC/Base/AliTPCComposedCorrection.cxx
index e14f0e0..00804e6 100644 (file)
--- a/TPC/Base/AliTPCComposedCorrection.cxx
+++ b/TPC/Base/AliTPCComposedCorrection.cxx
@@ -28,6 +28,10 @@
 //    the corrected position (x+dx1) resulting in dx2, the third one          //
 //    is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+...     //
 //    is returned.                                                            //
+// 3. kQueueResidual: like kQueue with the exception that in case of          //
+//    a positive weight the 'Distortion' is called and in case of a negative  //
+//    weight the 'Correction' is called, where the absolute of the weight     //
+//    will be applied to the correction
 // For the inverse of the correction this is taken into account by reversing  //
 // the order the corrections are applied in the kQueue case (no issue for     //
 // kParallel).                                                                //
@@ -57,6 +61,7 @@
 #include <TCollection.h>
 #include <TTimeStamp.h>
 #include <TIterator.h>
+#include <TMath.h>
 #include "AliLog.h"
 
 #include "AliTPCComposedCorrection.h"
@@ -157,6 +162,12 @@ void AliTPCComposedCorrection::GetCorrection(const Float_t x[],const Short_t roc
     }
     for (Int_t j=0;j<3;++j) dx[j]=xi[j]-x[j];
     break;
+  case kQueueResidual:
+    //TODO: for the moment assume inverse of distortion
+    //      check if this is what is desired
+    GetDistortion(x,roc,dx);
+    for (Int_t j=0;j<3;++j) dx[j]*=-1.;
+    break;
   }
   delete i;
 }
@@ -171,6 +182,12 @@ void AliTPCComposedCorrection::GetDistortion(const Float_t x[],const Short_t roc
     AliInfo("No Corrections-models were set: can not calculate distortions");
     return;
   }
+  
+  if (fMode==kQueueResidual && !fWeights) {
+    AliInfo("kQueueResidual mode was selected but no weights were given. Switching to kQueue instead.");
+    fMode=kQueue;
+  }
+  
   TIterator *i=fCorrections->MakeReverseIterator();
   AliTPCCorrection *c;
   Int_t weightIndex=0;
@@ -196,6 +213,17 @@ void AliTPCComposedCorrection::GetDistortion(const Float_t x[],const Short_t roc
     }
     for (Int_t j=0;j<3;++j) dx[j]=xi[j]-x[j];
     break;
+  case kQueueResidual:
+    Float_t xi2[3];
+    for (Int_t j=0;j<3;++j) xi2[j]=x[j];
+    while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next()))) {
+      Double_t w=(*fWeights)[weightIndex++];
+      if (w>0) c->GetDistortion(xi2,roc,dx);
+      else c->GetCorrection(xi2,roc,dx);
+      for (Int_t j=0;j<3;++j) xi2[j]+=TMath::Abs(w)*dx[j];
+    }
+    for (Int_t j=0;j<3;++j) dx[j]=xi2[j]-x[j];
+    break;
   }
   delete i;
 }

diff --git a/TPC/Base/AliTPCComposedCorrection.h b/TPC/Base/AliTPCComposedCorrection.h
index fe6ecbd..4e6c0a8 100644 (file)
--- a/TPC/Base/AliTPCComposedCorrection.h
+++ b/TPC/Base/AliTPCComposedCorrection.h
@@ -34,7 +34,7 @@ class TTimeStamp;
 
 class AliTPCComposedCorrection : public AliTPCCorrection {
 public:
-  enum CompositionType {kParallel,kQueue};
+  enum CompositionType {kParallel,kQueue, kQueueResidual};
 
   AliTPCComposedCorrection();
   AliTPCComposedCorrection(TCollection *corrections,CompositionType mode);

diff --git a/TPC/Upgrade/AliToyMCEventGenerator.h b/TPC/Upgrade/AliToyMCEventGenerator.h
index eaad57e..828db48 100644 (file)
--- a/TPC/Upgrade/AliToyMCEventGenerator.h
+++ b/TPC/Upgrade/AliToyMCEventGenerator.h
@@ -10,6 +10,8 @@ class TObjArray;
 class AliTPCParam;
 class AliTPCCorrection;
 class AliTrackPointArray;
+class AliTrackPoint;
+class AliTPCclusterMI;
 
 class AliToyMCTrack;
 class AliToyMCEvent;

diff --git a/TPC/Upgrade/macros/GetComposedResidualDistortion.C b/TPC/Upgrade/macros/GetComposedResidualDistortion.C
new file mode 100644 (file)
index 0000000..a5c640b
--- /dev/null
+++ b/TPC/Upgrade/macros/GetComposedResidualDistortion.C
@@ -0,0 +1,45 @@
+#include <TString.h>
+#include <TVectorD.h>
+#include <TObjArray.h>
+#include <TFile.h>
+
+#include <AliTPCComposedCorrection.h>
+#include <AliTPCCorrectionLookupTable.h>
+
+#include <AliToyMCEventGenerator.h>
+
+
+AliTPCComposedCorrection* GetComposedResidualDistortion(TString fluctuationMap, TString averageMap, Bool_t rescale=kTRUE)
+{
+  //
+  //
+  //
+
+
+  TFile fFluct(fluctuationMap);
+  AliTPCCorrectionLookupTable *corrFluct = (AliTPCCorrectionLookupTable*)fFluct.Get("map");
+  fFluct.Close();
+
+  TFile fAverage(averageMap);
+  AliTPCCorrectionLookupTable *corrAverage = (AliTPCCorrectionLookupTable*)fAverage.Get("map");
+  fAverage.Close();
+
+  TObjArray *arrMaps = new TObjArray(2);
+  arrMaps->Add(corrFluct);   // distortion with the fluctuation Map
+  arrMaps->Add(corrAverage); // correction with the average Map
+
+  // create the composed correction
+  // if the weight are set to +1 and -1, the first map will be responsible for the distortions
+  // The second map for the corrections
+  AliTPCComposedCorrection *residualDistortion = new AliTPCComposedCorrection(arrMaps, AliTPCComposedCorrection::kQueueResidual);
+  TVectorD weights(2);
+  weights(0)=+1.;
+  weights(1)=-1.;
+  if (rescale) {
+    Float_t dummy=0;
+    weights(1)=-AliToyMCEventGenerator::GetSCScalingFactor(corrFluct, corrAverage,dummy);
+  }
+  residualDistortion->SetWeights(&weights);
+
+  return residualDistortion;
+}