Plane Efficiency framework upgrade: possibility to create histograms with residuals...
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 Feb 2008 09:43:04 +0000 (09:43 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 8 Feb 2008 09:43:04 +0000 (09:43 +0000)
ITS/AliITSPlaneEff.cxx
ITS/AliITSPlaneEff.h
ITS/AliITSPlaneEffSPD.cxx
ITS/AliITSPlaneEffSPD.h
ITS/AliITSRecoParam.cxx
ITS/AliITSRecoParam.h
ITS/AliITStrackerMI.cxx
STEER/AliPlaneEff.h
STEER/AliReconstruction.cxx

index b5bda20..d47e8a2 100644 (file)
@@ -37,7 +37,8 @@ ClassImp(AliITSPlaneEff)
 AliITSPlaneEff::AliITSPlaneEff(): AliPlaneEff(),
 fRunNumber(0), 
 fCDBUri(""),
-fInitCDBCalled(kFALSE)
+fInitCDBCalled(kFALSE),
+fHis(kFALSE)
 {
     // Default constructor
     // Inputs:
@@ -52,7 +53,8 @@ fInitCDBCalled(kFALSE)
 AliITSPlaneEff::AliITSPlaneEff(const AliITSPlaneEff &s) : AliPlaneEff(s),
 fRunNumber(s.fRunNumber),
 fCDBUri(s.fCDBUri),
-fInitCDBCalled(s.fInitCDBCalled)
+fInitCDBCalled(s.fInitCDBCalled),
+fHis(s.fHis)
 {
     //     Copy Constructor
     // Inputs:
@@ -114,6 +116,7 @@ void AliITSPlaneEff::Copy(TObject &obj) const {
   ((AliITSPlaneEff& ) obj).fRunNumber          = fRunNumber;
   ((AliITSPlaneEff& ) obj).fCDBUri             = fCDBUri;
   ((AliITSPlaneEff& ) obj).fInitCDBCalled      = fInitCDBCalled;
+  ((AliITSPlaneEff& ) obj).fHis                        = fHis;
 }
 //_________________________________________________________________________
 Double_t AliITSPlaneEff::PlaneEff(Int_t nf,Int_t nt) const {
index 52d3fd4..e370a5f 100644 (file)
@@ -74,6 +74,17 @@ class AliITSPlaneEff : public AliPlaneEff {
       {AliError("This method must be implemented in a derived class"); return 999999;};
     virtual Bool_t GetBlockBoundaries(const UInt_t,Float_t&,Float_t&,Float_t&,Float_t&) const
       {AliError("This method must be implemented in a derived class"); return kFALSE;};
+  // Methods for dealing with auxiliary histograms
+    // method to set on/off the creation/updates of histograms (Histos are created/destroyed)
+    virtual void   SetCreateHistos(Bool_t)
+      {AliError("This method must be implemented in a derived class"); return; }
+    virtual Bool_t GetCreateHistos() const {return fHis;};
+    virtual Bool_t FillHistos(UInt_t, Bool_t, Float_t[2], Float_t[2], Int_t[2])
+      {AliError("This method must be implemented in a derived class"); return kFALSE; }
+    virtual Bool_t WriteHistosToFile(TString ,Option_t*)
+      {AliError("This method must be implemented in a derived class"); return kFALSE; }
+    virtual Bool_t ReadHistosFromFile(TString )
+      {AliError("This method must be implemented in a derived class"); return kFALSE; }
 
  protected:
 
@@ -84,6 +95,7 @@ class AliITSPlaneEff : public AliPlaneEff {
     Int_t      fRunNumber;     //! run number (to access CDB)
     TString    fCDBUri;        //! Uri of the default CDB storage
     Bool_t     fInitCDBCalled; //! flag to check if CDB storages are already initialized
+    Bool_t      fHis;           //! if true, then histograms are created and filled 
    
  private:
     //Int_t*   fFound;         // number of associated clusters into a given block (e.g. SPD 1200 chip)
index e0c5d37..b613aca 100644 (file)
 /* $Id$ */
 
 #include <TMath.h>
+#include <TH1F.h>
+#include <TFile.h>
+#include <TTree.h>
+#include <TROOT.h>
 #include "AliITSPlaneEffSPD.h"
 #include "AliLog.h"
 #include "AliCDBStorage.h"
 ClassImp(AliITSPlaneEffSPD)    
 //______________________________________________________________________
 AliITSPlaneEffSPD::AliITSPlaneEffSPD():
-  AliITSPlaneEff(){
-//  for (UInt_t im=0; im<kNModule; im++){
-//  for (UInt_t ic=0; ic<kNChip; ic++){
-//    fFound[im][ic]=0;
-//    fTried[im][ic]=0;
-//  }}
+  AliITSPlaneEff(),
+  //fHis(kFALSE),
+  fHisResX(0),
+  fHisResZ(0),
+  fHisResXZ(0),
+  fHisClusterSize(0),
+  fHisResXclu(0),
+  fHisResZclu(0){
   for (UInt_t i=0; i<kNModule*kNChip; i++){
     fFound[i]=0;
     fTried[i]=0;
@@ -59,10 +65,17 @@ AliITSPlaneEffSPD::~AliITSPlaneEffSPD(){
     //    none.
     // Return:
     //     none.
+    DeleteHistos();
 }
 //______________________________________________________________________
-AliITSPlaneEffSPD::AliITSPlaneEffSPD(const AliITSPlaneEffSPD &s) : AliITSPlaneEff(s) //,
+AliITSPlaneEffSPD::AliITSPlaneEffSPD(const AliITSPlaneEffSPD &s) : AliITSPlaneEff(s), 
 //fHis(s.fHis),
+fHisResX(0),
+fHisResZ(0),
+fHisResXZ(0),
+fHisClusterSize(0),
+fHisResXclu(0),
+fHisResZclu(0)
 {
     //     Copy Constructor
     // Inputs:
@@ -72,6 +85,23 @@ AliITSPlaneEffSPD::AliITSPlaneEffSPD(const AliITSPlaneEffSPD &s) : AliITSPlaneEf
     //    none.
     // Return:
 
+ for (UInt_t i=0; i<kNModule*kNChip; i++){
+    fFound[i]=s.fFound[i];
+    fTried[i]=s.fTried[i];
+ }
+ if(fHis) { 
+   InitHistos();
+   for(Int_t i=0; i<kNHisto; i++) {
+      s.fHisResX[i]->Copy(*fHisResX[i]);
+      s.fHisResZ[i]->Copy(*fHisResZ[i]);
+      s.fHisResXZ[i]->Copy(*fHisResXZ[i]);
+      s.fHisClusterSize[i]->Copy(*fHisClusterSize[i]);
+      for(Int_t clu=0; clu<kNclu; clu++) {  // clu=0 --> cluster size 1
+        s.fHisResXclu[i][clu]->Copy(*fHisResXclu[i][clu]);
+        s.fHisResZclu[i][clu]->Copy(*fHisResZclu[i][clu]);
+      }
+   }
+ }
 }
 //_________________________________________________________________________
 AliITSPlaneEffSPD& AliITSPlaneEffSPD::operator+=(const AliITSPlaneEffSPD &add){
@@ -86,6 +116,18 @@ AliITSPlaneEffSPD& AliITSPlaneEffSPD::operator+=(const AliITSPlaneEffSPD &add){
       fFound[i] += add.fFound[i];
       fTried[i] += add.fTried[i];
     }
+    if(fHis && add.fHis) {
+      for(Int_t i=0; i<kNHisto; i++) {
+        fHisResX[i]->Add(add.fHisResX[i]); 
+        fHisResZ[i]->Add(add.fHisResZ[i]); 
+        fHisResXZ[i]->Add(add.fHisResXZ[i]); 
+        fHisClusterSize[i]->Add(add.fHisClusterSize[i]); 
+        for(Int_t clu=0; clu<kNclu; clu++) {  // clu=0 --> cluster size 1
+          fHisResXclu[i][clu]->Add(add.fHisResXclu[i][clu]); 
+          fHisResZclu[i][clu]->Add(add.fHisResZclu[i][clu]); 
+        }
+      }
+    }
     return *this;
 }
 //______________________________________________________________________
@@ -101,22 +143,45 @@ AliITSPlaneEffSPD&  AliITSPlaneEffSPD::operator=(const
  
     if(this==&s) return *this;
     s.Copy(*this);
-//    if(&s == this) return *this;
-//    for (UInt_t i=0; i<kNModule*kNChip; i++){
-//      this->fFound[i] = s.fFound[i];
-//      this->fTried[i] = s.fTried[i];
-//    }
     return *this;
 }
 //______________________________________________________________________
 void AliITSPlaneEffSPD::Copy(TObject &obj) const {
   // protected method. copy this to obj
   AliITSPlaneEff::Copy(obj);
-  //((AliITSPlaneEffSPD& ) obj).fNpx  = fNpx;
+  AliITSPlaneEffSPD& target = (AliITSPlaneEffSPD &) obj;
   for(Int_t i=0;i<kNModule*kNChip;i++) {
-      ((AliITSPlaneEffSPD& ) obj).fFound[i] = fFound[i];
-      ((AliITSPlaneEffSPD& ) obj).fTried[i] = fTried[i];
+      target.fFound[i] = fFound[i];
+      target.fTried[i] = fTried[i];
+  }
+  CopyHistos(target);
+  return;
+}
+//_______________________________________________________________________
+void AliITSPlaneEffSPD::CopyHistos(AliITSPlaneEffSPD &target) const {
+  // protected method: copy histos from this to target
+  target.fHis  = fHis; // this is redundant only in some cases. Leave as it is.
+  if(fHis) {
+    target.fHisResX=new TH1F*[kNHisto];
+    target.fHisResZ=new TH1F*[kNHisto];
+    target.fHisResXZ=new TH2F*[kNHisto];
+    target.fHisClusterSize=new TH2I*[kNHisto];
+    target.fHisResXclu=new TH1F**[kNHisto];
+    target.fHisResZclu=new TH1F**[kNHisto];
+    for(Int_t i=0; i<kNHisto; i++) {
+      target.fHisResX[i] = new TH1F(*fHisResX[i]);
+      target.fHisResZ[i] = new TH1F(*fHisResZ[i]);
+      target.fHisResXZ[i] = new TH2F(*fHisResXZ[i]);
+      target.fHisClusterSize[i] = new TH2I(*fHisClusterSize[i]);
+      target.fHisResXclu[i]=new TH1F*[kNclu];
+      target.fHisResZclu[i]=new TH1F*[kNclu];
+      for(Int_t clu=0; clu<kNclu; clu++) {  // clu=0 --> cluster size 1
+        target.fHisResXclu[i][clu] = new TH1F(*fHisResXclu[i][clu]);
+        target.fHisResZclu[i][clu] = new TH1F(*fHisResZclu[i][clu]);
+      }
+    }
   }
+return;
 }
 //______________________________________________________________________
 AliITSPlaneEff&  AliITSPlaneEffSPD::operator=(const
@@ -355,7 +420,8 @@ if(!fInitCDBCalled)
 AliCDBEntry *cdbEntry = AliCDBManager::Instance()->Get("ITS/PlaneEff/PlaneEffSPD",fRunNumber);
 AliITSPlaneEffSPD* eff= (AliITSPlaneEffSPD*)cdbEntry->GetObject();
 if(this==eff) return kFALSE;
-eff->Copy(*this);
+if(fHis) CopyHistos(*eff); // If histos already exist then copy them to eff
+eff->Copy(*this);          // copy everything (statistics and histos) from eff to this
 return kTRUE;
 }
 //_____________________________________________________________________________
@@ -490,3 +556,309 @@ for(UInt_t j=0;j<col;j++){
 } // end for j
 return dz;
 }
+//__________________________________________________________
+void AliITSPlaneEffSPD::InitHistos() {
+  // for the moment let's create the histograms 
+  // module by  module
+  TString histnameResX="HistResX_mod_",aux;
+  TString histnameResZ="HistResZ_mod_";
+  TString histnameResXZ="HistResXZ_mod_";
+  TString histnameClusterType="HistClusterType_mod_";
+  TString histnameResXclu="HistResX_mod_";
+  TString histnameResZclu="HistResZ_mod_";
+//
+  fHisResX=new TH1F*[kNHisto];
+  fHisResZ=new TH1F*[kNHisto];
+  fHisResXZ=new TH2F*[kNHisto];
+  fHisClusterSize=new TH2I*[kNHisto];
+  fHisResXclu=new TH1F**[kNHisto];
+  fHisResZclu=new TH1F**[kNHisto];
+
+  for (Int_t nhist=0;nhist<kNHisto;nhist++){
+    aux=histnameResX;
+    aux+=nhist;
+    fHisResX[nhist]=new TH1F("histname","histname",800,-0.04,0.04); // +- 400 micron; 1 bin=1 micron
+    fHisResX[nhist]->SetName(aux.Data());
+    fHisResX[nhist]->SetTitle(aux.Data());
+
+    aux=histnameResZ;
+    aux+=nhist;
+    fHisResZ[nhist]=new TH1F("histname","histname",800,-0.32,0.32); // +-3200 micron; 1 bin=8 micron
+    fHisResZ[nhist]->SetName(aux.Data());
+    fHisResZ[nhist]->SetTitle(aux.Data());
+
+    aux=histnameResXZ;
+    aux+=nhist;
+    fHisResXZ[nhist]=new TH2F("histname","histname",40,-0.02,0.02,40,-0.16,0.16); // binning:
+                                                                                   // 10 micron in x; 
+                                                                                   // 80 micron in z; 
+    fHisResXZ[nhist]->SetName(aux.Data());
+    fHisResXZ[nhist]->SetTitle(aux.Data());
+
+    aux=histnameClusterType;
+    aux+=nhist;
+    fHisClusterSize[nhist]=new TH2I("histname","histname",10,0.5,10.5,10,0.5,10.5);
+    fHisClusterSize[nhist]->SetName(aux.Data());
+    fHisClusterSize[nhist]->SetTitle(aux.Data());
+
+    fHisResXclu[nhist]=new TH1F*[kNclu];
+    fHisResZclu[nhist]=new TH1F*[kNclu];
+    for(Int_t clu=0; clu<kNclu; clu++) {  // clu=0 --> cluster size 1
+      aux=histnameResXclu;
+      aux+=nhist;
+      aux+="_clu_";
+      aux+=clu+1; // clu=0 --> cluster size 1
+      fHisResXclu[nhist][clu]=new TH1F("histname","histname",800,-0.04,0.04); // +- 400 micron; 1 bin=1 micron
+      fHisResXclu[nhist][clu]->SetName(aux.Data());
+      fHisResXclu[nhist][clu]->SetTitle(aux.Data());
+
+      aux=histnameResZclu;
+      aux+=nhist;
+      aux+="_clu_";
+      aux+=clu+1; // clu=0 --> cluster size 1
+      fHisResZclu[nhist][clu]=new TH1F("histname","histname",800,-0.32,0.32); // +-3200 micron; 1 bin=8 micron
+      fHisResZclu[nhist][clu]->SetName(aux.Data());
+      fHisResZclu[nhist][clu]->SetTitle(aux.Data());
+    }
+
+  }
+return;
+}
+//__________________________________________________________
+void AliITSPlaneEffSPD::DeleteHistos() {
+  if(fHisResX) {
+    for (Int_t i=0; i<kNHisto; i++ ) delete fHisResX[i];
+    delete [] fHisResX; 
+  }
+  if(fHisResZ) {
+    for (Int_t i=0; i<kNHisto; i++ ) delete fHisResZ[i];
+    delete [] fHisResZ;
+  }
+  if(fHisResXZ) {
+    for (Int_t i=0; i<kNHisto; i++ ) delete fHisResXZ[i];
+    delete [] fHisResXZ;
+  }
+  if(fHisClusterSize) {
+    for (Int_t i=0; i<kNHisto; i++ ) delete fHisClusterSize[i];
+    delete [] fHisClusterSize;
+  }
+  if(fHisResXclu) {
+    for (Int_t i=0; i<kNHisto; i++ ) {
+      for (Int_t clu=0; clu<kNclu; clu++) if (fHisResXclu[i][clu]) delete fHisResXclu[i][clu];
+      delete [] fHisResXclu[i];
+    }
+    delete [] fHisResXclu;
+    fHisResXclu = 0;
+  }
+  if(fHisResZclu) {
+    for (Int_t i=0; i<kNHisto; i++ ) {
+      for (Int_t clu=0; clu<kNclu; clu++) if (fHisResZclu[i][clu]) delete fHisResZclu[i][clu];
+      delete [] fHisResZclu[i];
+    }
+    delete [] fHisResZclu;
+    fHisResZclu = 0;
+  }
+
+return;
+}
+//__________________________________________________________
+Bool_t AliITSPlaneEffSPD::FillHistos(UInt_t key, Bool_t found, 
+                                     Float_t tXZ[2], Float_t cXZ[2], Int_t ctXZ[2]) {
+// this method fill the histograms
+// input: - key: unique key of the basic block 
+//        - found: Boolean to asses whether a cluster has been associated to the track or not 
+//        - tXZ[2] local X and Z coordinates of the track prediction
+//        - cXZ[2] local X and Z coordinates of the cluster associated to the track
+// output: kTRUE if filling was succesfull kFALSE otherwise
+// side effects: updating of the histograms. 
+//
+  if (!fHis) {
+    AliWarning("FillHistos: histograms do not exist! Call SetCreateHistos(kTRUE) first");
+    return kFALSE;
+  }
+  if(key>=kNModule*kNChip)
+    {AliWarning("FillHistos: you asked for a non existing key"); return kFALSE;}
+  Int_t id=GetModFromKey(key);
+  if(id>=kNHisto) 
+    {AliWarning("FillHistos: you want to fill a non-existing histos"); return kFALSE;}
+  if(found) {
+    Float_t resx=tXZ[0]-cXZ[0];
+    Float_t resz=tXZ[1]-cXZ[1];
+    fHisResX[id]->Fill(resx);
+    fHisResZ[id]->Fill(resz);
+    fHisResXZ[id]->Fill(resx,resz);
+    fHisClusterSize[id]->Fill((Double_t)ctXZ[0],(Double_t)ctXZ[1]);
+    if(ctXZ[0]>0 &&  ctXZ[0]<=kNclu) fHisResXclu[id][ctXZ[0]-1]->Fill(resx);
+    if(ctXZ[1]>0 &&  ctXZ[1]<=kNclu) fHisResZclu[id][ctXZ[1]-1]->Fill(resx);
+  }
+  return kTRUE;
+}
+//__________________________________________________________
+Bool_t AliITSPlaneEffSPD::WriteHistosToFile(TString filename, Option_t* option) {
+  //
+  // Saves the histograms into a tree and saves the trees into a file
+  //
+  if (!fHis) return kFALSE;
+  if (filename.Data()=="") {
+     AliWarning("WriteHistosToFile: null output filename!");
+     return kFALSE;
+  }
+  char branchname[30];
+  TFile *hFile=new TFile(filename.Data(),option,
+                         "The File containing the TREEs with ITS PlaneEff Histos");
+  TTree *SPDTree=new TTree("SPDTree","Tree whith Residuals and Cluster Type distributions for SPD");
+  TH1F *histZ,*histX;
+  TH2F *histXZ;
+  TH2I *histClusterType;
+  TH1F *histXclu[kNclu];
+  TH1F *histZclu[kNclu];
+
+  histZ=new TH1F();
+  histX=new TH1F();
+  histXZ=new TH2F();
+  histClusterType=new TH2I();
+  for(Int_t clu=0;clu<kNclu;clu++) {
+    histXclu[clu]=new TH1F();
+    histZclu[clu]=new TH1F();
+  }
+
+  SPDTree->Branch("histX","TH1F",&histX,128000,0);
+  SPDTree->Branch("histZ","TH1F",&histZ,128000,0);
+  SPDTree->Branch("histXZ","TH2F",&histXZ,128000,0);
+  SPDTree->Branch("histClusterType","TH2I",&histClusterType,128000,0);
+  for(Int_t clu=0;clu<kNclu;clu++) {
+    sprintf(branchname,"histXclu_%d",clu+1);
+    SPDTree->Branch(branchname,"TH1F",&histXclu[clu],128000,0);
+    sprintf(branchname,"histZclu_%d",clu+1);
+    SPDTree->Branch(branchname,"TH1F",&histZclu[clu],128000,0);
+  }
+
+  for(Int_t j=0;j<kNHisto;j++){
+    histX=fHisResX[j];
+    histZ=fHisResZ[j];
+    histXZ=fHisResXZ[j];
+    histClusterType=fHisClusterSize[j];
+    for(Int_t clu=0;clu<kNclu;clu++) {
+      histXclu[clu]=fHisResXclu[j][clu];
+      histZclu[clu]=fHisResZclu[j][clu];
+    }
+    SPDTree->Fill();
+  }
+  hFile->Write();
+  hFile->Close();
+return kTRUE;
+}
+//__________________________________________________________
+Bool_t AliITSPlaneEffSPD::ReadHistosFromFile(TString filename) {
+  //
+  // Read histograms from an already existing file 
+  //
+  if (!fHis) return kFALSE;
+  if (filename.Data()=="") {
+     AliWarning("ReadHistosFromFile: incorrect output filename!");
+     return kFALSE;
+  }
+  char branchname[30];
+
+  TH1F *h  = 0;
+  TH2F *h2 = 0;
+  TH2I *h2i= 0;
+
+  TFile *file=TFile::Open(filename.Data(),"READONLY");
+
+  if (!file || file->IsZombie()) {
+    AliWarning(Form("Can't open %s !",filename.Data()));
+    delete file;
+    return kFALSE;
+  }
+  TTree *tree = (TTree*) file->Get("SPDTree");
+
+  TBranch *histX = (TBranch*) tree->GetBranch("histX");
+  TBranch *histZ = (TBranch*) tree->GetBranch("histZ");
+  TBranch *histXZ = (TBranch*) tree->GetBranch("histXZ");
+  TBranch *histClusterType = (TBranch*) tree->GetBranch("histClusterType");
+   
+  TBranch *histXclu[kNclu], *histZclu[kNclu];
+  for(Int_t clu=0; clu<kNclu; clu++) {
+    sprintf(branchname,"histXclu_%d",clu+1);
+    histXclu[clu]= (TBranch*) tree->GetBranch(branchname);
+    sprintf(branchname,"histZclu_%d",clu+1);
+    histZclu[clu]= (TBranch*) tree->GetBranch(branchname);
+  }
+
+  gROOT->cd();
+
+  Int_t nevent = (Int_t)histX->GetEntries();
+  if(nevent!=kNHisto) 
+    {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+  histX->SetAddress(&h);
+  for(Int_t j=0;j<kNHisto;j++){
+    delete h; h=0;
+    histX->GetEntry(j);
+    fHisResX[j]->Add(h);
+  }
+
+  nevent = (Int_t)histZ->GetEntries();
+  if(nevent!=kNHisto) 
+    {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+  histZ->SetAddress(&h);
+  for(Int_t j=0;j<kNHisto;j++){
+    delete h; h=0;
+    histZ->GetEntry(j);
+    fHisResZ[j]->Add(h);
+  }
+
+  nevent = (Int_t)histXZ->GetEntries();
+  if(nevent!=kNHisto) 
+    {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+  histXZ->SetAddress(&h2);
+  for(Int_t j=0;j<kNHisto;j++){
+    delete h2; h2=0;
+    histXZ->GetEntry(j);
+    fHisResXZ[j]->Add(h2);
+  }
+
+  nevent = (Int_t)histClusterType->GetEntries();
+  if(nevent!=kNHisto) 
+    {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+  histClusterType->SetAddress(&h2i);
+  for(Int_t j=0;j<kNHisto;j++){
+    delete h2i; h2i=0;
+    histClusterType->GetEntry(j);
+    fHisClusterSize[j]->Add(h2i);
+  }
+
+  for(Int_t clu=0; clu<kNclu; clu++) {
+
+    nevent = (Int_t)histXclu[clu]->GetEntries();
+    if(nevent!=kNHisto)
+      {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+    histXclu[clu]->SetAddress(&h);
+    for(Int_t j=0;j<kNHisto;j++){
+      delete h; h=0;
+      histXclu[clu]->GetEntry(j);
+      fHisResXclu[j][clu]->Add(h);
+    }
+
+   nevent = (Int_t)histZclu[clu]->GetEntries();
+    if(nevent!=kNHisto)
+      {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+    histZclu[clu]->SetAddress(&h);
+    for(Int_t j=0;j<kNHisto;j++){
+      delete h; h=0;
+      histZclu[clu]->GetEntry(j);
+      fHisResZclu[j][clu]->Add(h);
+    }
+  }
+
+  delete h;   h=0;
+  delete h2;  h2=0;
+  delete h2i; h2i=0;
+
+  if (file) {
+    file->Close();
+  }
+
+  fHisResZclu[0][0]->Draw();
+return kTRUE;
+}
index 9880ef8..ab1e84b 100644 (file)
@@ -3,7 +3,8 @@
 /* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-
+#include <TH1F.h>
+#include <TH2I.h>
 #include "AliITSPlaneEff.h"
 
 ///////////////////////////////////////////
@@ -40,9 +41,14 @@ class AliITSPlaneEffSPD :  public AliITSPlaneEff {
         {return UpDatePlaneEff(Kfound,GetModFromKey(key),GetChipFromKey(key));};
     //
     enum {kNModule = 240}; // The number of modules
-    enum {kNChip = 5}; // The number of chips per module
-    enum {kNCol = 32}; // The number of columns per chip
-    enum {kNRow = 256}; // The number of rows per chip (and per module)
+    enum {kNChip = 5};     // The number of chips per module
+    enum {kNCol = 32};     // The number of columns per chip
+    enum {kNRow = 256};    // The number of rows per chip (and per module)
+
+    enum {kNHisto = kNModule}; // The number of histograms: module by module.  
+    enum {kNclu = 3};          // Build specific histos of residuals up to cluster size kNclu.
+                               // If you change them, then you must change implementation of 
+                               // the method FillHistos.
 //
 //  UInt_t GetChip(const UInt_t col) const; // get the chip number (from 0 to kNChip)
 //  Plane efficiency for active  detector (excluding dead/noisy channels)
@@ -64,20 +70,37 @@ class AliITSPlaneEffSPD :  public AliITSPlaneEff {
    // method to locate a basic block from Detector Local coordinate (to be used in tracking)
    // see file cxx for numbering convention.
    // here idet runs from 0 to 79 for layer 0 and from 0 to 159 for layer 1
+    UInt_t GetKey(const UInt_t mod, const UInt_t chip) const; // unique key to locate the basic
+                                                              // block of the SPD
     UInt_t GetKeyFromDetLocCoord(Int_t ilay,Int_t idet, Float_t, Float_t locz) const;
     UInt_t Nblock() const; // return the number of basic blocks
     // compute the geometrical limit of a basic block (chip) in detector local coordinate system 
     Bool_t GetBlockBoundaries(const UInt_t key,Float_t& xmn,Float_t& xmx,Float_t& zmn,Float_t& zmx) const;
+  // Methods for dealing with auxiliary histograms
+    // method to set on/off the creation/updates of histograms (Histos are created/destroyed)
+    void   SetCreateHistos(Bool_t his=kFALSE) 
+         {fHis=his; if(fHis) InitHistos(); else DeleteHistos(); return; }
+    Bool_t FillHistos(UInt_t key, Bool_t found, Float_t trackXZ[2], Float_t clusterXZ[2], Int_t ctXZ[2]);
+    Bool_t WriteHistosToFile(TString filename="PlaneEffSPDHistos.root",Option_t* option = "RECREATE");
+    Bool_t ReadHistosFromFile(TString filename="PlaneEffSPDHistos.root");
 
  protected:
-    virtual void Copy(TObject &obj) const;
+    virtual void Copy(TObject &obj) const;           // copy ALL data members to obj 
+                                                     // iboth statistics ad histograms)
+    void CopyHistos(AliITSPlaneEffSPD& target) const; // copy only histograms to target
     Int_t GetMissingTracksForGivenEff(Double_t eff, Double_t RelErr, UInt_t im, UInt_t ic) const;
 
 // 
     Int_t fFound[kNModule*kNChip];  // number of associated clusters in a given chip
     Int_t fTried[kNModule*kNChip];  // number of tracks used for chip efficiency evaluation
+    TH1F **fHisResX; //! histos with residual distribution (track-cluster) along local X (r-phi)
+    TH1F **fHisResZ; //! histos with residual distribution (track-cluster) along local Z
+    TH2F **fHisResXZ; //! 2-d histos with residual distribution (track-cluster) along local X and Z
+    TH2I **fHisClusterSize; //! histos with cluster-size distribution
+    TH1F ***fHisResXclu; //! histos with residual distribution along local X (r-phi) for cluster type 
+    TH1F ***fHisResZclu; //! histos with residual distribution along local Z for cluster type  
  private:
-    UInt_t GetKey(const UInt_t mod, const UInt_t chip) const; // unique key to locate the basic 
+    //UInt_t GetKey(const UInt_t mod, const UInt_t chip) const; // unique key to locate the basic 
                                                               // block of the SPD 
     UInt_t GetModFromKey(const UInt_t key) const;
     UInt_t GetChipFromKey(const UInt_t key) const;
@@ -89,6 +112,8 @@ class AliITSPlaneEffSPD :  public AliITSPlaneEff {
                                                     // the latter in the range [0,kNRow]
     void GetModAndChipFromKey(const UInt_t key, UInt_t& mod, UInt_t& chip) const;
     void GetDeadAndNoisyInChip(const UInt_t key, UInt_t& dead, UInt_t& noisy) const;
+    void InitHistos();
+    void DeleteHistos();
 
     ClassDef(AliITSPlaneEffSPD,1) // SPD Plane Efficiency class
 };
index 9cff51f..ff63a5a 100644 (file)
@@ -98,6 +98,7 @@ fUseTGeoInTracker(3),
 fAllowSharedClusters(kTRUE),
 fClusterErrorsParam(1),
 fComputePlaneEff(kFALSE),
+fHistoPlaneEff(kFALSE),
 fExtendedEtaAcceptance(kFALSE),
 fUseDeadZonesFromOCDB(kFALSE),
 fAllowProlongationWithEmptyRoad(kFALSE),
index a4a48af..600b976 100644 (file)
@@ -125,8 +125,10 @@ class AliITSRecoParam : public AliDetectorRecoParam
   void   SetUseAmplitudeInfo(Int_t ilay,Bool_t use) { fUseAmplitudeInfo[ilay]=use; return; }
   Bool_t GetUseAmplitudeInfo(Int_t ilay) const { return fUseAmplitudeInfo[ilay]; }
   //
-  void   SetComputePlaneEff(Bool_t eff=kTRUE) { fComputePlaneEff=eff; return; }
+  void   SetComputePlaneEff(Bool_t eff=kTRUE, Bool_t his=kTRUE) 
+      { fComputePlaneEff=eff; fHistoPlaneEff=his; return; }
   Bool_t GetComputePlaneEff() const { return fComputePlaneEff; }
+  Bool_t GetHistoPlaneEff() const { return fHistoPlaneEff; }
   //
   void   SetExtendedEtaAcceptance(Bool_t ext=kTRUE) { fExtendedEtaAcceptance=ext; return; }
   Bool_t GetExtendedEtaAcceptance() const { return fExtendedEtaAcceptance; }
@@ -259,6 +261,7 @@ class AliITSRecoParam : public AliDetectorRecoParam
   Int_t fClusterErrorsParam; // parametrization for cluster errors (MI), see AliITSRecoParam::GetError()
   Bool_t fUseAmplitudeInfo[AliITSgeomTGeo::kNLayers]; // use cluster charge in cluster-track matching (SDD,SSD) (MI)
   Bool_t fComputePlaneEff;  // flag to enable computation of PlaneEfficiency
+  Bool_t fHistoPlaneEff;  // flag to enable auxiliary PlaneEff histograms (e.g. residual distributions)
   Bool_t fExtendedEtaAcceptance;  // enable jumping from TPC to SPD at large eta (MI)
   Bool_t fUseDeadZonesFromOCDB; // enable using OCDB info on dead modules.. (MI)
   Bool_t fAllowProlongationWithEmptyRoad; // allow to prolong even if road is empty (MI)
index 2a26daf..412afc6 100644 (file)
@@ -220,6 +220,10 @@ fPlaneEff(0) {
     }
     if(!fPlaneEff->ReadFromCDB()) 
       {AliWarning("AliITStrackerMI reading of AliITSPlaneEff from OCDB failed") ;}
+    if(AliITSReconstructor::GetRecoParam()->GetHistoPlaneEff()) {
+      fPlaneEff->SetCreateHistos(kTRUE); 
+      //fPlaneEff->ReadHistosFromFile();
+    }
   }
 }
 //------------------------------------------------------------------------
@@ -4965,7 +4969,7 @@ Bool_t AliITStrackerMI::IsOKForPlaneEff(AliITStrackMI* track, Int_t ilayer) cons
   Float_t blockXmn,blockXmx,blockZmn,blockZmx;
   if (!fPlaneEff->GetBlockBoundaries(key,blockXmn,blockXmx,blockZmn,blockZmx)) return kFALSE;
   // transform Local boundaries of the basic block into 
-  //  Global (i.e. ALICE not tracking reference) coordinate
+  //  Global (i.e. ALICE, not tracking reference) coordinate
   //
   Double_t a1[3]={blockXmn,0.,blockZmn};
   Double_t a2[3]={blockXmx,0.,blockZmn};
@@ -5138,6 +5142,21 @@ void AliITStrackerMI::UseTrackForPlaneEff(AliITStrackMI* track, Int_t ilayer) {
   }
   if(!fPlaneEff->UpDatePlaneEff(found,key))
        AliWarning(Form("UseTrackForPlaneEff: cannot UpDate PlaneEff for key=%d",key));
+  if(fPlaneEff->GetCreateHistos()&&  AliITSReconstructor::GetRecoParam()->GetHistoPlaneEff()) {
+    Int_t ndet=AliITSgeomTGeo::GetNDetectors(ilayer+1); // layers from 1 to 6
+    Int_t lad = Int_t(idet/ndet) + 1;
+    Int_t hdet = idet - (lad-1)*ndet + 1;
+    Double_t xyzGlob[3],xyzLoc[3];
+    tmp.GetXYZ(xyzGlob);
+    AliITSgeomTGeo::GlobalToLocal(ilayer+1,lad,hdet,xyzGlob,xyzLoc);
+    Float_t tr[2]={xyzLoc[0],xyzLoc[2]};
+    Float_t cl[2];
+    cl[0]=layer.GetCluster(ci)->GetDetLocalX();
+    cl[1]=layer.GetCluster(ci)->GetDetLocalZ();
+    Int_t cltype[2];
+    cltype[0]=layer.GetCluster(ci)->GetNy();
+    cltype[1]=layer.GetCluster(ci)->GetNz();
+    fPlaneEff->FillHistos(key,found,tr,cl,cltype);
+  }
 return;
 }
-
index fe5187e..05f021c 100644 (file)
@@ -30,13 +30,20 @@ class AliPlaneEff : public TObject {
     //Int_t   GetRunNumber() const {return fRunNumber;}
     //void    SetRunNumber(Int_t n) {fRunNumber=n;}
     //
-    // Write into the data base 
+    // Write into (read from) the data base 
     virtual Bool_t WriteIntoCDB() const
        {AliError("This method must be implemented in a derived class"); return kFALSE;};
     virtual Bool_t ReadFromCDB()
        {AliError("This method must be implemented in a derived class"); return kFALSE;};
     virtual Bool_t AddFromCDB()
        {AliError("This method must be implemented in a derived class"); return kFALSE;};
+    // Write/read Histograms to/from File
+    virtual Bool_t WriteHistosToFile(TString ,Option_t* )
+       {AliError("This method must be implemented in a derived class"); return kFALSE; }
+    virtual Bool_t ReadHistosFromFile(TString )
+       {AliError("This method must be implemented in a derived class"); return kFALSE; }
+    virtual Bool_t GetCreateHistos() const
+       {AliError("This method must be implemented in a derived class"); return kFALSE; }
 
  protected:
 
index 2435e15..286b053 100644 (file)
@@ -3176,7 +3176,16 @@ Bool_t AliReconstruction::FinishPlaneEff() {
  //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
  for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS  
    //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
-   if(fTracker[iDet]) ret=fTracker[iDet]->GetPlaneEff()->WriteIntoCDB();
+   if(fTracker[iDet]) {
+      AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff(); 
+      ret=planeeff->WriteIntoCDB();
+      if(planeeff->GetCreateHistos()) {
+        TString name="PlaneEffHisto";
+        name+=fgkDetectorName[iDet];
+        name+=".root";
+        ret*=planeeff->WriteHistosToFile(name,"RECREATE");
+      }
+   }
  }
  return ret;
 }