[u/mrichter/AliRoot.git] / PWGPP / TPC / AliPerformanceDEdx.cxx

//------------------------------------------------------------------------------
// Implementation of AliPerformanceDEdx class. It keeps information from 
// comparison of reconstructed and MC particle tracks. In addtion, 
// it keeps selection cuts used during comparison. The comparison 
// information is stored in the ROOT histograms. Analysis of these 
// histograms can be done by using Analyse() class function. The result of 
// the analysis (histograms/graphs) are stored in the folder which is 
// a data of AliPerformanceDEdx.
//  
// Author: J.Otwinowski 04/02/2008 
// Changes by M.Knichel 15/10/2010
//------------------------------------------------------------------------------

/*
 
  // after running comparison task, read the file, and get component
  gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");
  LoadMyLibs();
  TFile f("Output.root");
  //AliPerformanceDEdx * compObj = (AliPerformanceDEdx*)f.Get("AliPerformanceDEdx");
  AliPerformanceDEdx * compObj = (AliPerformanceDEdx*)coutput->FindObject("AliPerformanceDEdx");

  // Analyse comparison data
  compObj->Analyse();

  // the output histograms/graphs will be stored in the folder "folderDEdx" 
  compObj->GetAnalysisFolder()->ls("*");

  // user can save whole comparison object (or only folder with anlysed histograms) 
  // in the seperate output file (e.g.)
  TFile fout("Analysed_DEdx.root","recreate");
  //compObj->Write(); // compObj->GetAnalysisFolder()->Write();
  compObj->GetAnalysisFolder()->Write();
  fout.Close();

*/

#include "TDirectory.h"
#include "TAxis.h"
#include "TCanvas.h"
#include "TH1.h"
#include "TH2.h"
#include "TF1.h"
#include "TSystem.h"
#include "TChain.h"

#include "AliPerformanceDEdx.h"
#include "AliPerformanceTPC.h"
#include "AliTPCPerformanceSummary.h"
#include "AliESDEvent.h"
#include "AliTracker.h"
#include "AliMCEvent.h"
#include "AliESDtrack.h"
#include "AliStack.h"
#include "AliLog.h" 
#include "AliMCInfoCuts.h" 
#include "AliMathBase.h"
#include "AliRecInfoCuts.h" 
#include "AliTreeDraw.h"
#include "AliHeader.h"
#include "AliGenEventHeader.h"

using namespace std;

ClassImp(AliPerformanceDEdx)

Bool_t AliPerformanceDEdx::fgMergeTHnSparse = kFALSE;
Bool_t AliPerformanceDEdx::fgUseMergeTHnSparse = kFALSE;

//_____________________________________________________________________________
AliPerformanceDEdx::AliPerformanceDEdx():
  AliPerformanceObject("AliPerformanceDEdx"),

  // dEdx 
  fDeDxHisto(0),
  fFolderObj(0),
  
  // Cuts 
  fCutsRC(0), 
  fCutsMC(0),

  // histogram folder 
  fAnalysisFolder(0)
{
  // default constructor	
  Init();
}

//_____________________________________________________________________________
AliPerformanceDEdx::AliPerformanceDEdx(const Char_t* name="AliPerformanceDEdx", const Char_t* title="AliPerformanceDEdx",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE):
  AliPerformanceObject(name,title),

  // dEdx 
  fDeDxHisto(0),
  fFolderObj(0),
  
  // Cuts 
  fCutsRC(0), 
  fCutsMC(0),

  // histogram folder 
  fAnalysisFolder(0)
{
  // named constructor

  SetAnalysisMode(analysisMode);
  SetHptGenerator(hptGenerator);
  Init();
}


//_____________________________________________________________________________
AliPerformanceDEdx::~AliPerformanceDEdx()
{
  // destructor
  if(fDeDxHisto)  delete fDeDxHisto; fDeDxHisto=0; 
  if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;
}

//_____________________________________________________________________________
void AliPerformanceDEdx::Init()
{
  // Init histograms
  
  // TPC dEdx
  // set p bins
  Int_t nPBins = 50;
  Double_t pMin = 1.e-2, pMax = 20.;

  Double_t *binsP = 0;

  if (IsHptGenerator())  { 
        pMax = 100.;
  } 
   binsP = CreateLogAxis(nPBins,pMin,pMax);


  /*
  Int_t nPBins = 31;
    Double_t binsP[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.};
    Double_t pMin = 0., pMax = 10.;

    if(IsHptGenerator() == kTRUE) {
      nPBins = 100;
      pMin = 0.; pMax = 100.;
    }
   */

   //dedx:alpha:y:z:snp:tgl:ncls:p
   //dedx:phi:y:z:snp:tgl:ncls:p
   //Int_t binsQA[8]    = {300, 50, 50,  50, 50, 50, 80, nPBins};
   //Double_t xminQA[8] = {0, -4,-20,-250, -1, -2, 0, pMin};
   //Double_t xmaxQA[8] = {300, 4, 20, 250,  1,  2, 160, pMax};
  Int_t binsQA[10]    = {300, 144, 50,  50, 50, 50, 80, nPBins, 80, 80};
  Double_t xminQA[10] = {0, -TMath::Pi(),-20,-250, -1, -2, 0, pMin, 0., 0.};
  Double_t xmaxQA[10] = {300, TMath::Pi(), 20, 250,  1,  2, 160, pMax ,160., 160.};

   //fDeDxHisto = new THnSparseF("fDeDxHisto","dedx:alpha:y:z:snp:tgl:ncls:momentum",8,binsQA,xminQA,xmaxQA);
   fDeDxHisto = new THnSparseF("fDeDxHisto","dedx:phi:y:z:snp:tgl:ncls:momentum:TPCSignalN:CrossedRows",10,binsQA,xminQA,xmaxQA);
   fDeDxHisto->SetBinEdges(7,binsP);

   fDeDxHisto->GetAxis(0)->SetTitle("dedx (a.u.)");
   fDeDxHisto->GetAxis(1)->SetTitle("#phi (rad)");
   fDeDxHisto->GetAxis(2)->SetTitle("y (cm)");
   fDeDxHisto->GetAxis(3)->SetTitle("z (cm)");
   fDeDxHisto->GetAxis(4)->SetTitle("sin#phi");
   fDeDxHisto->GetAxis(5)->SetTitle("tan#lambda");
   fDeDxHisto->GetAxis(6)->SetTitle("ncls");
   fDeDxHisto->GetAxis(7)->SetTitle("p (GeV/c)");
   fDeDxHisto->GetAxis(8)->SetTitle("number of cls used for dEdx");
   fDeDxHisto->GetAxis(9)->SetTitle("Crossed rows in the TPC");
   //fDeDxHisto->Sumw2();

   // Init cuts
   if(!fCutsMC) {
     AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object");
   }
   if(!fCutsRC) {
     AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object");
   }

   // init folder
   fAnalysisFolder = CreateFolder("folderDEdx","Analysis de/dx Folder");
   
   // save merge status in object
   fMergeTHnSparseObj = fgMergeTHnSparse;

}

//_____________________________________________________________________________
void AliPerformanceDEdx::ProcessTPC(AliStack* const /*stack*/, AliESDtrack *const /*esdTrack*/)
{
  // Fill dE/dx  comparison information
  AliDebug(AliLog::kWarning, "Warning: Not implemented");
}

//_____________________________________________________________________________
void AliPerformanceDEdx::ProcessInnerTPC(AliStack* const stack, AliESDtrack *const esdTrack, AliESDEvent* const esdEvent)
{
 //
 // Fill TPC track information at inner TPC wall
 // 
  if(!esdEvent) return;
  if(!esdTrack) return;

  if( IsUseTrackVertex() ) 
  { 
    // Relate TPC inner params to prim. vertex
    const AliESDVertex *vtxESD = esdEvent->GetPrimaryVertexTracks();
    Double_t x[3]; esdTrack->GetXYZ(x);
    Double_t b[3]; AliTracker::GetBxByBz(x,b);
    Bool_t isOK = kFALSE;
    if(fabs(b[2])>0.000001)
      isOK = esdTrack->RelateToVertexTPCBxByBz(vtxESD, b, kVeryBig);
    //    Bool_t isOK = esdTrack->RelateToVertexTPCBxByBz(vtxESD, b, kVeryBig);
    if(!isOK) return;

    /*
      // JMT -- recaluclate DCA for HLT if not present
      if ( dca[0] == 0. && dca[1] == 0. ) {
        track->GetDZ( vtxESD->GetX(), vtxESD->GetY(), vtxESD->GetZ(), esdEvent->GetMagneticField(), dca );
      }
    */
  }

  // get external param. at inner TPC wall
  const AliExternalTrackParam *innerParam =  esdTrack->GetInnerParam();
  if(!innerParam) return;

  Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
  esdTrack->GetImpactParametersTPC(dca,cov);

  if((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return; // TPC refit

  //
  // select primaries
  //
  Double_t dcaToVertex = -1;
  if( fCutsRC->GetDCAToVertex2D() ) 
  {
      dcaToVertex = TMath::Sqrt(dca[0]*dca[0]/fCutsRC->GetMaxDCAToVertexXY()/fCutsRC->GetMaxDCAToVertexXY()                    + dca[1]*dca[1]/fCutsRC->GetMaxDCAToVertexZ()/fCutsRC->GetMaxDCAToVertexZ()); 
  }
  if(fCutsRC->GetDCAToVertex2D() && dcaToVertex > 1) return;
  if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[0]) > fCutsRC->GetMaxDCAToVertexXY()) return;
  if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[1]) > fCutsRC->GetMaxDCAToVertexZ()) return;

  Float_t dedx = esdTrack->GetTPCsignal();
  Int_t ncls = esdTrack->GetTPCNcls();
  Int_t TPCSignalN = esdTrack->GetTPCsignalN();
  Float_t nCrossedRows = esdTrack->GetTPCClusterInfo(2,1);


  Double_t pt = innerParam->Pt();
  Double_t lam = TMath::ATan2(innerParam->Pz(),innerParam->Pt());
  Double_t p = pt/TMath::Cos(lam);
  //Double_t alpha = innerParam->GetAlpha();
  Double_t phi = TMath::ATan2(innerParam->Py(),innerParam->Px());
  //if(phi<0.) phi += 2.*TMath::Phi();
  Double_t y = innerParam->GetY();
  Double_t z = innerParam->GetZ();
  Double_t snp = innerParam->GetSnp();
  Double_t tgl = innerParam->GetTgl();

  //Double_t vDeDxHisto[8] = {dedx,alpha,y,z,snp,tgl,ncls,p};
  Double_t vDeDxHisto[10] = {dedx,phi,y,z,snp,tgl,ncls,p,TPCSignalN,nCrossedRows};
  fDeDxHisto->Fill(vDeDxHisto); 

  if(!stack) return;
}

//_____________________________________________________________________________
void AliPerformanceDEdx::ProcessTPCITS(AliStack* const /*stack*/, AliESDtrack *const /*esdTrack*/)
{
  // Fill dE/dx  comparison information
  
   AliDebug(AliLog::kWarning, "Warning: Not implemented");
}

//_____________________________________________________________________________
void AliPerformanceDEdx::ProcessConstrained(AliStack* const /*stack*/, AliESDtrack *const /*esdTrack*/)
{
  // Fill dE/dx  comparison information
  
   AliDebug(AliLog::kWarning, "Warning: Not implemented");
}

//_____________________________________________________________________________
Long64_t AliPerformanceDEdx::Merge(TCollection* const list) 
{
  // Merge list of objects (needed by PROOF)

  if (!list)
  return 0;

  if (list->IsEmpty())
  return 1;
  
  Bool_t merge = ((fgUseMergeTHnSparse && fgMergeTHnSparse) || (!fgUseMergeTHnSparse && fMergeTHnSparseObj));

  TIterator* iter = list->MakeIterator();
  TObject* obj = 0;
  TObjArray* objArrayList = 0;
  objArrayList = new TObjArray();

  // collection of generated histograms
  Int_t count=0;
  while((obj = iter->Next()) != 0) 
  {
    AliPerformanceDEdx* entry = dynamic_cast<AliPerformanceDEdx*>(obj);
    if (entry == 0) continue; 
    if (merge) {
        if ((fDeDxHisto) && (entry->fDeDxHisto)) { fDeDxHisto->Add(entry->fDeDxHisto); }        
    }
    // the analysisfolder is only merged if present
    if (entry->fFolderObj) { objArrayList->Add(entry->fFolderObj); }

    count++;
  }
  if (fFolderObj) { fFolderObj->Merge(objArrayList); } 
  // to signal that track histos were not merged: reset
  if (!merge) { fDeDxHisto->Reset(); }
  // delete
  if (objArrayList)  delete objArrayList;  objArrayList=0;  

return count;
}

//_____________________________________________________________________________
void AliPerformanceDEdx::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend)
{
  // Process comparison information 
  //
  if(!esdEvent) 
  {
      AliDebug(AliLog::kError, "esdEvent not available");
      return;
  }
  AliHeader* header = 0;
  AliGenEventHeader* genHeader = 0;
  AliStack* stack = 0;
  TArrayF vtxMC(3);
  
  if(bUseMC)
  {
    if(!mcEvent) {
      AliDebug(AliLog::kError, "mcEvent not available");
      return;
    }

    // get MC event header
    header = mcEvent->Header();
    if (!header) {
      AliDebug(AliLog::kError, "Header not available");
      return;
    }
    // MC particle stack
    stack = mcEvent->Stack();
    if (!stack) {
      AliDebug(AliLog::kError, "Stack not available");
      return;
    }

    // get MC vertex
    genHeader = header->GenEventHeader();
    if (!genHeader) {
      AliDebug(AliLog::kError, "Could not retrieve genHeader from Header");
      return;
    }
    genHeader->PrimaryVertex(vtxMC);

  } // end bUseMC

  // use ESD friends
  if(bUseESDfriend) {
    if(!esdFriend) {
      AliDebug(AliLog::kError, "esdFriend not available");
      return;
    }
  }

  // trigger
  if(!bUseMC && GetTriggerClass()) {
    Bool_t isEventTriggered = esdEvent->IsTriggerClassFired(GetTriggerClass());
    if(!isEventTriggered) return; 
  }

  // get event vertex
  const AliESDVertex *vtxESD = NULL;
  if( IsUseTrackVertex() ) 
  { 
    // track vertex
    vtxESD = esdEvent->GetPrimaryVertexTracks();
  }
  else {
    // TPC track vertex
    vtxESD = esdEvent->GetPrimaryVertexTPC();
  }
  if(vtxESD && (vtxESD->GetStatus()<=0)) return;

  //  Process events
  for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) 
  { 
    AliESDtrack *track = esdEvent->GetTrack(iTrack);
    if(!track) continue;

    if(GetAnalysisMode() == 0) ProcessTPC(stack,track);
    else if(GetAnalysisMode() == 1) ProcessTPCITS(stack,track);
    else if(GetAnalysisMode() == 2) ProcessConstrained(stack,track);
    else if(GetAnalysisMode() == 3) ProcessInnerTPC(stack,track,esdEvent);
    else {
      printf("ERROR: AnalysisMode %d \n",fAnalysisMode);
      return;
    }
  }
}

//_____________________________________________________________________________
void AliPerformanceDEdx::Analyse()
{
  // Analyze comparison information and store output histograms
  // in the folder "folderDEdx"
  //
  TH1::AddDirectory(kFALSE);
  TH1::SetDefaultSumw2(kFALSE);
  TH1F *h1D=0;
  TH2F *h2D=0;
  TObjArray *aFolderObj = new TObjArray;
  TString selString;

  char name[256];
  char title[256];

  for(Int_t i=1; i<10; i++) { 
    AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, i);
  }

    AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 6, 7);
    AddProjection(aFolderObj, "dedx", fDeDxHisto, 7, 8, 9);
    AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 8, 9);
    AddProjection(aFolderObj, "dedx", fDeDxHisto, 6, 8, 9);

  // resolution histograms for mips
  //dedx:phi:y:z:snp:tgl:ncls:p
  fDeDxHisto->GetAxis(2)->SetRangeUser(-15.,14.999);
  fDeDxHisto->GetAxis(3)->SetRangeUser(-120.,119.999);
  fDeDxHisto->GetAxis(4)->SetRangeUser(-0.4, 0.399);
  fDeDxHisto->GetAxis(5)->SetRangeUser(-0.9,0.89);
  fDeDxHisto->GetAxis(6)->SetRangeUser(60.,160.);
  fDeDxHisto->GetAxis(7)->SetRangeUser(0.4,0.499);
  fDeDxHisto->GetAxis(8)->SetRangeUser(60.,160.);
  
  
  selString = "mipsres";
  AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, &selString);

  //
  TObjArray *arr[9] = {0};
  TF1 *f1[9] = {0};
  
  for(Int_t i=0; i<9; i++) 
  { 
    arr[i] = new TObjArray;
    f1[i] = new TF1("gaus","gaus");
    //printf("i %d \n",i);

    h2D = (TH2F*)fDeDxHisto->Projection(0,i+1);

    f1[i]->SetRange(40,60); // should be pion peak
    h2D->FitSlicesY(f1[i],0,-1,10,"QNR",arr[i]); // gaus fit of pion peak

    h1D = (TH1F*)arr[i]->At(1);
    snprintf(name,256,"mean_dedx_mips_vs_%d",i);
    h1D->SetName(name);
    snprintf(title,256,"%s vs %s","mean_dedx_mips (a.u.)",fDeDxHisto->GetAxis(i)->GetTitle());
    h1D->SetTitle(title);
    h1D->GetXaxis()->SetTitle(fDeDxHisto->GetAxis(i)->GetTitle());
    h1D->GetYaxis()->SetTitle("mean_dedx_mips (a.u.)");
    //h1D->SetMinimum(40);
    //h1D->SetMaximum(60);

    aFolderObj->Add(h1D);

    h1D = (TH1F*)arr[i]->At(2);
    snprintf(name,256,"res_dedx_mips_vs_%d",i);
    h1D->SetName(name);
    snprintf(title,256,"%s vs %s","res_dedx_mips (a.u)",fDeDxHisto->GetAxis(i)->GetTitle());
    h1D->SetTitle(title);
    h1D->GetXaxis()->SetTitle(fDeDxHisto->GetAxis(i)->GetTitle());
    h1D->GetYaxis()->SetTitle("res_dedx_mips (a.u.)");
    //h1D->SetMinimum(0);
    //h1D->SetMaximum(6);

    aFolderObj->Add(h1D);
  }

    // select MIPs (version from AliTPCPerfomanceSummary)
    fDeDxHisto->GetAxis(0)->SetRangeUser(35,60);
    fDeDxHisto->GetAxis(2)->SetRangeUser(-20,20);
    fDeDxHisto->GetAxis(3)->SetRangeUser(-250,250);
    fDeDxHisto->GetAxis(4)->SetRangeUser(-1, 1);
    fDeDxHisto->GetAxis(5)->SetRangeUser(-1,1);
    fDeDxHisto->GetAxis(6)->SetRangeUser(80,160);
    fDeDxHisto->GetAxis(7)->SetRangeUser(0.4,0.55);
    fDeDxHisto->GetAxis(8)->SetRangeUser(80,160);
    fDeDxHisto->GetAxis(9)->SetRangeUser(0.5,1.);

    selString = "mips";
    AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, &selString);
    
    selString = "mips_C";
    fDeDxHisto->GetAxis(5)->SetRangeUser(-3,0);
    AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 5, &selString);
    AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 1, &selString);
    
    selString = "mips_A";
    fDeDxHisto->GetAxis(5)->SetRangeUser(0,3);
    AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 5, &selString);    
    AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 1, &selString);
    
    //restore cuts
    fDeDxHisto->GetAxis(0)->SetRangeUser(0,300);
    fDeDxHisto->GetAxis(2)->SetRangeUser(-20,20);
    fDeDxHisto->GetAxis(3)->SetRangeUser(-250,250);
    fDeDxHisto->GetAxis(4)->SetRangeUser(-1, 1);
    fDeDxHisto->GetAxis(5)->SetRangeUser(-3,3);
    fDeDxHisto->GetAxis(6)->SetRangeUser(0,160);
    fDeDxHisto->GetAxis(7)->SetRangeUser(1e-2,10);    
    fDeDxHisto->GetAxis(8)->SetRangeUser(0,160);
    fDeDxHisto->GetAxis(9)->SetRangeUser(0.,1.);


    printf("exportToFolder\n");
    // export objects to analysis folder
    fAnalysisFolder = ExportToFolder(aFolderObj);
    if (fFolderObj) delete fFolderObj;
    fFolderObj = aFolderObj;
    aFolderObj=0;


  for(Int_t i=0;i<9;i++) { 
    if(f1[i]) delete f1[i]; f1[i]=0;
  }

}

//_____________________________________________________________________________
TFolder* AliPerformanceDEdx::ExportToFolder(TObjArray * array) 
{
  // recreate folder avery time and export objects to new one
  //
  AliPerformanceDEdx * comp=this;
  TFolder *folder = comp->GetAnalysisFolder();

  TString name, title;
  TFolder *newFolder = 0;
  Int_t i = 0;
  Int_t size = array->GetSize();

  if(folder) { 
     // get name and title from old folder
     name = folder->GetName();  
     title = folder->GetTitle();  

	 // delete old one
     delete folder;

	 // create new one
     newFolder = CreateFolder(name.Data(),title.Data());
     newFolder->SetOwner();

	 // add objects to folder
     while(i < size) {
	   newFolder->Add(array->At(i));
	   i++;
	 }
  }

return newFolder;
}


//_____________________________________________________________________________
TFolder* AliPerformanceDEdx::CreateFolder(TString name,TString title) { 
// create folder for analysed histograms
TFolder *folder = 0;
  folder = new TFolder(name.Data(),title.Data());

  return folder;
}

//_____________________________________________________________________________
TTree* AliPerformanceDEdx::CreateSummary()
{
    // implementaion removed, switched back to use AliPerformanceSummary (now called in AliPerformanceTask)
    return 0;
}
Commit	Line	Data
7cc34f08	1	//------------------------------------------------------------------------------
	2	// Implementation of AliPerformanceDEdx class. It keeps information from
	3	// comparison of reconstructed and MC particle tracks. In addtion,
	4	// it keeps selection cuts used during comparison. The comparison
	5	// information is stored in the ROOT histograms. Analysis of these
	6	// histograms can be done by using Analyse() class function. The result of
	7	// the analysis (histograms/graphs) are stored in the folder which is
	8	// a data of AliPerformanceDEdx.
	9	//
	10	// Author: J.Otwinowski 04/02/2008
814d192f	11	// Changes by M.Knichel 15/10/2010
7cc34f08	12	//------------------------------------------------------------------------------
	13
	14	/*
	15
	16	// after running comparison task, read the file, and get component
2bfe5463	17	gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");
7cc34f08	18	LoadMyLibs();
	19	TFile f("Output.root");
	20	//AliPerformanceDEdx * compObj = (AliPerformanceDEdx*)f.Get("AliPerformanceDEdx");
	21	AliPerformanceDEdx * compObj = (AliPerformanceDEdx*)coutput->FindObject("AliPerformanceDEdx");
	22
	23	// Analyse comparison data
	24	compObj->Analyse();
	25
	26	// the output histograms/graphs will be stored in the folder "folderDEdx"
	27	compObj->GetAnalysisFolder()->ls("*");
	28
	29	// user can save whole comparison object (or only folder with anlysed histograms)
	30	// in the seperate output file (e.g.)
faa3b211	31	TFile fout("Analysed_DEdx.root","recreate");
	32	//compObj->Write(); // compObj->GetAnalysisFolder()->Write();
	33	compObj->GetAnalysisFolder()->Write();
7cc34f08	34	fout.Close();
	35
	36	*/
	37
814d192f	38	#include "TDirectory.h"
	39	#include "TAxis.h"
	40	#include "TCanvas.h"
	41	#include "TH1.h"
	42	#include "TH2.h"
	43	#include "TF1.h"
	44	#include "TSystem.h"
	45	#include "TChain.h"
	46
	47	#include "AliPerformanceDEdx.h"
	48	#include "AliPerformanceTPC.h"
	49	#include "AliTPCPerformanceSummary.h"
7cc34f08	50	#include "AliESDEvent.h"
758320f7	51	#include "AliTracker.h"
7cc34f08	52	#include "AliMCEvent.h"
	53	#include "AliESDtrack.h"
	54	#include "AliStack.h"
	55	#include "AliLog.h"
	56	#include "AliMCInfoCuts.h"
	57	#include "AliMathBase.h"
	58	#include "AliRecInfoCuts.h"
	59	#include "AliTreeDraw.h"
	60	#include "AliHeader.h"
	61	#include "AliGenEventHeader.h"
	62
	63	using namespace std;
	64
	65	ClassImp(AliPerformanceDEdx)
	66
28bb9d1f	67	Bool_t AliPerformanceDEdx::fgMergeTHnSparse = kFALSE;
56958768	68	Bool_t AliPerformanceDEdx::fgUseMergeTHnSparse = kFALSE;
28bb9d1f	69
7cc34f08	70	//_____________________________________________________________________________
	71	AliPerformanceDEdx::AliPerformanceDEdx():
	72	AliPerformanceObject("AliPerformanceDEdx"),
	73
	74	// dEdx
	75	fDeDxHisto(0),
28bb9d1f	76	fFolderObj(0),
7cc34f08	77
	78	// Cuts
	79	fCutsRC(0),
	80	fCutsMC(0),
	81
	82	// histogram folder
	83	fAnalysisFolder(0)
	84	{
	85	// default constructor
	86	Init();
	87	}
	88
	89	//_____________________________________________________________________________
feda9561	90	AliPerformanceDEdx::AliPerformanceDEdx(const Char_t* name="AliPerformanceDEdx", const Char_t* title="AliPerformanceDEdx",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE):
7cc34f08	91	AliPerformanceObject(name,title),
	92
	93	// dEdx
	94	fDeDxHisto(0),
28bb9d1f	95	fFolderObj(0),
7cc34f08	96
	97	// Cuts
	98	fCutsRC(0),
	99	fCutsMC(0),
	100
	101	// histogram folder
	102	fAnalysisFolder(0)
	103	{
	104	// named constructor
	105
	106	SetAnalysisMode(analysisMode);
	107	SetHptGenerator(hptGenerator);
	108	Init();
	109	}
	110
	111
	112	//_____________________________________________________________________________
	113	AliPerformanceDEdx::~AliPerformanceDEdx()
	114	{
	115	// destructor
	116	if(fDeDxHisto) delete fDeDxHisto; fDeDxHisto=0;
	117	if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0;
	118	}
	119
	120	//_____________________________________________________________________________
	121	void AliPerformanceDEdx::Init()
	122	{
	123	// Init histograms
	124
	125	// TPC dEdx
ef1ed531	126	// set p bins
7cc34f08	127	Int_t nPBins = 50;
ef1ed531	128	Double_t pMin = 1.e-2, pMax = 20.;
7cc34f08	129
7cc34f08	130	Double_t *binsP = 0;
ef1ed531	131
7cc34f08	132	if (IsHptGenerator()) {
ef1ed531	133	pMax = 100.;
	134	}
	135	binsP = CreateLogAxis(nPBins,pMin,pMax);
7cc34f08	136
	137
	138	/*
	139	Int_t nPBins = 31;
	140	Double_t binsP[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.};
	141	Double_t pMin = 0., pMax = 10.;
	142
	143	if(IsHptGenerator() == kTRUE) {
	144	nPBins = 100;
	145	pMin = 0.; pMax = 100.;
	146	}
	147	*/
	148
	149	//dedx:alpha:y:z:snp:tgl:ncls:p
	150	//dedx:phi:y:z:snp:tgl:ncls:p
	151	//Int_t binsQA[8] = {300, 50, 50, 50, 50, 50, 80, nPBins};
	152	//Double_t xminQA[8] = {0, -4,-20,-250, -1, -2, 0, pMin};
	153	//Double_t xmaxQA[8] = {300, 4, 20, 250, 1, 2, 160, pMax};
7ca3360b	154	Int_t binsQA[10] = {300, 144, 50, 50, 50, 50, 80, nPBins, 80, 80};
ef1ed531	155	Double_t xminQA[10] = {0, -TMath::Pi(),-20,-250, -1, -2, 0, pMin, 0., 0.};
7ca3360b	156	Double_t xmaxQA[10] = {300, TMath::Pi(), 20, 250, 1, 2, 160, pMax ,160., 160.};
7cc34f08	157
7cc34f08	158	//fDeDxHisto = new THnSparseF("fDeDxHisto","dedx:alpha:y:z:snp:tgl:ncls:momentum",8,binsQA,xminQA,xmaxQA);
7ca3360b	159	fDeDxHisto = new THnSparseF("fDeDxHisto","dedx:phi:y:z:snp:tgl:ncls:momentum:TPCSignalN:CrossedRows",10,binsQA,xminQA,xmaxQA);
7cc34f08	160	fDeDxHisto->SetBinEdges(7,binsP);
	161
	162	fDeDxHisto->GetAxis(0)->SetTitle("dedx (a.u.)");
	163	fDeDxHisto->GetAxis(1)->SetTitle("#phi (rad)");
	164	fDeDxHisto->GetAxis(2)->SetTitle("y (cm)");
	165	fDeDxHisto->GetAxis(3)->SetTitle("z (cm)");
	166	fDeDxHisto->GetAxis(4)->SetTitle("sin#phi");
	167	fDeDxHisto->GetAxis(5)->SetTitle("tan#lambda");
	168	fDeDxHisto->GetAxis(6)->SetTitle("ncls");
	169	fDeDxHisto->GetAxis(7)->SetTitle("p (GeV/c)");
15e4c8af	170	fDeDxHisto->GetAxis(8)->SetTitle("number of cls used for dEdx");
7ca3360b	171	fDeDxHisto->GetAxis(9)->SetTitle("Crossed rows in the TPC");
28bb9d1f	172	//fDeDxHisto->Sumw2();
7cc34f08	173
7cc34f08	174	// Init cuts
814d192f	175	if(!fCutsMC) {
7cc34f08	176	AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object");
814d192f	177	}
814d192f	178	if(!fCutsRC) {
7cc34f08	179	AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object");
814d192f	180	}
7cc34f08	181
	182	// init folder
	183	fAnalysisFolder = CreateFolder("folderDEdx","Analysis de/dx Folder");
56958768	184
	185	// save merge status in object
	186	fMergeTHnSparseObj = fgMergeTHnSparse;
	187
7cc34f08	188	}
	189
	190	//_____________________________________________________________________________
	191	void AliPerformanceDEdx::ProcessTPC(AliStack* const /stack/, AliESDtrack const /esdTrack*/)
	192	{
	193	// Fill dE/dx comparison information
	194	AliDebug(AliLog::kWarning, "Warning: Not implemented");
	195	}
	196
	197	//_____________________________________________________________________________
758320f7	198	void AliPerformanceDEdx::ProcessInnerTPC(AliStack* const stack, AliESDtrack const esdTrack, AliESDEvent const esdEvent)
7cc34f08	199	{
758320f7	200	//
	201	// Fill TPC track information at inner TPC wall
	202	//
	203	if(!esdEvent) return;
7cc34f08	204	if(!esdTrack) return;
7cc34f08	205
758320f7	206	if( IsUseTrackVertex() )
	207	{
	208	// Relate TPC inner params to prim. vertex
	209	const AliESDVertex *vtxESD = esdEvent->GetPrimaryVertexTracks();
	210	Double_t x[3]; esdTrack->GetXYZ(x);
	211	Double_t b[3]; AliTracker::GetBxByBz(x,b);
1833a193	212	Bool_t isOK = kFALSE;
	213	if(fabs(b[2])>0.000001)
	214	isOK = esdTrack->RelateToVertexTPCBxByBz(vtxESD, b, kVeryBig);
	215	// Bool_t isOK = esdTrack->RelateToVertexTPCBxByBz(vtxESD, b, kVeryBig);
758320f7	216	if(!isOK) return;
	217
	218	/*
	219	// JMT -- recaluclate DCA for HLT if not present
	220	if ( dca[0] == 0. && dca[1] == 0. ) {
	221	track->GetDZ( vtxESD->GetX(), vtxESD->GetY(), vtxESD->GetZ(), esdEvent->GetMagneticField(), dca );
	222	}
	223	*/
	224	}
	225
	226	// get external param. at inner TPC wall
7cc34f08	227	const AliExternalTrackParam *innerParam = esdTrack->GetInnerParam();
	228	if(!innerParam) return;
	229
	230	Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
	231	esdTrack->GetImpactParametersTPC(dca,cov);
	232
	233	if((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return; // TPC refit
a13f4653	234
	235	//
	236	// select primaries
	237	//
	238	Double_t dcaToVertex = -1;
	239	if( fCutsRC->GetDCAToVertex2D() )
	240	{
	241	dcaToVertex = TMath::Sqrt(dca[0]dca[0]/fCutsRC->GetMaxDCAToVertexXY()/fCutsRC->GetMaxDCAToVertexXY() + dca[1]dca[1]/fCutsRC->GetMaxDCAToVertexZ()/fCutsRC->GetMaxDCAToVertexZ());
7cc34f08	242	}
a13f4653	243	if(fCutsRC->GetDCAToVertex2D() && dcaToVertex > 1) return;
	244	if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[0]) > fCutsRC->GetMaxDCAToVertexXY()) return;
	245	if(!fCutsRC->GetDCAToVertex2D() && TMath::Abs(dca[1]) > fCutsRC->GetMaxDCAToVertexZ()) return;
	246
	247	Float_t dedx = esdTrack->GetTPCsignal();
	248	Int_t ncls = esdTrack->GetTPCNcls();
15e4c8af	249	Int_t TPCSignalN = esdTrack->GetTPCsignalN();
7ca3360b	250	Float_t nCrossedRows = esdTrack->GetTPCClusterInfo(2,1);
15e4c8af	251
a13f4653	252
	253	Double_t pt = innerParam->Pt();
	254	Double_t lam = TMath::ATan2(innerParam->Pz(),innerParam->Pt());
	255	Double_t p = pt/TMath::Cos(lam);
	256	//Double_t alpha = innerParam->GetAlpha();
	257	Double_t phi = TMath::ATan2(innerParam->Py(),innerParam->Px());
	258	//if(phi<0.) phi += 2.*TMath::Phi();
	259	Double_t y = innerParam->GetY();
	260	Double_t z = innerParam->GetZ();
	261	Double_t snp = innerParam->GetSnp();
	262	Double_t tgl = innerParam->GetTgl();
	263
	264	//Double_t vDeDxHisto[8] = {dedx,alpha,y,z,snp,tgl,ncls,p};
7ca3360b	265	Double_t vDeDxHisto[10] = {dedx,phi,y,z,snp,tgl,ncls,p,TPCSignalN,nCrossedRows};
a13f4653	266	fDeDxHisto->Fill(vDeDxHisto);
7cc34f08	267
	268	if(!stack) return;
	269	}
	270
	271	//_____________________________________________________________________________
	272	void AliPerformanceDEdx::ProcessTPCITS(AliStack* const /stack/, AliESDtrack const /esdTrack*/)
	273	{
	274	// Fill dE/dx comparison information
	275
	276	AliDebug(AliLog::kWarning, "Warning: Not implemented");
	277	}
	278
	279	//_____________________________________________________________________________
	280	void AliPerformanceDEdx::ProcessConstrained(AliStack* const /stack/, AliESDtrack const /esdTrack*/)
	281	{
	282	// Fill dE/dx comparison information
	283
	284	AliDebug(AliLog::kWarning, "Warning: Not implemented");
	285	}
	286
	287	//_____________________________________________________________________________
	288	Long64_t AliPerformanceDEdx::Merge(TCollection* const list)
	289	{
	290	// Merge list of objects (needed by PROOF)
	291
	292	if (!list)
	293	return 0;
	294
	295	if (list->IsEmpty())
	296	return 1;
56958768	297
56958768	298	Bool_t merge = ((fgUseMergeTHnSparse && fgMergeTHnSparse) \|\| (!fgUseMergeTHnSparse && fMergeTHnSparseObj));
7cc34f08	299
	300	TIterator* iter = list->MakeIterator();
	301	TObject* obj = 0;
28bb9d1f	302	TObjArray* objArrayList = 0;
28bb9d1f	303	objArrayList = new TObjArray();
7cc34f08	304
	305	// collection of generated histograms
	306	Int_t count=0;
	307	while((obj = iter->Next()) != 0)
	308	{
	309	AliPerformanceDEdx* entry = dynamic_cast<AliPerformanceDEdx*>(obj);
28bb9d1f	310	if (entry == 0) continue;
56958768	311	if (merge) {
28bb9d1f	312	if ((fDeDxHisto) && (entry->fDeDxHisto)) { fDeDxHisto->Add(entry->fDeDxHisto); }
	313	}
	314	// the analysisfolder is only merged if present
	315	if (entry->fFolderObj) { objArrayList->Add(entry->fFolderObj); }
7cc34f08	316
7cc34f08	317	count++;
7cc34f08	318	}
28bb9d1f	319	if (fFolderObj) { fFolderObj->Merge(objArrayList); }
28bb9d1f	320	// to signal that track histos were not merged: reset
56958768	321	if (!merge) { fDeDxHisto->Reset(); }
28bb9d1f	322	// delete
28bb9d1f	323	if (objArrayList) delete objArrayList; objArrayList=0;
7cc34f08	324
	325	return count;
	326	}
	327
	328	//_____________________________________________________________________________
	329	void AliPerformanceDEdx::Exec(AliMCEvent* const mcEvent, AliESDEvent const esdEvent, AliESDfriend const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend)
	330	{
	331	// Process comparison information
	332	//
	333	if(!esdEvent)
	334	{
	335	AliDebug(AliLog::kError, "esdEvent not available");
	336	return;
	337	}
	338	AliHeader* header = 0;
	339	AliGenEventHeader* genHeader = 0;
	340	AliStack* stack = 0;
	341	TArrayF vtxMC(3);
	342
	343	if(bUseMC)
	344	{
	345	if(!mcEvent) {
	346	AliDebug(AliLog::kError, "mcEvent not available");
	347	return;
	348	}
	349
	350	// get MC event header
	351	header = mcEvent->Header();
	352	if (!header) {
	353	AliDebug(AliLog::kError, "Header not available");
	354	return;
	355	}
	356	// MC particle stack
	357	stack = mcEvent->Stack();
	358	if (!stack) {
	359	AliDebug(AliLog::kError, "Stack not available");
	360	return;
	361	}
	362
	363	// get MC vertex
	364	genHeader = header->GenEventHeader();
	365	if (!genHeader) {
	366	AliDebug(AliLog::kError, "Could not retrieve genHeader from Header");
	367	return;
	368	}
	369	genHeader->PrimaryVertex(vtxMC);
	370
	371	} // end bUseMC
	372
	373	// use ESD friends
	374	if(bUseESDfriend) {
	375	if(!esdFriend) {
	376	AliDebug(AliLog::kError, "esdFriend not available");
	377	return;
	378	}
	379	}
	380
e6a60a90	381	// trigger
046b4280	382	if(!bUseMC && GetTriggerClass()) {
4bb5f8a9	383	Bool_t isEventTriggered = esdEvent->IsTriggerClassFired(GetTriggerClass());
	384	if(!isEventTriggered) return;
	385	}
7cc34f08	386
758320f7	387	// get event vertex
	388	const AliESDVertex *vtxESD = NULL;
	389	if( IsUseTrackVertex() )
	390	{
	391	// track vertex
	392	vtxESD = esdEvent->GetPrimaryVertexTracks();
	393	}
	394	else {
	395	// TPC track vertex
	396	vtxESD = esdEvent->GetPrimaryVertexTPC();
	397	}
e6a60a90	398	if(vtxESD && (vtxESD->GetStatus()<=0)) return;
7cc34f08	399
	400	// Process events
	401	for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++)
	402	{
	403	AliESDtrack *track = esdEvent->GetTrack(iTrack);
	404	if(!track) continue;
	405
	406	if(GetAnalysisMode() == 0) ProcessTPC(stack,track);
	407	else if(GetAnalysisMode() == 1) ProcessTPCITS(stack,track);
	408	else if(GetAnalysisMode() == 2) ProcessConstrained(stack,track);
758320f7	409	else if(GetAnalysisMode() == 3) ProcessInnerTPC(stack,track,esdEvent);
7cc34f08	410	else {
	411	printf("ERROR: AnalysisMode %d \n",fAnalysisMode);
	412	return;
	413	}
	414	}
	415	}
	416
	417	//_____________________________________________________________________________
	418	void AliPerformanceDEdx::Analyse()
	419	{
	420	// Analyze comparison information and store output histograms
	421	// in the folder "folderDEdx"
	422	//
	423	TH1::AddDirectory(kFALSE);
28bb9d1f	424	TH1::SetDefaultSumw2(kFALSE);
7cc34f08	425	TH1F *h1D=0;
	426	TH2F *h2D=0;
	427	TObjArray *aFolderObj = new TObjArray;
28bb9d1f	428	TString selString;
7cc34f08	429
	430	char name[256];
	431	char title[256];
	432
ef1ed531	433	for(Int_t i=1; i<10; i++) {
28bb9d1f	434	AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, i);
7cc34f08	435	}
7cc34f08	436
7ca3360b	437	AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 6, 7);
	438	AddProjection(aFolderObj, "dedx", fDeDxHisto, 7, 8, 9);
	439	AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 8, 9);
	440	AddProjection(aFolderObj, "dedx", fDeDxHisto, 6, 8, 9);
	441
7cc34f08	442	// resolution histograms for mips
a13f4653	443	//dedx:phi:y:z:snp:tgl:ncls:p
7cc34f08	444	fDeDxHisto->GetAxis(2)->SetRangeUser(-15.,14.999);
	445	fDeDxHisto->GetAxis(3)->SetRangeUser(-120.,119.999);
	446	fDeDxHisto->GetAxis(4)->SetRangeUser(-0.4, 0.399);
a13f4653	447	fDeDxHisto->GetAxis(5)->SetRangeUser(-0.9,0.89);
a13f4653	448	fDeDxHisto->GetAxis(6)->SetRangeUser(60.,160.);
7cc34f08	449	fDeDxHisto->GetAxis(7)->SetRangeUser(0.4,0.499);
15e4c8af	450	fDeDxHisto->GetAxis(8)->SetRangeUser(60.,160.);
28bb9d1f	451
	452
	453	selString = "mipsres";
	454	AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, &selString);
7cc34f08	455
7cc34f08	456	//
ef1ed531	457	TObjArray *arr[9] = {0};
ef1ed531	458	TF1 *f1[9] = {0};
7cc34f08	459
ef1ed531	460	for(Int_t i=0; i<9; i++)
7cc34f08	461	{
	462	arr[i] = new TObjArray;
	463	f1[i] = new TF1("gaus","gaus");
	464	//printf("i %d \n",i);
	465
c11cd0fa	466	h2D = (TH2F*)fDeDxHisto->Projection(0,i+1);
7cc34f08	467
	468	f1[i]->SetRange(40,60); // should be pion peak
	469	h2D->FitSlicesY(f1[i],0,-1,10,"QNR",arr[i]); // gaus fit of pion peak
	470
	471	h1D = (TH1F*)arr[i]->At(1);
18e588e9	472	snprintf(name,256,"mean_dedx_mips_vs_%d",i);
7cc34f08	473	h1D->SetName(name);
18e588e9	474	snprintf(title,256,"%s vs %s","mean_dedx_mips (a.u.)",fDeDxHisto->GetAxis(i)->GetTitle());
7cc34f08	475	h1D->SetTitle(title);
	476	h1D->GetXaxis()->SetTitle(fDeDxHisto->GetAxis(i)->GetTitle());
	477	h1D->GetYaxis()->SetTitle("mean_dedx_mips (a.u.)");
	478	//h1D->SetMinimum(40);
	479	//h1D->SetMaximum(60);
	480
	481	aFolderObj->Add(h1D);
	482
	483	h1D = (TH1F*)arr[i]->At(2);
18e588e9	484	snprintf(name,256,"res_dedx_mips_vs_%d",i);
7cc34f08	485	h1D->SetName(name);
18e588e9	486	snprintf(title,256,"%s vs %s","res_dedx_mips (a.u)",fDeDxHisto->GetAxis(i)->GetTitle());
7cc34f08	487	h1D->SetTitle(title);
	488	h1D->GetXaxis()->SetTitle(fDeDxHisto->GetAxis(i)->GetTitle());
	489	h1D->GetYaxis()->SetTitle("res_dedx_mips (a.u.)");
	490	//h1D->SetMinimum(0);
	491	//h1D->SetMaximum(6);
	492
	493	aFolderObj->Add(h1D);
	494	}
c11cd0fa	495
28bb9d1f	496	// select MIPs (version from AliTPCPerfomanceSummary)
	497	fDeDxHisto->GetAxis(0)->SetRangeUser(35,60);
	498	fDeDxHisto->GetAxis(2)->SetRangeUser(-20,20);
	499	fDeDxHisto->GetAxis(3)->SetRangeUser(-250,250);
	500	fDeDxHisto->GetAxis(4)->SetRangeUser(-1, 1);
	501	fDeDxHisto->GetAxis(5)->SetRangeUser(-1,1);
	502	fDeDxHisto->GetAxis(6)->SetRangeUser(80,160);
	503	fDeDxHisto->GetAxis(7)->SetRangeUser(0.4,0.55);
15e4c8af	504	fDeDxHisto->GetAxis(8)->SetRangeUser(80,160);
ef1ed531	505	fDeDxHisto->GetAxis(9)->SetRangeUser(0.5,1.);
15e4c8af	506
28bb9d1f	507	selString = "mips";
	508	AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, &selString);
	509
	510	selString = "mips_C";
	511	fDeDxHisto->GetAxis(5)->SetRangeUser(-3,0);
	512	AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 5, &selString);
	513	AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 1, &selString);
	514
	515	selString = "mips_A";
	516	fDeDxHisto->GetAxis(5)->SetRangeUser(0,3);
	517	AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 5, &selString);
	518	AddProjection(aFolderObj, "dedx", fDeDxHisto, 0, 1, &selString);
	519
	520	//restore cuts
	521	fDeDxHisto->GetAxis(0)->SetRangeUser(0,300);
	522	fDeDxHisto->GetAxis(2)->SetRangeUser(-20,20);
	523	fDeDxHisto->GetAxis(3)->SetRangeUser(-250,250);
	524	fDeDxHisto->GetAxis(4)->SetRangeUser(-1, 1);
	525	fDeDxHisto->GetAxis(5)->SetRangeUser(-3,3);
	526	fDeDxHisto->GetAxis(6)->SetRangeUser(0,160);
	527	fDeDxHisto->GetAxis(7)->SetRangeUser(1e-2,10);
15e4c8af	528	fDeDxHisto->GetAxis(8)->SetRangeUser(0,160);
ef1ed531	529	fDeDxHisto->GetAxis(9)->SetRangeUser(0.,1.);
	530
	531
	532
15e4c8af	533
28bb9d1f	534	printf("exportToFolder\n");
	535	// export objects to analysis folder
	536	fAnalysisFolder = ExportToFolder(aFolderObj);
	537	if (fFolderObj) delete fFolderObj;
	538	fFolderObj = aFolderObj;
	539	aFolderObj=0;
c11cd0fa	540
c11cd0fa	541
ef1ed531	542	for(Int_t i=0;i<9;i++) {
c11cd0fa	543	if(f1[i]) delete f1[i]; f1[i]=0;
	544	}
	545
7cc34f08	546	}
	547
	548	//_____________________________________________________________________________
	549	TFolder* AliPerformanceDEdx::ExportToFolder(TObjArray * array)
	550	{
	551	// recreate folder avery time and export objects to new one
	552	//
	553	AliPerformanceDEdx * comp=this;
	554	TFolder *folder = comp->GetAnalysisFolder();
	555
	556	TString name, title;
	557	TFolder *newFolder = 0;
	558	Int_t i = 0;
	559	Int_t size = array->GetSize();
	560
	561	if(folder) {
	562	// get name and title from old folder
	563	name = folder->GetName();
	564	title = folder->GetTitle();
	565
	566	// delete old one
	567	delete folder;
	568
	569	// create new one
	570	newFolder = CreateFolder(name.Data(),title.Data());
	571	newFolder->SetOwner();
	572
	573	// add objects to folder
	574	while(i < size) {
	575	newFolder->Add(array->At(i));
	576	i++;
	577	}
	578	}
	579
	580	return newFolder;
	581	}
	582
	583
	584	//_____________________________________________________________________________
	585	TFolder* AliPerformanceDEdx::CreateFolder(TString name,TString title) {
	586	// create folder for analysed histograms
	587	TFolder *folder = 0;
	588	folder = new TFolder(name.Data(),title.Data());
	589
	590	return folder;
	591	}
	592
814d192f	593	//_____________________________________________________________________________
	594	TTree* AliPerformanceDEdx::CreateSummary()
	595	{
	596	// implementaion removed, switched back to use AliPerformanceSummary (now called in AliPerformanceTask)
	597	return 0;
	598	}
	599