- new gain calibb
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 29 Oct 2011 10:44:12 +0000 (10:44 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 29 Oct 2011 10:44:12 +0000 (10:44 +0000)
- alternative exb methode: being saved as OCDB object in TRD/Calib/ChamberExBAlt

15 files changed:
TRD/AliTRDCalibTask.cxx
TRD/AliTRDCalibTask.h
TRD/AliTRDCalibraExbAltFit.cxx [new file with mode: 0644]
TRD/AliTRDCalibraExbAltFit.h [new file with mode: 0644]
TRD/AliTRDCalibraFillHisto.cxx
TRD/AliTRDCalibraFillHisto.h
TRD/AliTRDCalibraFit.cxx
TRD/AliTRDCalibraFit.h
TRD/AliTRDCalibraVdriftLinearFit.h
TRD/AliTRDPreprocessorOffline.cxx
TRD/AliTRDPreprocessorOffline.h
TRD/AliTRDseedV1.cxx
TRD/AliTRDseedV1.h
TRD/CMakelibTRDbase.pkg
TRD/TRDbaseLinkDef.h

index c3db4b4..7e4f6cc 100644 (file)
@@ -71,6 +71,7 @@ using namespace std;
 #include "AliTRDCalibraVector.h"
 #include "AliTRDCalibraFillHisto.h"
 #include "AliTRDCalibraVdriftLinearFit.h" 
+#include "AliTRDCalibraExbAltFit.h" 
 
 #include "AliTRDcalibDB.h"
 #include "AliCDBId.h"
@@ -123,6 +124,7 @@ ClassImp(AliTRDCalibTask)
       fHisto2d(kTRUE),
       fVector2d(kFALSE),
       fVdriftLinear(kTRUE),
+      fExbAlt(kFALSE),
       fNbTimeBins(0),
       fSelectedTrigger(new TObjArray()),
       fRejected(kTRUE),
@@ -264,6 +266,7 @@ void AliTRDCalibTask::UserCreateOutputObjects()
     fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
     fTRDCalibraFillHisto->SetLinearFitterOn(fVdriftLinear); // Other possibility vdrift VDRIFT
     fTRDCalibraFillHisto->SetLinearFitterDebugOn(fVdriftLinear); // Other possibility vdrift
+    fTRDCalibraFillHisto->SetExbAltFitOn(fExbAlt); // Alternative method for exb
     for(Int_t k = 0; k < 3; k++){
       if(((fNz[k] != 10) && (fNrphi[k] != 10)) && ((fNz[k] != 100) && (fNrphi[k] != 100))) {
        fTRDCalibraFillHisto->SetNz(k,fNz[k]);                                    // Mode calibration
@@ -300,7 +303,8 @@ void AliTRDCalibTask::UserCreateOutputObjects()
       fListHist->Add(fTRDCalibraFillHisto->GetPRF2d());
     } 
     if(fVdriftLinear) fListHist->Add((TObject *)fTRDCalibraFillHisto->GetVdriftLinearFit());
-    if(fVector2d) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector  
+    if(fVector2d) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector
+    if(fExbAlt) fListHist->Add((TObject *)fTRDCalibraFillHisto->GetExbAltFit());
   }
   fRelativeScale = fTRDCalibraFillHisto->GetRelativeScale(); // Get the relative scale for the gain
   
@@ -1004,6 +1008,7 @@ void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
   TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject(Form("PH2dSM_%s",(const char*)calibTask->GetName()));
   
   AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) listcalibTask->FindObject("AliTRDCalibraVdriftLinearFit");  
+  AliTRDCalibraExbAltFit *exbaltfit = (AliTRDCalibraExbAltFit *) listcalibTask->FindObject("AliTRDCalibraExbAltFit");  
   AliTRDCalibraVector *calibraVector = (AliTRDCalibraVector *) listcalibTask->FindObject("AliTRDCalibraVector");  
 
   //
@@ -1043,6 +1048,7 @@ void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
   TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject(Form("PH2dSM_%s",(const char*)fName));
   
   AliTRDCalibraVdriftLinearFit *ilinearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");  
+  AliTRDCalibraExbAltFit *iexbaltfit = (AliTRDCalibraExbAltFit *) fListHist->FindObject("AliTRDCalibraExbAltFit");
   AliTRDCalibraVector *icalibraVector = (AliTRDCalibraVector *) fListHist->FindObject("AliTRDCalibraVector");  
 
 
@@ -1258,7 +1264,15 @@ void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
       ilinearfit = new AliTRDCalibraVdriftLinearFit(*linearfit);
       fListHist->Add(ilinearfit);
     }
-  }
+  } 
+
+  if(exbaltfit) {
+    if(iexbaltfit) iexbaltfit->Add(exbaltfit);
+    else {
+      iexbaltfit = new AliTRDCalibraExbAltFit(*exbaltfit);
+      fListHist->Add(iexbaltfit);
+    }
+  } 
 
   if(calibraVector) {
     if(icalibraVector) icalibraVector->Add(calibraVector);
index 0d691bd..ed82a49 100644 (file)
@@ -54,6 +54,7 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   void SetHisto2d(Bool_t histo2d)                                   {fHisto2d=histo2d;};
   void SetVector2d(Bool_t vector2d)                                 {fVector2d=vector2d;};
   void SetVdriftLinear(Bool_t vdriftLinear)                         {fVdriftLinear = vdriftLinear;};
+  void SetExbAlt(Bool_t exbalt)                                     {fExbAlt = exbalt;};
   void SetNbTimeBins(Int_t nbTimeBins)                              {fNbTimeBins=nbTimeBins;};  
   
   void SetNz(Short_t nz, Int_t i)                                      {fNz[i]=nz;};
@@ -141,6 +142,7 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   Bool_t      fHisto2d;                          // histo
   Bool_t      fVector2d;                         // vector
   Bool_t      fVdriftLinear;                     // vdrift Linear
+  Bool_t      fExbAlt;                           // alternative exb calculation
 
   Int_t       fNbTimeBins;                       // number of timebins 
 
diff --git a/TRD/AliTRDCalibraExbAltFit.cxx b/TRD/AliTRDCalibraExbAltFit.cxx
new file mode 100644 (file)
index 0000000..cd7207d
--- /dev/null
@@ -0,0 +1,387 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id: AliTRDCalibraExbAltFit.cxx 46327 2011-01-10 13:29:56Z cblume $ */
+
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+// AliTRDCalibraExbAltFit                                                 //
+//                                                                        //
+// Does the ExB calibration by applying a quadratic fit                   //
+//                                                                        //
+// Author:                                                                //
+//   R. Bailhache (R.Bailhache@gsi.de)                                    //
+//                                                                        //
+////////////////////////////////////////////////////////////////////////////
+
+//Root includes
+#include <TObjArray.h>
+#include <TH2F.h>
+#include <TString.h>
+#include <TVectorD.h>
+#include <TAxis.h>
+#include <TLinearFitter.h>
+#include <TMath.h>
+#include <TTreeStream.h>
+
+
+//header file
+#include "AliTRDCalibraExbAltFit.h"
+
+ClassImp(AliTRDCalibraExbAltFit) /*FOLD00*/
+
+//_____________________________________________________________________
+AliTRDCalibraExbAltFit::AliTRDCalibraExbAltFit() : /*FOLD00*/
+  TObject(),
+  fVersion(0),
+  fFitterHistoArray(540),
+  fFitterPArray(540),
+  fFitterEArray(540)
+{
+  //
+  // default constructor
+  //
+}
+//_____________________________________________________________________
+AliTRDCalibraExbAltFit::AliTRDCalibraExbAltFit(const AliTRDCalibraExbAltFit &ped) : /*FOLD00*/
+  TObject(ped),
+  fVersion(ped.fVersion),
+  fFitterHistoArray(540),
+  fFitterPArray(540),
+  fFitterEArray(540)
+{
+    //
+    // copy constructor
+    //
+  for (Int_t idet = 0; idet < 540; idet++){
+   
+    const TVectorD     *vectorE     = (TVectorD*)ped.fFitterEArray.UncheckedAt(idet);
+    const TVectorD     *vectorP     = (TVectorD*)ped.fFitterPArray.UncheckedAt(idet);
+    const TH2S         *hped        = (TH2S*)ped.fFitterHistoArray.UncheckedAt(idet);
+    
+    if ( vectorE != 0x0 ) fFitterEArray.AddAt(new TVectorD(*vectorE), idet);
+    if ( vectorP != 0x0 ) fFitterPArray.AddAt(new TVectorD(*vectorP), idet);
+    if ( hped != 0x0 ){
+      TH2S *hNew = (TH2S *)hped->Clone();
+      //hNew->SetDirectory(0);
+      fFitterHistoArray.AddAt(hNew,idet);
+    }
+  }
+}
+//_____________________________________________________________________
+AliTRDCalibraExbAltFit::AliTRDCalibraExbAltFit(const TObjArray &obja) : /*FOLD00*/
+  TObject(),
+  fVersion(0),
+  fFitterHistoArray(540),
+  fFitterPArray(540),
+  fFitterEArray(540)
+{
+  //
+  // constructor from a TObjArray
+  //
+  for (Int_t idet = 0; idet < 540; idet++){
+    const TH2S         *hped        = (TH2S*)obja.UncheckedAt(idet);
+    if ( hped != 0x0 ){
+      TH2S *hNew = (TH2S *)hped->Clone();
+      //hNew->SetDirectory(0);
+      fFitterHistoArray.AddAt(hNew,idet);
+    }
+  }
+}
+//_____________________________________________________________________
+AliTRDCalibraExbAltFit& AliTRDCalibraExbAltFit::operator = (const  AliTRDCalibraExbAltFit &source)
+{
+  //
+  // assignment operator
+  //
+  if (&source == this) return *this;
+  new (this) AliTRDCalibraExbAltFit(source);
+
+  return *this;
+}
+//_____________________________________________________________________
+AliTRDCalibraExbAltFit::~AliTRDCalibraExbAltFit() /*FOLD00*/
+{
+  //
+  // destructor
+  //
+  fFitterHistoArray.SetOwner();
+  fFitterPArray.SetOwner();
+  fFitterEArray.SetOwner();
+
+  fFitterHistoArray.Delete();
+  fFitterPArray.Delete();
+  fFitterEArray.Delete();
+
+}
+//_____________________________________________________________________________
+void AliTRDCalibraExbAltFit::Copy(TObject &c) const
+{
+  //
+  // Copy function
+  //
+
+  AliTRDCalibraExbAltFit& target = (AliTRDCalibraExbAltFit &) c;
+
+  // Copy only the histos
+  for (Int_t idet = 0; idet < 540; idet++){
+    if(fFitterHistoArray.UncheckedAt(idet)){
+      TH2S *hped1 = (TH2S *)target.GetFitterHisto(idet,kTRUE);
+      //hped1->SetDirectory(0);
+      hped1->Add((const TH2S *)fFitterHistoArray.UncheckedAt(idet));
+    }
+  }
+  
+  TObject::Copy(c);
+
+}
+//_____________________________________________________________________________
+Long64_t AliTRDCalibraExbAltFit::Merge(const TCollection* list) 
+{
+  // Merge list of objects (needed by PROOF)
+
+  if (!list)
+    return 0;
+  
+  if (list->IsEmpty())
+    return 1;
+  
+  TIterator* iter = list->MakeIterator();
+  TObject* obj = 0;
+  
+  // collection of generated histograms
+  Int_t count=0;
+  while((obj = iter->Next()) != 0) 
+    {
+      AliTRDCalibraExbAltFit* entry = dynamic_cast<AliTRDCalibraExbAltFit*>(obj);
+      if (entry == 0) continue; 
+      
+      // Copy only the histos
+      for (Int_t idet = 0; idet < 540; idet++){
+       if(entry->GetFitterHisto(idet)){
+         TH2S *hped1 = (TH2S *)GetFitterHisto(idet,kTRUE);
+         Double_t entriesa = hped1->GetEntries();
+         Double_t entriesb = ((TH2S *)entry->GetFitterHisto(idet))->GetEntries();
+         if((entriesa + entriesb) < 5*32767) hped1->Add(entry->GetFitterHisto(idet));
+       }
+      }
+      
+      count++;
+    }
+  
+  return count;
+}
+//_____________________________________________________________________
+void AliTRDCalibraExbAltFit::Add(const AliTRDCalibraExbAltFit *ped)
+{
+  //
+  // Add histo
+  //
+
+  fVersion++;
+
+  for (Int_t idet = 0; idet < 540; idet++){
+    const TH2S         *hped        = (TH2S*)ped->GetFitterHistoNoForce(idet);
+    //printf("idet %d\n",idet);
+    if ( hped != 0x0 ){
+      //printf("add\n");
+      TH2S *hped1 = (TH2S *)GetFitterHisto(idet,kTRUE);
+      Double_t entriesa = hped1->GetEntries();
+      Double_t entriesb = hped->GetEntries();
+      if((entriesa + entriesb) < 5*32767) hped1->Add(hped);
+    }
+  }
+}
+//______________________________________________________________________________________
+TH2S* AliTRDCalibraExbAltFit::GetFitterHisto(Int_t detector, Bool_t force)
+{
+    //
+    // return pointer to TH2F histo 
+    // if force is true create a new histo if it doesn't exist allready
+    //
+    if ( !force || fFitterHistoArray.UncheckedAt(detector) )
+       return (TH2S*)fFitterHistoArray.UncheckedAt(detector);
+
+    return GetFitterHistoForce(detector);
+
+}
+//______________________________________________________________________________________
+TH2S* AliTRDCalibraExbAltFit::GetFitterHistoForce(Int_t detector)
+{
+  //
+  // return pointer to TH2F histo 
+  // if NULL create a new histo if it doesn't exist allready
+  //
+  if (fFitterHistoArray.UncheckedAt(detector))
+    return (TH2S*)fFitterHistoArray.UncheckedAt(detector);
+  
+  // if we are forced and TLinearFitter doesn't yes exist create it
+  
+  // new TH2F
+  TString name("LFEXB");
+  name += detector;
+  name += "version";
+  name +=  fVersion;
+  
+  TH2S *lfdv = new TH2S((const Char_t *)name,(const Char_t *) name,
+                       30, -TMath::DegToRad()*45, TMath::DegToRad()*45, 
+                       30, 0.3, 1.4);
+  lfdv->SetXTitle("tan(phi_{track})");
+  lfdv->SetYTitle("rms");
+  lfdv->SetZTitle("Number of tracklets");
+  lfdv->SetStats(0);
+  lfdv->SetDirectory(0);
+  
+  fFitterHistoArray.AddAt(lfdv,detector);
+  return lfdv;
+}
+//______________________________________________________________________________________
+Bool_t AliTRDCalibraExbAltFit::GetParam(Int_t detector, TVectorD *param)
+{
+    //
+    // return param for this detector
+    //
+  if ( fFitterPArray.UncheckedAt(detector) ){
+    const TVectorD     *vectorP     = (TVectorD*)fFitterPArray.UncheckedAt(detector);
+    if(!param) param = new TVectorD(vectorP->GetNoElements());
+    for(Int_t k = 0; k < vectorP->GetNoElements(); k++){
+      (*param)[k] = (*vectorP)[k];
+    }
+    return kTRUE;
+  }
+  else return kFALSE;
+
+}
+//______________________________________________________________________________________
+Bool_t AliTRDCalibraExbAltFit::GetError(Int_t detector, TVectorD *error)
+{
+    //
+    // return error for this detector 
+    //
+  if ( fFitterEArray.UncheckedAt(detector) ){
+    const TVectorD     *vectorE     = (TVectorD*)fFitterEArray.UncheckedAt(detector);
+    if(!error) error = new TVectorD(vectorE->GetNoElements());
+    for(Int_t k = 0; k < vectorE->GetNoElements(); k++){
+      (*error)[k] = (*vectorE)[k];
+    }
+    return kTRUE;
+  }
+  else return kFALSE;
+
+}
+//______________________________________________________________________________________
+void AliTRDCalibraExbAltFit::Update(Int_t detector, Float_t tnp, Float_t pars1)
+{
+    //
+    // Fill the 2D histos for debugging
+    //
+  
+  TH2S *h = ((TH2S *) GetFitterHisto(detector,kTRUE));
+  Double_t nbentries = h->GetEntries();
+  if(nbentries < 5*32767) h->Fill(tnp,pars1);
+
+}
+//____________Functions fit Online CH2d________________________________________
+void AliTRDCalibraExbAltFit::FillPEArray()
+{
+  //
+  // Fill fFitterPArray and fFitterEArray from inside
+  //
+
+  
+  Int_t *arrayI = new Int_t[540];
+  for(Int_t k = 0; k< 540; k++){
+    arrayI[k] = 0; 
+  }
+
+  // Loop over histos 
+  for(Int_t cb = 0; cb < 540; cb++){
+    const TH2S *fitterhisto = (TH2S*)fFitterHistoArray.UncheckedAt(cb);
+    //printf("Processing the detector cb %d we find %d\n",cb, (Bool_t) fitterhisto);    
+
+    if ( fitterhisto != 0 ){
+      
+      // Fill a fitter
+      TAxis *xaxis = fitterhisto->GetXaxis();
+      TAxis *yaxis = fitterhisto->GetYaxis();
+      TLinearFitter fitter = TLinearFitter(3,"pol2");
+      //printf("test\n");
+      Double_t integral = fitterhisto->Integral();
+      //printf("Integral is %f\n",integral);
+      Bool_t securitybreaking = kFALSE;
+      if(TMath::Abs(integral-1199) < 0.00001) securitybreaking = kTRUE;
+      for(Int_t ibinx = 0; ibinx < fitterhisto->GetNbinsX(); ibinx++){
+       for(Int_t ibiny = 0; ibiny < fitterhisto->GetNbinsY(); ibiny++){
+         if(fitterhisto->GetBinContent(ibinx+1,ibiny+1)>0){
+           Double_t x = xaxis->GetBinCenter(ibinx+1);
+           Double_t y = yaxis->GetBinCenter(ibiny+1);
+           
+           for(Int_t k = 0; k < (Int_t)fitterhisto->GetBinContent(ibinx+1,ibiny+1); k++){
+             if(!securitybreaking){
+               fitter.AddPoint(&x,y);
+               arrayI[cb]++;
+             }
+             else {
+               if(arrayI[cb]< 1198){
+                 fitter.AddPoint(&x,y);
+                 arrayI[cb]++; 
+               }
+             }
+           }
+           
+         }
+       }
+      }
+      
+      //printf("Find %d entries for the detector %d\n",arrayI[cb],cb);
+
+      // Eval the  fitter
+      if(arrayI[cb]>15){
+       TVectorD  *par  = new TVectorD(3);
+       TVectorD  pare = TVectorD(2);
+       TVectorD  *parE = new TVectorD(3);
+       //printf("Fit\n");
+       if((fitter.EvalRobust(0.8)==0)) {
+         //if((fitter.Eval()==0)) {
+         //printf("Take the param\n");
+         fitter.GetParameters(*par);
+         //printf("Done\n");
+         //fitter.GetErrors(*pare);
+         //Float_t  ppointError =  TMath::Sqrt(TMath::Abs(fitter.GetChisquare())/arrayI[cb]);
+         //(*parE)[0] = pare[0]*ppointError;
+         //(*parE)[1] = pare[1]*ppointError;
+         (*parE)[0] = 0.0;
+         (*parE)[1] = 0.0;
+         (*parE)[2] = (Double_t) arrayI[cb];
+         fFitterPArray.AddAt(par,cb);
+         fFitterEArray.AddAt(parE,cb);
+         
+         //par->Print();
+         //parE->Print();
+       }
+       //printf("Finish\n");
+      }
+      
+      //delete fitterhisto;
+      
+    }// if something
+
+  }
+
+  delete [] arrayI;
+   
+}
+
+
diff --git a/TRD/AliTRDCalibraExbAltFit.h b/TRD/AliTRDCalibraExbAltFit.h
new file mode 100644 (file)
index 0000000..ce32255
--- /dev/null
@@ -0,0 +1,65 @@
+#ifndef ALITRDCALIBRAEXBALTFIT_H
+#define ALITRDCALIBRAEXBALTFIT_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id: AliTRDCalibraExbAltFit.h 46327 2011-01-10 13:29:56Z cblume $ */
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+//  TRD calibration class for online calibration                             //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+//#include "TObjArray.h"
+#include "TObject.h"
+
+//class TVectorD;
+class TObjArray;
+class TH2S;
+class TTreeSRedirector;
+
+class AliTRDCalibraExbAltFit : public TObject {
+
+ public:
+
+  AliTRDCalibraExbAltFit();
+  AliTRDCalibraExbAltFit(const AliTRDCalibraExbAltFit &ped);
+  AliTRDCalibraExbAltFit(const TObjArray &obja);
+  virtual ~AliTRDCalibraExbAltFit();
+  virtual Long64_t Merge(const TCollection* list);
+  virtual void Copy(TObject &c) const;
+
+  AliTRDCalibraExbAltFit& operator = (const  AliTRDCalibraExbAltFit &source);
+
+  void            Update(Int_t detector, Float_t tnp, Float_t pars1);
+  void            FillPEArray();
+  void            Add(const AliTRDCalibraExbAltFit *ped);
+  TH2S           *GetFitterHisto(Int_t detector, Bool_t force=kFALSE);
+  TH2S           *GetFitterHistoForce(Int_t detector);
+  TH2S           *GetFitterHistoNoForce(Int_t detector) const   { return (TH2S*)fFitterHistoArray.UncheckedAt(detector);};
+  Bool_t          GetParam(Int_t detector, TVectorD *param);
+  Bool_t          GetError(Int_t detector, TVectorD *error);
+
+  TObjArray      *GetPArray()                    { return &fFitterPArray;       };
+  TObjArray      *GetEArray()                    { return &fFitterEArray;       };
+  TObjArray       GetHistoArray() const          { return fFitterHistoArray;    };
+
+ private:
+   
+  Int_t           fVersion;                 // Version of the object
+
+  TObjArray       fFitterHistoArray;  // TObjArray of histo2D for debugging  Fitters
+  TObjArray       fFitterPArray;      // Array of result parameters from  fitters for the detectors
+  TObjArray       fFitterEArray;      // Array of result errors from  fitters for the detectors
+
+  
+  ClassDef(AliTRDCalibraExbAltFit,1)  // Online ExB Calibration
+
+};
+
+
+
+#endif
+
index b869adf..f6c05ae 100644 (file)
@@ -57,6 +57,7 @@
 #include "AliTRDCalibraMode.h"
 #include "AliTRDCalibraVector.h"
 #include "AliTRDCalibraVdriftLinearFit.h"
+#include "AliTRDCalibraExbAltFit.h"
 #include "AliTRDcalibDB.h"
 #include "AliTRDCommonParam.h"
 #include "AliTRDpadPlane.h"
@@ -65,6 +66,7 @@
 #include "AliRawReader.h"
 #include "AliRawReaderDate.h"
 #include "AliTRDgeometry.h"
+#include "AliTRDfeeParam.h"
 #include "./Cal/AliTRDCalROC.h"
 #include "./Cal/AliTRDCalPad.h"
 #include "./Cal/AliTRDCalDet.h"
@@ -138,6 +140,7 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
   ,fVector2d(kFALSE)
   ,fLinearFitterOn(kFALSE)
   ,fLinearFitterDebugOn(kFALSE)
+  ,fExbAltFitOn(kFALSE)
   ,fRelativeScale(0)
   ,fThresholdClusterPRF2(15.0)
   ,fLimitChargeIntegration(kFALSE)
@@ -190,6 +193,7 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
   ,fCH2d(0x0)
   ,fLinearFitterArray(540)
   ,fLinearVdriftFit(0x0)
+  ,fExbAltFit(0x0)
   ,fCalDetGain(0x0)
   ,fCalROCGain(0x0)
 {
@@ -223,6 +227,7 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
   ,fVector2d(c.fVector2d)
   ,fLinearFitterOn(c.fLinearFitterOn)
   ,fLinearFitterDebugOn(c.fLinearFitterDebugOn)
+  ,fExbAltFitOn(c.fExbAltFitOn)
   ,fRelativeScale(c.fRelativeScale)
   ,fThresholdClusterPRF2(c.fThresholdClusterPRF2)
   ,fLimitChargeIntegration(c.fLimitChargeIntegration)
@@ -275,6 +280,7 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
   ,fCH2d(0x0)
   ,fLinearFitterArray(540)
   ,fLinearVdriftFit(0x0)
+  ,fExbAltFit(0x0)
   ,fCalDetGain(0x0)
   ,fCalROCGain(0x0)
 {
@@ -298,6 +304,9 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
   if(c.fLinearVdriftFit){
     fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit(*c.fLinearVdriftFit);
   }
+  if(c.fExbAltFit){
+    fExbAltFit = new AliTRDCalibraExbAltFit(*c.fExbAltFit);
+  }
 
   if(c.fCalDetGain)  fCalDetGain   = new AliTRDCalDet(*c.fCalDetGain);
   if(c.fCalROCGain)  fCalROCGain   = new AliTRDCalROC(*c.fCalROCGain);
@@ -341,6 +350,7 @@ AliTRDCalibraFillHisto::~AliTRDCalibraFillHisto()
     if(f) { delete f;}
   }
   if(fLinearVdriftFit) delete fLinearVdriftFit;
+  if(fExbAltFit) delete fExbAltFit;
   if (fGeo) {
     delete fGeo;
   }
@@ -521,6 +531,9 @@ Bool_t AliTRDCalibraFillHisto::Init2Dhistos(Int_t nboftimebin)
     nameee += "Nz";
     fLinearVdriftFit->SetNameCalibUsed(nameee); 
   }
+  if(fExbAltFitOn){
+    fExbAltFit = new AliTRDCalibraExbAltFit();
+  }
 
   if (fPRF2dOn) {
 
@@ -726,7 +739,7 @@ Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
       // Add the charge if shared cluster
       cls = tracklet->GetClusters(jc+AliTRDseedV1::kNtb);
       //
-      StoreInfoCHPHtrack(cl, tracklet->GetdQdl(jc),group,row,col,cls);
+      StoreInfoCHPHtrack(cl, tracklet->GetQperTB(jc),group,row,col,cls); //tracklet->GetdQdl(jc)
     }
     
     ////////////////////////////////////////
@@ -823,8 +836,24 @@ Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *track
   //////////////////////////////////
   // Loop clusters
   //////////////////////////////////
+
+  Short_t sigArr[AliTRDfeeParam::GetNcol()];
+  memset(sigArr, 0, AliTRDfeeParam::GetNcol()*sizeof(sigArr[0]));
+  Int_t ncl=0, tbf=0, tbl=0;
+
   for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
     if(!(cl = tracklet->GetClusters(ic))) continue;
+
+    if(!tbf) tbf=ic;
+    tbl=ic;
+    ncl++;
+    Int_t col = cl->GetPadCol();
+    for(int ip=-1, jp=2; jp<5; ip++, jp++){
+      Int_t idx=col+ip;
+      if(idx<0 || idx>=AliTRDfeeParam::GetNcol()) continue;
+      sigArr[idx]+=cl->GetSignals()[jp];
+    }
+
     if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
     
     Double_t ycluster                 = cl->GetY();
@@ -856,13 +885,36 @@ Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *track
   dydt        = pars[1]; 
   //printf("chis %f, nbli %d, pointError %f, parError %f, errorpar %f\n",fLinearFitterTracklet->GetChisquare(),nbli,pointError,fLinearFitterTracklet->GetParError(1),errorpar);
   fLinearFitterTracklet->ClearPoints();  
+
+  ////////////////////////////////////
+  // Calc the projection of the clusters on the y direction
+  ///////////////////////////////////
+
+  Float_t signalSum(0.);
+  Float_t mean = -1, rms = -1;
+  Float_t dydx = tracklet->GetYref(1), tilt = tracklet->GetTilt(); // ,dzdx = tracklet->GetZref(1); (identical to the previous definition!)
+  Float_t dz = dzdx*(tbl-tbf)/10;
+  if(ncl>10){
+    for(Int_t ip(0); ip<AliTRDfeeParam::GetNcol(); ip++){
+      signalSum+=sigArr[ip]; 
+      mean+=ip*sigArr[ip];
+    } 
+    mean/=signalSum;
+  
+    for(Int_t ip = 0; ip<AliTRDfeeParam::GetNcol(); ip++) 
+      rms+=sigArr[ip]*(ip-mean)*(ip-mean);
+    rms = TMath::Sqrt(rms/signalSum);
+    
+    rms -= TMath::Abs(dz*tilt);
+    dydx -= dzdx*tilt;
+  }
  
   ////////////////////////////////
   // Debug stuff
   /////////////////////////////// 
 
 
-  if(fDebugLevel > 0){
+  //if(fDebugLevel > 0){
     if ( !fDebugStreamer ) {
       //debug stream
       TDirectory *backup = gDirectory;
@@ -870,7 +922,8 @@ Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *track
       if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
     } 
     
-
+    float xcoord = tnp-dzdx*tnt;
+    float pt = tracklet->GetPt();
     Int_t layer = GetLayer(fDetectorPreviousTrack);
            
     (* fDebugStreamer) << "FindP1TrackPHtrackletV1"<<
@@ -888,9 +941,16 @@ Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *track
       "crossrow="<<crossrow<<
       "errorpar="<<errorpar<<
       "pointError="<<pointError<<
+      "xcoord="<<xcoord<<
+      "pt="<<pt<<
+      "rms="<<rms<<
+      "dydx="<<dydx<<
+      "dz="<<dz<<
+      "tilt="<<tilt<<
+      "ncl="<<ncl<<
       "\n";
 
-  }
+    //}
   
   /////////////////////////
   // Cuts quality
@@ -916,6 +976,9 @@ Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *track
       fLinearVdriftFit->Update(fDetectorPreviousTrack,x,pars[1]);
     }
   }
+  if(fExbAltFitOn){
+    fExbAltFit->Update(fDetectorPreviousTrack,dydx,rms);
+  }
   
   return kTRUE;
 }
@@ -1521,7 +1584,7 @@ void AliTRDCalibraFillHisto::StoreInfoCHPHtrack(const AliTRDcluster *cl,const Do
   if(fIsHLT) correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack);
   else correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
   Float_t correction    = 1.0;
-  Float_t normalisation = 6.67;
+  Float_t normalisation = 1.13; //org: 6.67; 1st: 1.056; 2nd: 1.13;
   // we divide with gain in AliTRDclusterizer::Transform...
   if( correctthegain > 0 ) normalisation /= correctthegain;
 
index 9a44538..a6b2d72 100644 (file)
@@ -34,6 +34,7 @@ class AliRawReader;
 class AliTRDCalibraMode;
 class AliTRDCalibraVector;
 class AliTRDCalibraVdriftLinearFit;
+class AliTRDCalibraExbAltFit;
 class AliTRDcluster;
 class AliTRDtrackV1;
 class AliTRDseedV1;
@@ -98,6 +99,7 @@ class AliTRDCalibraFillHisto : public TObject {
           void     SetVector2d(Bool_t vector2d = kTRUE)                      { fVector2d        = vector2d;          }
          void     SetLinearFitterOn(Bool_t linearfitteron = kTRUE)          { fLinearFitterOn      = linearfitteron;}
          void     SetLinearFitterDebugOn(Bool_t debug = kTRUE)              { fLinearFitterDebugOn = debug;         }
+          void     SetExbAltFitOn(Bool_t fiton = kTRUE)                      { fExbAltFitOn      = fiton;}
          void     SetFirstRunGain(Int_t firstRunGain)                       { fFirstRunGain = firstRunGain;   }
          void     SetVersionGainUsed(Int_t versionGainUsed)                 { fVersionGainUsed = versionGainUsed;   }
          void     SetSubVersionGainUsed(Int_t subVersionGainUsed)           { fSubVersionGainUsed = subVersionGainUsed;   }
@@ -131,7 +133,8 @@ class AliTRDCalibraFillHisto : public TObject {
   TProfile2D      *GetPRF2d() const                                          { return fPRF2d;                  } 
   TObjArray        GetLinearFitterArray() const                              { return fLinearFitterArray;      }
   TLinearFitter   *GetLinearFitter(Int_t detector, Bool_t force=kFALSE);
-  AliTRDCalibraVdriftLinearFit *GetVdriftLinearFit() const                   { return fLinearVdriftFit;        }
+  AliTRDCalibraVdriftLinearFit *GetVdriftLinearFit() const                   { return fLinearVdriftFit; }
+  AliTRDCalibraExbAltFit *GetExbAltFit() const                               { return fExbAltFit; }
   
  
   // How to fill the 2D
@@ -198,6 +201,7 @@ AliTRDCalibraVector *GetCalibraVector() const                                { r
           Bool_t   fVector2d;               // Chose to fill vectors
          Bool_t   fLinearFitterOn;         // Method with linear fit for drift velocity
          Bool_t   fLinearFitterDebugOn;    // Method with linear fit for drift velocity
+          Bool_t   fExbAltFitOn;              // Enable parabolic fit for exb
 
   // How to fill the 2D
           Float_t  fRelativeScale;          // Scale of the deposited charge
@@ -275,6 +279,7 @@ AliTRDCalibraVector *GetCalibraVector() const                                { r
          TH2I            *fCH2d;                         // 2D deposited charge
          TObjArray       fLinearFitterArray;             // TObjArray of Linear Fitters for the detectors 
          AliTRDCalibraVdriftLinearFit *fLinearVdriftFit; // Info Linear Fit
+          AliTRDCalibraExbAltFit *fExbAltFit; // ExB parabolic fit (alternative to vdrift linear fit)
          
  // Current calib object: to correct for the database used
          AliTRDCalDet *fCalDetGain;                      // Current calib object gain
index 65037cc..d7837bc 100644 (file)
@@ -72,6 +72,7 @@
 #include "AliTRDCalibraMode.h"
 #include "AliTRDCalibraVector.h"
 #include "AliTRDCalibraVdriftLinearFit.h"
+#include "AliTRDCalibraExbAltFit.h"
 #include "AliTRDcalibDB.h"
 #include "AliTRDgeometry.h"
 #include "AliTRDpadPlane.h"
@@ -1286,6 +1287,77 @@ Bool_t AliTRDCalibraFit::AnalyseLinearFitters(AliTRDCalibraVdriftLinearFit *cali
   return kTRUE;
   
 }
+//______________________________________________________________________________________
+Bool_t AliTRDCalibraFit::AnalyseExbAltFit(AliTRDCalibraExbAltFit *calivdli)
+{
+  //
+  // The linear method
+  //
+
+  fStatisticMean        = 0.0;
+  fNumberFit            = 0;
+  fNumberFitSuccess     = 0;
+  fNumberEnt            = 0;
+  if(!InitFitExbAlt()) return kFALSE;
+
+  
+  for(Int_t idet = 0; idet < 540; idet++){
+
+
+    //printf("detector number %d\n",idet);
+
+    // Take the result
+    TVectorD param(3);
+    TVectorD error(3);
+    fEntriesCurrent = 0;
+    fCountDet       = idet;
+    Bool_t here     = calivdli->GetParam(idet,&param);
+    Bool_t heree    = calivdli->GetError(idet,&error);
+    //printf("here %d and heree %d\n",here, heree);
+    if(heree) {
+      fEntriesCurrent = (Int_t) error[2];
+      fNumberEnt++;
+    }
+    //printf("Number of entries %d\n",fEntriesCurrent);
+    // Nothing found or not enough statistic
+    if((!heree) || (!here) || (fEntriesCurrent <= fMinEntries)) {
+      NotEnoughStatisticExbAlt();
+      continue;
+    }
+    //param.Print();
+    //error.Print();
+    //Statistics
+    fNumberFit++;
+    fStatisticMean += fEntriesCurrent;
+
+    // Statistics   
+    fNumberFitSuccess ++;
+
+    // Put the fCurrentCoef
+    if(TMath::Abs(param[2])>0.0001){
+      fCurrentCoef2[0]  = -param[1]/2/param[2];
+      fCurrentCoefE2    = 0;//error[1];
+    }else{
+      fCurrentCoef2[0]  = 100;
+      fCurrentCoefE2    = 0;//error[1];
+    }
+    
+    // Fill
+    FillInfosFitExbAlt();
+    
+  }
+  // Mean Statistics
+  if (fNumberFit > 0) {
+    AliInfo(Form("There are %d with at least one entries. %d fits have been proceeded (sucessfully or not...). There is a mean statistic of: %d over these fitted histograms and %d successfulled fits",fNumberEnt, fNumberFit, (Int_t) fStatisticMean/fNumberFit,fNumberFitSuccess));
+  }
+  else {
+    AliInfo(Form("There are %d with at least one entries. There is no fit!",fNumberEnt));
+  }
+  delete fDebugStreamer;
+  fDebugStreamer = 0x0;
+  return kTRUE;
+  
+}
 //____________Functions fit Online CH2d________________________________________
 void AliTRDCalibraFit::AnalyseLinearFittersAllTogether(AliTRDCalibraVdriftLinearFit *calivdli, Double_t &vdriftoverall, Double_t &exboverall)
 {
@@ -2287,6 +2359,47 @@ AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectLorentzAngle(const TObjArray *vec
   
 }
 //_____________________________________________________________________________
+AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectExbAlt(const TObjArray *vectorFit)
+{
+  //
+  // It creates the AliTRDCalDet object from the AliTRDFitInfo2
+  // It takes the min value of the coefficients per detector 
+  // This object has to be written in the database
+  //
+  
+  // Create the DetObject
+  AliTRDCalDet *object = new AliTRDCalDet("tan(lorentzangle)","tan(lorentzangle) (detector value)");
+  
+  
+  Int_t loop = (Int_t) vectorFit->GetEntriesFast();
+  if(loop != 540) AliInfo("The Vector Fit is not complete!");
+  Int_t detector = -1;
+  Float_t value  = 0.0;
+
+  for (Int_t k = 0; k < loop; k++) {
+    detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
+    /*
+      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
+      Float_t min  = 100.0;
+      for (Int_t row = 0; row < rowMax; row++) {
+      for (Int_t col = 0; col < colMax; col++) {
+      value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
+      mean += -TMath::Abs(value);
+      count++;       
+      } // Col
+      } // Row
+      if(count > 0) mean = mean/count;
+    */
+    value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
+    //if(value > 70.0) value = value-100.0;
+    object->SetValue(detector,value);
+  }
+
+  return object;
+  
+}
+//_____________________________________________________________________________
 TObject *AliTRDCalibraFit::CreatePadObjectGain(const TObjArray *vectorFit, Double_t scaleFitFactor, const AliTRDCalDet *detobject)
 {
   //
@@ -2905,6 +3018,22 @@ Bool_t AliTRDCalibraFit::InitFitLinearFitter()
   return kTRUE;
 }
 //____________Functions for initialising the AliTRDCalibraFit in the code_________
+Bool_t AliTRDCalibraFit::InitFitExbAlt()
+{
+  //
+  // Init the fCalDet, fVectorFit fCurrentCoefDetector 
+  //
+  
+  gDirectory = gROOT;
+  fCurrentCoefDetector   = new Float_t[2304];
+  for (Int_t k = 0; k < 2304; k++) {
+    fCurrentCoefDetector2[k]  = 0.0;
+  }
+
+  return kTRUE;
+}
+//____________Functions for initialising the AliTRDCalibraFit in the code_________
 void AliTRDCalibraFit::InitfCountDetAndfCount(Int_t i)
 {
   //
@@ -3498,6 +3627,33 @@ Bool_t AliTRDCalibraFit::NotEnoughStatisticLinearFitter()
 }
 
 //____________Functions for initialising the AliTRDCalibraFit in the code_________
+Bool_t AliTRDCalibraFit::NotEnoughStatisticExbAlt()
+{
+  //
+  // For the case where there are not enough entries in the histograms
+  // of the calibration group, the value present in the choosen database
+  // will be put. A negativ sign enables to know that a fit was not possible.
+  //
+  
+  Int_t factor = 0;
+  if(GetStack(fCountDet) == 2) factor = 1728;
+  else factor = 2304;
+    
+    
+  // Fill the fCurrentCoefDetector
+  for (Int_t k = 0; k < factor; k++) {
+    fCurrentCoefDetector2[k] = 100.0;
+  }
+   
+  fCurrentCoef2[0] = 100.0;
+  fCurrentCoefE2 = 0.0; 
+  
+  FillFillExbAlt();
+    
+  return kTRUE;
+}
+
+//____________Functions for initialising the AliTRDCalibraFit in the code_________
 Bool_t AliTRDCalibraFit::FillInfosFitCH(Int_t idect)
 {
   //
@@ -3871,6 +4027,28 @@ Bool_t AliTRDCalibraFit::FillInfosFitLinearFitter()
   return kTRUE;
 
 }
+//____________Functions for initialising the AliTRDCalibraFit in the code_________
+Bool_t AliTRDCalibraFit::FillInfosFitExbAlt()
+{
+  //
+  // Fill the coefficients found with the fits or other
+  // methods from the Fit functions
+  //
+  
+  Int_t factor = 0;
+  if(GetStack(fCountDet) == 2) factor = 1728;
+  else factor = 2304; 
+  
+  // Pointer to the branch
+  for (Int_t k = 0; k < factor; k++) {
+    fCurrentCoefDetector2[k]  = fCurrentCoef2[0];
+  }
+  
+  FillFillExbAlt();
+  
+  return kTRUE;
+
+}
 //________________________________________________________________________________
 void AliTRDCalibraFit::FillFillCH(Int_t idect)
 {
@@ -4093,6 +4271,56 @@ void AliTRDCalibraFit::FillFillLinearFitter()
   }
   
 }
+//________________________________________________________________________________
+void AliTRDCalibraFit::FillFillExbAlt()
+{
+  //
+  // DebugStream and fVectorFit
+  //
+
+  // End of one detector
+  FillVectorFit2();
+  
+  
+  // Reset
+  for (Int_t k = 0; k < 2304; k++) {
+    fCurrentCoefDetector2[k]  = 0.0;
+  }
+  
+
+  if(fDebugLevel > 1){
+
+    if ( !fDebugStreamer ) {
+      //debug stream
+      TDirectory *backup = gDirectory;
+      fDebugStreamer = new TTreeSRedirector("TRDDebugFitExbAlt.root");
+      if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+    } 
+    
+    //Debug: comparaison of the different methods (okey for first time but not for iterative procedure)
+    AliTRDpadPlane *padplane = fGeo->GetPadPlane(GetLayer(fCountDet),GetStack(fCountDet));
+    Float_t rowmd            = (padplane->GetRow0()+padplane->GetRowEnd())/2.;
+    Float_t r                = AliTRDgeometry::GetTime0(GetLayer(fCountDet)); 
+    Float_t tiltangle        = padplane->GetTiltingAngle();
+    Int_t   detector         = fCountDet;
+    Int_t   stack            = GetStack(fCountDet);
+    Int_t   layer            = GetLayer(fCountDet);
+    Float_t vf               = fCurrentCoef2[0]; 
+    Float_t vfE              = fCurrentCoefE2;
+   
+    (* fDebugStreamer) << "FillFillLinearFitter"<<
+      "detector="<<detector<<
+      "stack="<<stack<<
+      "layer="<<layer<<
+      "rowmd="<<rowmd<<
+      "r="<<r<<
+      "tiltangle="<<tiltangle<<
+      "vf="<<vf<<
+      "vfE="<<vfE<<
+      "\n";  
+  }
+  
+}
 //
 //____________Calcul Coef Mean_________________________________________________
 //
index e4ba42d..d63230c 100644 (file)
@@ -37,6 +37,7 @@ class AliLog;
 class AliTRDCalibraMode;
 class AliTRDCalibraVector;
 class AliTRDCalibraVdriftLinearFit;
+class AliTRDCalibraExbAltFit;
 class AliTRDCalDet;
 class AliTRDCalROC;
 class AliTRDgeometry;
@@ -80,6 +81,7 @@ class AliTRDCalibraFit : public TObject {
   // Functions fit for vdrift/lorentzangle
   Bool_t   AnalyseLinearFitters(AliTRDCalibraVdriftLinearFit *calivdli);
   void     AnalyseLinearFittersAllTogether(AliTRDCalibraVdriftLinearFit *calivdli, Double_t &vdriftoverall, Double_t &exboverall);
+  Bool_t   AnalyseExbAltFit(AliTRDCalibraExbAltFit *calivdli);
   
   // Pad Calibration
   Bool_t   SetModeCalibration(TString name, Int_t i);
@@ -101,6 +103,7 @@ class AliTRDCalibraFit : public TObject {
   AliTRDCalDet *CreateDetObjectGain(const TObjArray *vectorFit, Bool_t meanOtherBefore=kTRUE, Double_t scaleFitFactor = 0.02431, Bool_t perdetector = kTRUE);
   AliTRDCalDet *CreateDetObjectT0(const TObjArray *vectorFit, Bool_t perdetector = kFALSE);
   AliTRDCalDet *CreateDetObjectLorentzAngle(const TObjArray *vectorFit);
+  AliTRDCalDet *CreateDetObjectExbAlt(const TObjArray *vectorFit);
   
   TObject      *CreatePadObjectGain(const TObjArray *vectorFit = 0, Double_t scaleFitFactor = 1.0, const AliTRDCalDet *detobject = 0);
   TObject      *CreatePadObjectVdrift(const TObjArray *vectorFit = 0, const AliTRDCalDet *detobject = 0);
@@ -276,23 +279,27 @@ class AliTRDCalibraFit : public TObject {
        Bool_t   InitFitPH();
        Bool_t   InitFitPRF();
        Bool_t   InitFitLinearFitter();
+       Bool_t   InitFitExbAlt();
        
        // Not enough Statistics
        Bool_t   NotEnoughStatisticCH(Int_t idect);
        Bool_t   NotEnoughStatisticPH(Int_t idect,Double_t nentries);
        Bool_t   NotEnoughStatisticPRF(Int_t idect);
        Bool_t   NotEnoughStatisticLinearFitter();
+       Bool_t   NotEnoughStatisticExbAlt();
        
        // Fill Infos Fit
        Bool_t   FillInfosFitCH(Int_t idect);
        Bool_t   FillInfosFitPH(Int_t idect,Double_t nentries);
        Bool_t   FillInfosFitPRF(Int_t idect);
        Bool_t   FillInfosFitLinearFitter();
+       Bool_t   FillInfosFitExbAlt();
        
        void     FillFillCH(Int_t idect);
        void     FillFillPH(Int_t idect,Double_t nentries);
        void     FillFillPRF(Int_t idect);
        void     FillFillLinearFitter();
+       void     FillFillExbAlt();
        
        Bool_t   FillVectorFit();
        Bool_t   FillVectorFit2();
index 44f236d..c068afc 100644 (file)
@@ -57,7 +57,6 @@ class AliTRDCalibraVdriftLinearFit : public TObject {
   TObjArray       fLinearFitterHistoArray;  // TObjArray of histo2D for debugging Linear Fitters
   TObjArray       fLinearFitterPArray;      // Array of result parameters from linear fitters for the detectors
   TObjArray       fLinearFitterEArray;      // Array of result errors from linear fitters for the detectors
-
   
   ClassDef(AliTRDCalibraVdriftLinearFit,2)  // Online Vdrift calibration
 
index a311c01..98901a1 100644 (file)
@@ -58,6 +58,7 @@
 #include "AliTRDCalibraMode.h"
 #include "AliTRDCalibraFit.h"
 #include "AliTRDCalibraVdriftLinearFit.h"
+#include "AliTRDCalibraExbAltFit.h"
 #include "AliTRDPreprocessorOffline.h"
 #include "AliTRDCalChamberStatus.h"
 #include "AliTRDCalibChamberStatus.h"
@@ -80,10 +81,11 @@ ClassImp(AliTRDPreprocessorOffline)
   fPRF2d(0x0),
   fSparse(0x0),
   fAliTRDCalibraVdriftLinearFit(0x0),
+  fAliTRDCalibraExbAltFit(0x0),
   fNEvents(0x0),
   fAbsoluteGain(0x0),
-  fPlots(new TObjArray(9)),
-  fCalibObjects(new TObjArray(9)),
+  fPlots(new TObjArray(kNumCalibObjs)),
+  fCalibObjects(new TObjArray(kNumCalibObjs)),
   fFirstRunGainUsed(0),
   fVersionGainUsed(0),
   fSubVersionGainUsed(0),
@@ -136,6 +138,7 @@ AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
   if(fPRF2d) delete fPRF2d;
   if(fSparse) delete fSparse;
   if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit;
+  if(fAliTRDCalibraExbAltFit) delete fAliTRDCalibraExbAltFit;
   if(fNEvents) delete fNEvents;
   if(fAbsoluteGain) delete fAbsoluteGain;
   if(fPlots) delete fPlots;
@@ -212,6 +215,41 @@ void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRun
   if(fExBValidated) UpdateOCDBExB(startRunNumber,endRunNumber,ocdbStorage);
   
 }
+//___________________________________________________________________________________________________________________
+
+void AliTRDPreprocessorOffline::CalibExbAlt(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
+  //
+  // make calibration of the drift velocity
+  // Input parameters:
+  //      file                             - the location of input file
+  //      startRunNumber, endRunNumber     - run validity period 
+  //      ocdbStorage                      - path to the OCDB storage
+  //                                       - if empty - local storage 'pwd' uesed
+  if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
+  //
+  // 1. Initialization 
+  //
+
+  //
+  // 2. extraction of the information
+  //
+  if(ReadExbAltFitGlobal(file)) AnalyzeExbAltFit();
+  //
+  // 3. Append QA plots
+  //
+  //MakeDefaultPlots(fVdriftArray,fVdriftArray);
+  //
+  //
+  // 4. validate OCDB entries
+  //
+  //
+  // 5. update of OCDB
+  //
+  //
+  UpdateOCDBExBAlt(startRunNumber,endRunNumber,ocdbStorage);
+  
+}
+
 //_________________________________________________________________________________________________________________
 
 void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
@@ -234,7 +272,7 @@ void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumb
   //
   AnalyzeGain();
   if(fBackCorrectGain) CorrectFromDetGainUsed();
-  if(fBackCorrectVdrift) CorrectFromDetVdriftUsed();
+  //if(fBackCorrectVdrift) CorrectFromDetVdriftUsed();
   //
   // 3. Append QA plots
   //
@@ -477,6 +515,28 @@ Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileNa
   
 }
 //_____________________________________________________________________________________________________________
+Bool_t AliTRDPreprocessorOffline::ReadExbAltFitGlobal(const Char_t* fileName){
+  //
+  // read calibration entries from file
+  // 
+  if(fAliTRDCalibraExbAltFit) return kTRUE;
+  TFile fcalib(fileName);
+  TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
+  if (array){
+    fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) array->FindObject("AliTRDCalibraExbAltFit");
+    //fNEvents = (TH1I *) array->FindObject("NEvents");
+  }else{
+    fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) fcalib.Get("AliTRDCalibraExbAltFit");
+    //fNEvents = (TH1I *) fcalib.Get("NEvents");
+  }
+  if(!fAliTRDCalibraExbAltFit) {
+    //printf("No AliTRDCalibraExbAltFit\n");
+    return kFALSE;
+  }
+  return kTRUE;
+  
+}
+//_____________________________________________________________________________________________________________
 
 Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
   //
@@ -729,6 +789,52 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
 }
 //________________________________________________________________________________________________________________
 
+Bool_t AliTRDPreprocessorOffline::AnalyzeExbAltFit(){
+  //
+  // Analyze vdrift linear fit - produce the calibration objects
+  //
+
+  //printf("Analyse linear fit\n");
+
+  
+  AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
+  calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
+  //printf("Fill PE Array\n");
+  fAliTRDCalibraExbAltFit->FillPEArray();
+  //printf("AliTRDCalibraFit\n");
+  calibra->AnalyseExbAltFit(fAliTRDCalibraExbAltFit);
+  //printf("After\n");
+
+  //Int_t nbtg        = 540;
+  Int_t nbfit       = calibra->GetNumberFit();
+  Int_t nbE         = calibra->GetNumberEnt();
+
+  
+  Bool_t ok = kFALSE;
+  // enough statistics
+  if ((nbfit        >= 0.5*nbE) && (nbE > 30)) {
+    // create the cal objects
+    //calibra->RemoveOutliers(1,kTRUE);
+    calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
+    //
+    TObjArray object  = calibra->GetVectorFit2();
+    AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectExbAlt(&object);
+    TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
+    //if(!calDetLorentz) printf("No lorentz created\n");
+    // Put them in the array
+    fCalibObjects->AddAt(calDetLorentz,kExbAlt);
+    fPlots->AddAt(coefLorentzAngle,kExbAlt);
+    //
+    ok = kTRUE;
+  }
+  
+  calibra->ResetVectorFit();
+  
+  return ok;
+  
+}
+//________________________________________________________________________________________________________________
+
 Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
   //
   // Analyze PRF - produce the calibration objects
@@ -1011,6 +1117,29 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
    //if(!calDet) printf("No caldet\n");
 
  }
+//___________________________________________________________________________________________________________________
+void AliTRDPreprocessorOffline::UpdateOCDBExBAlt(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
+  //
+  // Update OCDB entry
+  //
+
+  Int_t detExB = kExbAlt;
+  if(!fMethodSecond) return;
+
+  //printf("Pass\n");
+
+  AliCDBMetaData *metaData= new AliCDBMetaData();
+  metaData->SetObjectClassName("AliTRDCalDet");
+  metaData->SetResponsible("Raphaelle Bailhache");
+  metaData->SetBeamPeriod(1);
+
+  AliCDBId id1("TRD/Calib/ChamberExBAlt", startRunNumber, endRunNumber);
+  AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
+  AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
+  if(calDet) gStorage->Put(calDet, id1, metaData);
+  //if(!calDet) printf("No caldet\n");
+
+}
  //___________________________________________________________________________________________________________________
  void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
    //
index 57bef07..63df3c0 100644 (file)
@@ -18,6 +18,7 @@ class AliTRDCalDet;
 class TH2I;
 class TProfile2D;
 class AliTRDCalibraVdriftLinearFit;
+class AliTRDCalibraExbAltFit;
 class TH1I;
 class TH2F;
 class TString;
@@ -25,17 +26,18 @@ class TString;
 
 class AliTRDPreprocessorOffline:public TNamed { 
 public:
-  enum{
-    kGain = 0,
-      kVdriftPHDet = 1,
-      kVdriftPHPad = 2,
-      kT0PHDet = 3,
-      kT0PHPad = 4,
-      kVdriftLinear = 5,
-      kLorentzLinear = 6,
-      kChamberStatus = 7,
-      kPRF = 8
-      };   
+  enum{ kGain = 0,
+       kVdriftPHDet = 1,
+       kVdriftPHPad = 2,
+       kT0PHDet = 3,
+       kT0PHPad = 4,
+       kVdriftLinear = 5,
+       kLorentzLinear = 6,
+       kChamberStatus = 7,
+       kPRF = 8,
+       kExbAlt = 9,
+       kNumCalibObjs = 10
+  };
   enum { kGainNotEnoughStatsButFill = 2,
         kVdriftNotEnoughStatsButFill = 4,
         kGainNotEnoughStatsNotFill = 8,
@@ -134,6 +136,7 @@ public:
   // Internal functions
 
   void CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
+  void CalibExbAlt(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
   void CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber,  TString  ocdbStorage="");
   void CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber,  TString  ocdbStorage="");
   void CalibChamberStatus(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
@@ -142,11 +145,13 @@ public:
   Bool_t ReadGainGlobal(const Char_t* fileName="CalibObjects.root");
   Bool_t ReadVdriftT0Global(const Char_t* fileName="CalibObjects.root");
   Bool_t ReadVdriftLinearFitGlobal(const Char_t* fileName="CalibObjects.root");
+  Bool_t ReadExbAltFitGlobal(const Char_t* fileName="CalibObjects.root");
   Bool_t ReadPRFGlobal(const Char_t* fileName="CalibObjects.root");
 
   Bool_t AnalyzeGain(); 
   Bool_t AnalyzeVdriftT0(); 
   Bool_t AnalyzeVdriftLinearFit(); 
+  Bool_t AnalyzeExbAltFit();
   Bool_t AnalyzePRF();
   Bool_t AnalyzeChamberStatus(); 
   
@@ -156,6 +161,7 @@ public:
   void UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
   void UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
   void UpdateOCDBExB(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);
+  void UpdateOCDBExBAlt(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);
   void UpdateOCDBGain(Int_t  startRunNumber, Int_t endRunNumber, const char* storagePath);
   void UpdateOCDBPRF(Int_t  startRunNumber, Int_t endRunNumber, const char* storagePath);
   void UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);
@@ -184,6 +190,7 @@ public:
   TProfile2D *fPRF2d;                        // PRF
   THnSparseI *fSparse;                       // chamberstatus
   AliTRDCalibraVdriftLinearFit *fAliTRDCalibraVdriftLinearFit; // Drift velocity second method
+  AliTRDCalibraExbAltFit* fAliTRDCalibraExbAltFit; //ExB alternative method
   TH1I *fNEvents;                         // Number of events 
   TH2F *fAbsoluteGain;                    // Absolute Gain calibration
   TObjArray * fPlots;                     // array with some plots to check
index b2e3e70..3845362 100644 (file)
@@ -543,6 +543,20 @@ Bool_t AliTRDseedV1::GetEstimatedCrossPoint(Float_t &x, Float_t &z) const
 }
 
 //____________________________________________________________________
+Float_t AliTRDseedV1::GetQperTB(Int_t tb) const
+{
+  //
+  // Charge of the clusters at timebin
+  //
+  Float_t Q = 0;
+  if(fClusters[tb] /*&& fClusters[tb]->IsInChamber()*/)
+    Q += TMath::Abs(fClusters[tb]->GetQ());
+  if(fClusters[tb+kNtb] /*&& fClusters[tb+kNtb]->IsInChamber()*/)
+    Q += TMath::Abs(fClusters[tb+kNtb]->GetQ());
+  return Q/TMath::Sqrt(1. + fYref[1]*fYref[1] + fZref[1]*fZref[1]);
+}
+
+//____________________________________________________________________
 Float_t AliTRDseedV1::GetdQdl() const
 {
 // Calculate total charge / tracklet length for 1D PID
index a14bc68..67350b7 100644 (file)
@@ -122,6 +122,7 @@ public:
   UChar_t   GetErrorMsg() const      { return fErrorMsg;}
   Float_t   GetdX() const            { return fdX;}
   const Float_t*  GetdEdx() const    { return &fdEdx[0];}
+  Float_t   GetQperTB(Int_t tb) const;
   Float_t   GetdQdl() const;
   Float_t   GetdQdl(Int_t ic, Float_t *dx=NULL) const;
   Float_t   GetdYdX() const          { return fYfit[1];}
index 2ab1fe6..23ecd53 100644 (file)
@@ -73,6 +73,7 @@ set ( SRCS
     AliTRDCalibraMode.cxx
     AliTRDCalibraVector.cxx
     AliTRDCalibraVdriftLinearFit.cxx
+    AliTRDCalibraExbAltFit.cxx
     AliTRDCalibPadStatus.cxx
     AliTRDCalibChamberStatus.cxx
     AliTRDCalibViewer.cxx
index aea236f..69b9987 100644 (file)
@@ -69,6 +69,7 @@
 #pragma link C++ class  AliTRDCalibraMode+;
 #pragma link C++ class  AliTRDCalibraVector+;
 #pragma link C++ class  AliTRDCalibraVdriftLinearFit+;
+#pragma link C++ class  AliTRDCalibraExbAltFit+;
 #pragma link C++ class  AliTRDCalibPadStatus+;
 #pragma link C++ class  AliTRDCalibChamberStatus+;
 #pragma link C++ class  AliTRDCalibViewer+;