technial fix to suppress the warning
[u/mrichter/AliRoot.git] / ITS / AliITSPlaneEffSSD.cxx
index 5c9aa2e..378455f 100644 (file)
@@ -1,4 +1,4 @@
- /**************************************************************************
+/**************************************************************************
  * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
  * Author: The ALICE Off-line Project.                                    *
@@ -44,12 +44,16 @@ AliITSPlaneEffSSD::AliITSPlaneEffSSD():
   fHisResX(0),
   fHisResZ(0),
   fHisResXZ(0),
-  fHisClusterSize(0){
+  fHisClusterSize(0),
+  fHisTrackErrX(0),
+  fHisTrackErrZ(0),
+  fHisClusErrX(0),
+  fHisClusErrZ(0){
   for (UInt_t i=0; i<kNModule; i++){
+  // default constructor
     fFound[i]=0;
     fTried[i]=0;
   }
-  // default constructor
   AliDebug(1,Form("Calling default constructor"));
 }
 //______________________________________________________________________
@@ -68,7 +72,11 @@ AliITSPlaneEffSSD::AliITSPlaneEffSSD(const AliITSPlaneEffSSD &s) : AliITSPlaneEf
 fHisResX(0),
 fHisResZ(0),
 fHisResXZ(0),
-fHisClusterSize(0)
+fHisClusterSize(0),
+fHisTrackErrX(0),
+fHisTrackErrZ(0),
+fHisClusErrX(0),
+fHisClusErrZ(0)
 {
     //     Copy Constructor
     // Inputs:
@@ -89,6 +97,10 @@ fHisClusterSize(0)
       s.fHisResZ[i]->Copy(*fHisResZ[i]);
       s.fHisResXZ[i]->Copy(*fHisResXZ[i]);
       s.fHisClusterSize[i]->Copy(*fHisClusterSize[i]);
+      s.fHisTrackErrX[i]->Copy(*fHisTrackErrX[i]);
+      s.fHisTrackErrZ[i]->Copy(*fHisTrackErrZ[i]);
+      s.fHisClusErrX[i]->Copy(*fHisClusErrX[i]);
+      s.fHisClusErrZ[i]->Copy(*fHisClusErrZ[i]);
    }
  }
 }
@@ -111,6 +123,10 @@ AliITSPlaneEffSSD& AliITSPlaneEffSSD::operator+=(const AliITSPlaneEffSSD &add){
         fHisResZ[i]->Add(add.fHisResZ[i]);
         fHisResXZ[i]->Add(add.fHisResXZ[i]);
         fHisClusterSize[i]->Add(add.fHisClusterSize[i]);
+        fHisTrackErrX[i]->Add(add.fHisTrackErrX[i]);
+        fHisTrackErrZ[i]->Add(add.fHisTrackErrZ[i]);
+        fHisClusErrX[i]->Add(add.fHisClusErrX[i]);
+        fHisClusErrZ[i]->Add(add.fHisClusErrZ[i]);
       }
     }
     return *this;
@@ -127,6 +143,8 @@ AliITSPlaneEffSSD&  AliITSPlaneEffSSD::operator=(const
     // Return:
  
     if(this==&s) return *this;
+    this->~AliITSPlaneEffSSD();
+    new(this) AliITSPlaneEffSSD();
     s.Copy(*this);
     return *this;
 }
@@ -151,30 +169,24 @@ void AliITSPlaneEffSSD::CopyHistos(AliITSPlaneEffSSD &target) const {
     target.fHisResZ=new TH1F*[kNHisto];
     target.fHisResXZ=new TH2F*[kNHisto];
     target.fHisClusterSize=new TH2I*[kNHisto];
+    target.fHisTrackErrX=new TH1F*[kNHisto];
+    target.fHisTrackErrZ=new TH1F*[kNHisto];
+    target.fHisClusErrX=new TH1F*[kNHisto];
+    target.fHisClusErrZ=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.fHisTrackErrX[i] = new TH1F(*fHisTrackErrX[i]);
+      target.fHisTrackErrZ[i] = new TH1F(*fHisTrackErrZ[i]);
+      target.fHisClusErrX[i]  = new TH1F(*fHisClusErrX[i]);
+      target.fHisClusErrZ[i]  = new TH1F(*fHisClusErrZ[i]);
     }
   }
 return;
 }
-//______________________________________________________________________
-AliITSPlaneEff&  AliITSPlaneEffSSD::operator=(const
-                                           AliITSPlaneEff &s){
-    //    Assignment operator
-    // Inputs:
-    //    AliITSPlaneEffSSD &s The original class for which
-    //                                this class is a copy of
-    // Outputs:
-    //    none.
-    // Return:
 
-    if(&s == this) return *this;
-    AliError("operator=: Not allowed to make a =, use default creater instead");
-    return *this;
-}
 //_______________________________________________________________________
 Int_t AliITSPlaneEffSSD::GetMissingTracksForGivenEff(Double_t eff, Double_t RelErr,
           UInt_t im) const {
@@ -304,13 +316,13 @@ if(cdbSSD) {
   return;
 }
 //
-UInt_t mod=GetModFromKey(key);
+//UInt_t mod=GetModFromKey(key);
 //
-AliITSBadChannelsSSD* badchannels=(AliITSBadChannelsSSD*) ssdEntry->At(mod);
+//AliITSBadChannelsSSD* badchannels=(AliITSBadChannelsSSD*) ssdEntry->At(mod);
 // count the  number of bad channels on the p side
-nrBadInMod += (badchannels->GetBadPChannelsList()).GetSize();
+//nrBadInMod += (badchannels->GetBadPChannelsList()).GetSize();
 // add the  number of bad channels on the s side
-nrBadInMod += (badchannels->GetBadNChannelsList()).GetSize();
+//nrBadInMod += (badchannels->GetBadNChannelsList()).GetSize();
 return;
 }
 //_____________________________________________________________________________
@@ -346,10 +358,8 @@ Bool_t AliITSPlaneEffSSD::ReadFromCDB() {
 if(!fInitCDBCalled)
   {AliError("ReadFromCDB: CDB not inizialized. Call InitCDB first");
    return kFALSE;}
-//if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
-//    AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
-//  }
 AliCDBEntry *cdbEntry = AliCDBManager::Instance()->Get("ITS/PlaneEff/PlaneEffSSD",fRunNumber);
+if(!cdbEntry) return kFALSE;
 AliITSPlaneEffSSD* eff= (AliITSPlaneEffSSD*)cdbEntry->GetObject();
 if(this==eff) return kFALSE;
 if(fHis) CopyHistos(*eff); // If histos already exist then copy them to eff
@@ -357,6 +367,22 @@ eff->Copy(*this);          // copy everything (statistics and histos) from eff t
 return kTRUE;
 }
 //_____________________________________________________________________________
+Bool_t AliITSPlaneEffSSD::AddFromCDB(AliCDBId *cdbId) {
+// Read (actually add the statistics) plane eff. from Data Base
+AliCDBEntry *cdbEntry=0;
+if (!cdbId) {
+  if(!fInitCDBCalled)
+    {AliError("ReadFromCDB: CDB not inizialized. Call InitCDB first"); return kFALSE;}
+  cdbEntry = AliCDBManager::Instance()->Get("ITS/PlaneEff/PlaneEffSSD",fRunNumber);
+} else {
+  cdbEntry = AliCDBManager::Instance()->Get(*cdbId);
+}
+if(!cdbEntry) return kFALSE;
+AliITSPlaneEffSSD* eff= (AliITSPlaneEffSSD*)cdbEntry->GetObject();
+*this+=*eff;
+return kTRUE;
+}
+//_____________________________________________________________________________
 UInt_t AliITSPlaneEffSSD::GetKeyFromDetLocCoord(Int_t ilay, Int_t idet,
                                                 Float_t, Float_t) const {
 // method to locate a basic block from Detector Local coordinate (to be used in tracking)
@@ -372,7 +398,7 @@ if(ilay==5 && (idet<0 || idet>949))
    return key;}
 
 UInt_t mod=idet;
-if(ilay==1) mod+=748;
+if(ilay==5) mod+=748;
 key=GetKey(mod);
 return key;
 }
@@ -384,31 +410,41 @@ void AliITSPlaneEffSSD::InitHistos() {
   TString histnameResZ="HistResZ_mod_";
   TString histnameResXZ="HistResXZ_mod_";
   TString histnameClusterType="HistClusterType_mod_";
-
+  TString histnameTrackErrX="HistTrackErrX_mod_";
+  TString histnameTrackErrZ="HistTrackErrZ_mod_";
+  TString histnameClusErrX="HistClusErrX_mod_";
+  TString histnameClusErrZ="HistClusErrZ_mod_";
 //
+
+  TH1::AddDirectory(kFALSE);
+
   fHisResX=new TH1F*[kNHisto];
   fHisResZ=new TH1F*[kNHisto];
   fHisResXZ=new TH2F*[kNHisto];
   fHisClusterSize=new TH2I*[kNHisto];
+  fHisTrackErrX=new TH1F*[kNHisto]; 
+  fHisTrackErrZ=new TH1F*[kNHisto]; 
+  fHisClusErrX=new TH1F*[kNHisto]; 
+  fHisClusErrZ=new TH1F*[kNHisto];
 
   for (Int_t nhist=0;nhist<kNHisto;nhist++){
     aux=histnameResX;
     aux+=nhist;
-    fHisResX[nhist]=new TH1F("histname","histname",500,-0.05,0.05); // +- 500 micron; 1 bin=2 micron
+    fHisResX[nhist]=new TH1F("histname","histname",500,-0.10,0.10); // +- 1000 micron; 1 bin=4 micron
     fHisResX[nhist]->SetName(aux.Data());
     fHisResX[nhist]->SetTitle(aux.Data());
 
     aux=histnameResZ;
     aux+=nhist;
-    fHisResZ[nhist]=new TH1F("histname","histname",500,-0.50,0.50); // +-5000 micron; 1 bin=20 micron
+    fHisResZ[nhist]=new TH1F("histname","histname",750,-0.75,0.75); // +-5000 micron; 1 bin=20 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]=new TH2F("histname","histname",40,-0.04,0.04,40,-0.32,0.32); // binning:
+                                                                                   // 20 micron in x;
+                                                                                   // 160 micron in z;
     fHisResXZ[nhist]->SetName(aux.Data());
     fHisResXZ[nhist]->SetTitle(aux.Data());
 
@@ -418,11 +454,39 @@ void AliITSPlaneEffSSD::InitHistos() {
     fHisClusterSize[nhist]->SetName(aux.Data());
     fHisClusterSize[nhist]->SetTitle(aux.Data());
 
+    aux=histnameTrackErrX;
+    aux+=nhist;
+    fHisTrackErrX[nhist]=new TH1F("histname","histname",300,0.,0.24); // 0-2400 micron; 1 bin=8 micron
+    fHisTrackErrX[nhist]->SetName(aux.Data());
+    fHisTrackErrX[nhist]->SetTitle(aux.Data());
+
+    aux=histnameTrackErrZ;
+    aux+=nhist;
+    fHisTrackErrZ[nhist]=new TH1F("histname","histname",300,0.,0.48); // 0-4800 micron; 1 bin=16 micron
+    fHisTrackErrZ[nhist]->SetName(aux.Data());
+    fHisTrackErrZ[nhist]->SetTitle(aux.Data());
+
+    aux=histnameClusErrX;
+    aux+=nhist;
+    fHisClusErrX[nhist]=new TH1F("histname","histname",300,0.,0.24); //  0-2400 micron; 1 bin=8 micron
+    fHisClusErrX[nhist]->SetName(aux.Data());
+    fHisClusErrX[nhist]->SetTitle(aux.Data());
+
+    aux=histnameClusErrZ;
+    aux+=nhist;
+    fHisClusErrZ[nhist]=new TH1F("histname","histname",200,0.,0.32); //  0-1600 micron; 1 bin=16 micron
+    fHisClusErrZ[nhist]->SetName(aux.Data());
+    fHisClusErrZ[nhist]->SetTitle(aux.Data());
+
   }
+
+  TH1::AddDirectory(kTRUE);
+
 return;
 }
 //__________________________________________________________
 void AliITSPlaneEffSSD::DeleteHistos() {
+// Delete histograms and remove them from memory 
   if(fHisResX) {
     for (Int_t i=0; i<kNHisto; i++ ) delete fHisResX[i];
     delete [] fHisResX; fHisResX=0;
@@ -439,17 +503,36 @@ void AliITSPlaneEffSSD::DeleteHistos() {
     for (Int_t i=0; i<kNHisto; i++ ) delete fHisClusterSize[i];
     delete [] fHisClusterSize; fHisClusterSize=0;
   }
+  if(fHisTrackErrX) {
+    for (Int_t i=0; i<kNHisto; i++ ) delete fHisTrackErrX[i];
+    delete [] fHisTrackErrX; fHisTrackErrX=0;
+  }
+  if(fHisTrackErrZ) {
+    for (Int_t i=0; i<kNHisto; i++ ) delete fHisTrackErrZ[i];
+    delete [] fHisTrackErrZ; fHisTrackErrZ=0;
+  }
+  if(fHisClusErrX) {
+    for (Int_t i=0; i<kNHisto; i++ ) delete fHisClusErrX[i];
+    delete [] fHisClusErrX; fHisClusErrX=0;
+  }
+  if(fHisClusErrZ) {
+    for (Int_t i=0; i<kNHisto; i++ ) delete fHisClusErrZ[i];
+    delete [] fHisClusErrZ; fHisClusErrZ=0;
+  }
 
 return;
 }
 //__________________________________________________________
 Bool_t AliITSPlaneEffSSD::FillHistos(UInt_t key, Bool_t found,
-                                     Float_t tXZ[2], Float_t cXZ[2], Int_t ctXZ[2]) {
+                                     Float_t *tr, Float_t *clu, Int_t *csize, Float_t*) {
 // 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
+//        - tr[0],tr[1] local X and Z coordinates of the track prediction, respectively
+//        - tr[2],tr[3] error on local X and Z coordinates of the track prediction, respectively
+//        - clu[0],clu[1] local X and Z coordinates of the cluster associated to the track, respectively
+//        - clu[2],clu[3] error on local X and Z coordinates of the cluster associated to the track, respectively
+//        - csize[0][1] cluster size in X and Z, respectively
 // output: kTRUE if filling was succesfull kFALSE otherwise
 // side effects: updating of the histograms.
 //
@@ -463,13 +546,17 @@ Bool_t AliITSPlaneEffSSD::FillHistos(UInt_t key, Bool_t found,
   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];
+    Float_t resx=tr[0]-clu[0];
+    Float_t resz=tr[1]-clu[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]);
+    fHisClusterSize[id]->Fill((Double_t)csize[0],(Double_t)csize[1]);
   }
+  fHisTrackErrX[id]->Fill(tr[2]);
+  fHisTrackErrZ[id]->Fill(tr[3]);
+  fHisClusErrX[id]->Fill(clu[2]);
+  fHisClusErrZ[id]->Fill(clu[3]);
   return kTRUE;
 }
 //__________________________________________________________
@@ -478,33 +565,47 @@ Bool_t AliITSPlaneEffSSD::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()=="") {
+  if (filename.IsNull() || filename.IsWhitespace()) {
      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 *SSDTree=new TTree("SSDTree","Tree whith Residuals and Cluster Type distributions for SSD");
   TH1F *histZ,*histX;
   TH2F *histXZ;
   TH2I *histClusterType;
+  TH1F *histTrErrZ,*histTrErrX;
+  TH1F *histClErrZ,*histClErrX;
 
   histZ=new TH1F();
   histX=new TH1F();
   histXZ=new TH2F();
   histClusterType=new TH2I();
+  histTrErrX=new TH1F();
+  histTrErrZ=new TH1F();
+  histClErrX=new TH1F();
+  histClErrZ=new TH1F();
 
   SSDTree->Branch("histX","TH1F",&histX,128000,0);
   SSDTree->Branch("histZ","TH1F",&histZ,128000,0);
   SSDTree->Branch("histXZ","TH2F",&histXZ,128000,0);
   SSDTree->Branch("histClusterType","TH2I",&histClusterType,128000,0);
+  SSDTree->Branch("histTrErrX","TH1F",&histTrErrX,128000,0);
+  SSDTree->Branch("histTrErrZ","TH1F",&histTrErrZ,128000,0);
+  SSDTree->Branch("histClErrX","TH1F",&histClErrX,128000,0);
+  SSDTree->Branch("histClErrZ","TH1F",&histClErrZ,128000,0);
 
   for(Int_t j=0;j<kNHisto;j++){
     histX=fHisResX[j];
     histZ=fHisResZ[j];
     histXZ=fHisResXZ[j];
     histClusterType=fHisClusterSize[j];
+    histTrErrX=fHisTrackErrX[j];
+    histTrErrZ=fHisTrackErrZ[j];
+    histClErrX=fHisClusErrX[j];
+    histClErrZ=fHisClusErrZ[j];
 
     SSDTree->Fill();
   }
@@ -518,7 +619,7 @@ Bool_t AliITSPlaneEffSSD::ReadHistosFromFile(TString filename) {
   // Read histograms from an already existing file
   //
   if (!fHis) return kFALSE;
-  if (filename.Data()=="") {
+  if (filename.IsNull() || filename.IsWhitespace()) {
      AliWarning("ReadHistosFromFile: incorrect output filename!");
      return kFALSE;
   }
@@ -540,6 +641,10 @@ Bool_t AliITSPlaneEffSSD::ReadHistosFromFile(TString filename) {
   TBranch *histZ = (TBranch*) tree->GetBranch("histZ");
   TBranch *histXZ = (TBranch*) tree->GetBranch("histXZ");
   TBranch *histClusterType = (TBranch*) tree->GetBranch("histClusterType");
+  TBranch *histTrErrX = (TBranch*) tree->GetBranch("histTrErrX");
+  TBranch *histTrErrZ = (TBranch*) tree->GetBranch("histTrErrZ");
+  TBranch *histClErrX = (TBranch*) tree->GetBranch("histClErrX");
+  TBranch *histClErrZ = (TBranch*) tree->GetBranch("histClErrZ");
 
   gROOT->cd();
 
@@ -548,7 +653,6 @@ Bool_t AliITSPlaneEffSSD::ReadHistosFromFile(TString filename) {
     {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);
   }
@@ -558,7 +662,6 @@ Bool_t AliITSPlaneEffSSD::ReadHistosFromFile(TString filename) {
     {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);
   }
@@ -568,7 +671,6 @@ Bool_t AliITSPlaneEffSSD::ReadHistosFromFile(TString filename) {
     {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);
   }
@@ -578,17 +680,55 @@ Bool_t AliITSPlaneEffSSD::ReadHistosFromFile(TString filename) {
     {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);
   }
 
-  delete h;   h=0;
-  delete h2;  h2=0;
-  delete h2i; h2i=0;
+  nevent = (Int_t)histTrErrX->GetEntries();
+  if(nevent!=kNHisto)
+    {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+  histTrErrX->SetAddress(&h);
+  for(Int_t j=0;j<kNHisto;j++){
+    histTrErrX->GetEntry(j);
+    fHisTrackErrX[j]->Add(h);
+  }
+
+  nevent = (Int_t)histTrErrZ->GetEntries();
+  if(nevent!=kNHisto)
+    {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+  histTrErrZ->SetAddress(&h);
+  for(Int_t j=0;j<kNHisto;j++){
+    histTrErrZ->GetEntry(j);
+    fHisTrackErrZ[j]->Add(h);
+  }
+
+  nevent = (Int_t)histClErrX->GetEntries();
+  if(nevent!=kNHisto)
+    {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+  histClErrX->SetAddress(&h);
+  for(Int_t j=0;j<kNHisto;j++){
+    //delete h; h=0;
+    histClErrX->GetEntry(j);
+    fHisClusErrX[j]->Add(h);
+  }
+
+  nevent = (Int_t)histClErrZ->GetEntries();
+  if(nevent!=kNHisto)
+    {AliWarning("ReadHistosFromFile: trying to read too many or too few histos!"); return kFALSE;}
+  histClErrZ->SetAddress(&h);
+  for(Int_t j=0;j<kNHisto;j++){
+    //delete h; h=0; 
+    histClErrZ->GetEntry(j);
+    fHisClusErrZ[j]->Add(h);
+  }
+
+  delete h;   
+  delete h2;  
+  delete h2i; 
 
   if (file) {
     file->Close();
+    delete file;
   }
 return kTRUE;
 }