[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowCommonHist.cxx

/**************************************************************************
 * 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.                  *
 **************************************************************************/

#include "Riostream.h"              //needed as include
#include "AliFlowCommonConstants.h" //needed as include
#include "AliFlowCommonHist.h"
#include "AliFlowEventSimple.h"
#include "AliFlowTrackSimple.h"

#include "TString.h" 
#include "TProfile.h"
#include "TMath.h"   //needed as include
#include "TList.h"
#include "AliFlowVector.h"
#include "TBrowser.h"

class TH1F;
class TH1D;

// AliFlowCommonHist:
//
// Description: Class to organise common histograms for Flow Analysis

// authors: N. van der Kolk (kolk@nikhef.nl), A. Bilandzic (anteb@nikhef.nl), RS


ClassImp(AliFlowCommonHist)

//-----------------------------------------------------------------------

AliFlowCommonHist::AliFlowCommonHist():TNamed(),
  fHistMultOrig(NULL),
  fHistMultInt(NULL),
  fHistMultDiff(NULL),
  fHistPtInt(NULL),
  fHistPtDiff(NULL),
  fHistPhiInt(NULL),
  fHistPhiDiff(NULL),
  fHistEtaInt(NULL),
  fHistEtaDiff(NULL),
  fHistProMeanPtperBin(NULL),
  fHistQ(NULL),
  fHistList(NULL)
{
  
  //default constructor
  
}

AliFlowCommonHist::AliFlowCommonHist(const AliFlowCommonHist& a):
  TNamed(),
  fHistMultOrig(new TH1F(*a.fHistMultOrig)),
  fHistMultInt(new TH1F(*a.fHistMultInt)),
  fHistMultDiff(new TH1F(*a.fHistMultDiff)),
  fHistPtInt(new TH1F(*a.fHistPtInt)),
  fHistPtDiff(new TH1F(*a.fHistPtDiff)),
  fHistPhiInt(new TH1F(*a.fHistPhiInt)),
  fHistPhiDiff(new TH1F(*a.fHistPhiDiff)),
  fHistEtaInt(new TH1F(*a.fHistEtaInt)),
  fHistEtaDiff(new TH1F(*a.fHistEtaDiff)),
  fHistProMeanPtperBin(new TProfile(*a.fHistProMeanPtperBin)),
  fHistQ(new TH1F(*a.fHistQ)),
  fHistList(NULL)
{
  // copy constructor

  fHistList = new TList();
  fHistList-> Add(fHistMultOrig);        
  fHistList-> Add(fHistMultInt);        
  fHistList-> Add(fHistMultDiff);       
  fHistList-> Add(fHistPtInt);          
  fHistList-> Add(fHistPtDiff);         
  fHistList-> Add(fHistPhiInt);          
  fHistList-> Add(fHistPhiDiff);         
  fHistList-> Add(fHistEtaInt);          
  fHistList-> Add(fHistEtaDiff);         
  fHistList-> Add(fHistProMeanPtperBin); 
  fHistList-> Add(fHistQ);           
  //  TListIter next = TListIter(a.fHistList);

}

// AliFlowCommonHist& AliFlowCommonHist::operator=(const AliFlowCommonHist& a) 
// {
//   *fHistMultOrig = *a.fHistMultOrig;
//   *fHistMultInt = *a.fHistMultInt;
//   *fHistMultDiff = *a.fHistMultDiff;
//   *fHistPtInt = *a.fHistPtInt;
//   *fHistPtDiff = *a.fHistPtDiff;
//   *fHistPhiInt = *a.fHistPhiInt;
//   *fHistPhiDiff = *a.fHistPhiDiff;
//   *fHistEtaInt = *a.fHistEtaInt;
//   *fHistEtaDiff = *a.fHistEtaDiff;
//   *fHistProMeanPtperBin = *a.fHistProMeanPtperBin;
//   *fHistQ = *a.fHistQ;
//   //  *fHistList = *a.fHistList;
//   fHistList = NULL;
 
//   return *this;
// }

//-----------------------------------------------------------------------

  AliFlowCommonHist::AliFlowCommonHist(const char *anInput,const char *title):TNamed(anInput,title),
   fHistMultOrig(NULL),
   fHistMultInt(NULL),
   fHistMultDiff(NULL),
   fHistPtInt(NULL),
   fHistPtDiff(NULL),
   fHistPhiInt(NULL),
   fHistPhiDiff(NULL),
   fHistEtaInt(NULL),
   fHistEtaDiff(NULL),
   fHistProMeanPtperBin(NULL),
   fHistQ(NULL),
   fHistList(NULL)
 {

  //constructor creating histograms 
  Int_t iNbinsMult = AliFlowCommonConstants::GetNbinsMult();
  Int_t iNbinsPt = AliFlowCommonConstants::GetNbinsPt();
  Int_t iNbinsPhi = AliFlowCommonConstants::GetNbinsPhi();
  Int_t iNbinsEta = AliFlowCommonConstants::GetNbinsEta();
  Int_t iNbinsQ = AliFlowCommonConstants::GetNbinsQ();
  TString sName;

  Double_t  dMultMin = AliFlowCommonConstants::GetMultMin();            
  Double_t  dMultMax = AliFlowCommonConstants::GetMultMax();
  Double_t  dPtMin = AliFlowCommonConstants::GetPtMin();	     
  Double_t  dPtMax = AliFlowCommonConstants::GetPtMax();
  Double_t  dPhiMin = AliFlowCommonConstants::GetPhiMin();	     
  Double_t  dPhiMax = AliFlowCommonConstants::GetPhiMax();
  Double_t  dEtaMin = AliFlowCommonConstants::GetEtaMin();	     
  Double_t  dEtaMax = AliFlowCommonConstants::GetEtaMax();	     
  Double_t  dQMin = AliFlowCommonConstants::GetQMin();	     
  Double_t  dQMax = AliFlowCommonConstants::GetQMax();	
  
  cout<<"The settings for the common histograms are as follows:"<<endl;
  cout<<"Multiplicity: "<<iNbinsMult<<" bins between "<<dMultMin<<" and "<<dMultMax<<endl;
  cout<<"Pt: "<<iNbinsPt<<" bins between "<<dPtMin<<" and "<<dPtMax<<endl;
  cout<<"Phi: "<<iNbinsPhi<<" bins between "<<dPhiMin<<" and "<<dPhiMax<<endl;
  cout<<"Eta: "<<iNbinsEta<<" bins between "<<dEtaMin<<" and "<<dEtaMax<<endl;
  cout<<"Q: "<<iNbinsQ<<" bins between "<<dQMin<<" and "<<dQMax<<endl;

  //Multiplicity
  sName = "Control_Flow_OrigMult_";
  sName +=anInput;
  fHistMultOrig = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
  fHistMultOrig ->SetXTitle("Original Multiplicity");
  fHistMultOrig ->SetYTitle("Counts");

  sName = "Control_Flow_MultInt_";
  sName +=anInput;
  fHistMultInt = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
  fHistMultInt ->SetXTitle("Multiplicity for integrated flow");
  fHistMultInt ->SetYTitle("Counts");

  sName = "Control_Flow_MultDiff_";
  sName +=anInput;
  fHistMultDiff = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
  fHistMultDiff ->SetXTitle("Multiplicity for differential flow");
  fHistMultDiff ->SetYTitle("Counts");

  //Pt
  sName = "Control_Flow_PtInt_";
  sName +=anInput;
  fHistPtInt = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax); 
  fHistPtInt ->SetXTitle("Pt (GeV/c) for integrated flow");
  fHistPtInt ->SetYTitle("Counts");

  sName = "Control_Flow_PtDiff_";
  sName +=anInput;
  fHistPtDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax); 
  //binning has to be the same as for fHistProVPt! use to get Nprime!
  fHistPtDiff ->SetXTitle("Pt (GeV/c) for differential flow");
  fHistPtDiff ->SetYTitle("Counts");

  //Phi
  sName = "Control_Flow_PhiInt_";
  sName +=anInput;
  fHistPhiInt = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
  fHistPhiInt ->SetXTitle("Phi for integrated flow");
  fHistPhiInt ->SetYTitle("Counts");

  sName = "Control_Flow_PhiDiff_";
  sName +=anInput;
  fHistPhiDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
  fHistPhiDiff ->SetXTitle("Phi for differential flow");
  fHistPhiDiff ->SetYTitle("Counts");

  //Eta
  sName = "Control_Flow_EtaInt_";
  sName +=anInput;
  fHistEtaInt = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
  fHistEtaInt ->SetXTitle("Eta for integrated flow");
  fHistEtaInt ->SetYTitle("Counts");

  sName = "Control_Flow_EtaDiff_";
  sName +=anInput;
  fHistEtaDiff = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
  fHistEtaDiff ->SetXTitle("Eta for differential flow");
  fHistEtaDiff ->SetYTitle("Counts");

  //Mean Pt per pt bin 
  sName = "Control_FlowPro_MeanPtperBin_";
  sName +=anInput;
  fHistProMeanPtperBin = new TProfile(sName.Data(), sName.Data(),iNbinsPt,dPtMin,dPtMax);
  fHistProMeanPtperBin ->SetXTitle("Pt");
  fHistProMeanPtperBin ->SetYTitle("<Pt>");

  //Q vector
  sName = "Control_Flow_Q_";
  sName +=anInput;
  fHistQ = new TH1F(sName.Data(), sName.Data(),iNbinsQ, dQMin, dQMax);
  fHistQ ->SetXTitle("Qvector/Mult");
  fHistQ ->SetYTitle("Counts");  

  //list of histograms if added here also add in copy constructor
  fHistList = new TList();
  fHistList-> Add(fHistMultOrig);        
  fHistList-> Add(fHistMultInt);        
  fHistList-> Add(fHistMultDiff);       
  fHistList-> Add(fHistPtInt);          
  fHistList-> Add(fHistPtDiff);         
  fHistList-> Add(fHistPhiInt);          
  fHistList-> Add(fHistPhiDiff);         
  fHistList-> Add(fHistEtaInt);          
  fHistList-> Add(fHistEtaDiff);         
  fHistList-> Add(fHistProMeanPtperBin); 
  fHistList-> Add(fHistQ);           


}


//----------------------------------------------------------------------- 

AliFlowCommonHist::~AliFlowCommonHist()
{
  //deletes histograms
  delete fHistMultOrig;      
  delete fHistMultInt;       
  delete fHistMultDiff;      
  delete fHistPtInt;         
  delete fHistPtDiff;       
  delete fHistPhiInt;        
  delete fHistPhiDiff;       
  delete fHistEtaInt;        
  delete fHistEtaDiff;
  delete fHistProMeanPtperBin;
  delete fHistQ;
  delete fHistList;
}


//----------------------------------------------------------------------- 

Bool_t AliFlowCommonHist::FillControlHistograms(AliFlowEventSimple* anEvent)
{
  //Fills the control histograms
  if (!anEvent){
    cout<<"##### FillControlHistograms: FlowEvent pointer null"<<endl;
    return kFALSE;
  }

  Double_t dPt, dPhi, dEta;


  //fill the histograms
  Int_t iNumberOfTracks = anEvent->NumberOfTracks();
  fHistMultOrig->Fill(iNumberOfTracks);

  AliFlowVector vQ = anEvent->GetQ(); 
  //weight by the Multiplicity
  Double_t dQX = vQ.X()/vQ.GetMult();
  Double_t dQY = vQ.Y()/vQ.GetMult();
  vQ.Set(dQX,dQY);
  fHistQ->Fill(vQ.Mod());

  Int_t iMultInt = 0;
  Int_t iMultDiff = 0;
  
  AliFlowTrackSimple* pTrack = NULL;     

  for (Int_t i=0;i<iNumberOfTracks;i++) {
    pTrack = anEvent->GetTrack(i);
    if (pTrack ) {
      if (pTrack->UseForIntegratedFlow()){
	dPt = pTrack->Pt();
	fHistPtInt->Fill(dPt);
	dPhi = pTrack->Phi();
	if (dPhi<0.) dPhi+=2*TMath::Pi();
	fHistPhiInt->Fill(dPhi);
	dEta = pTrack->Eta();
	fHistEtaInt->Fill(dEta);
	iMultInt++;
      }
      if (pTrack->UseForDifferentialFlow()){
	dPt = pTrack->Pt();
	fHistPtDiff->Fill(dPt);
	dPhi = pTrack->Phi();
	if (dPhi<0.) dPhi+=2*TMath::Pi();
	fHistPhiDiff->Fill(dPhi);
	dEta = pTrack->Eta();
	fHistEtaDiff->Fill(dEta);
	fHistProMeanPtperBin->Fill(dPt,dPt);
	iMultDiff++;
      }
    } //track
  } //loop over tracks
  
  fHistMultInt->Fill(iMultInt);
  fHistMultDiff->Fill(iMultDiff);

  return kTRUE; 
}

//----------------------------------------------------------------------- 

Double_t AliFlowCommonHist::GetEntriesInPtBin(Int_t aBin)
{
  //get entries in bin aBin from fHistPtDiff
  Double_t dEntries = fHistPtDiff->GetBinContent(aBin);

  return dEntries;

}

//----------------------------------------------------------------------- 

Double_t AliFlowCommonHist::GetMeanPt(Int_t aBin)
{  
  //Get entry from bin aBin from fHistProMeanPtperBin
  Double_t dMeanPt = fHistProMeanPtperBin->GetBinContent(aBin);

  return dMeanPt;
  
}


//----------------------------------------------------------------------- 
 Double_t AliFlowCommonHist::Merge(TCollection *aList)
{
  //merge fuction
  cout<<"entering merge function"<<endl;
  if (!aList) return 0;
  if (aList->IsEmpty()) return 0; //no merging is needed

  Int_t iCount = 0;
  TIter next(aList); // list is supposed to contain only objects of the same type as this
  AliFlowCommonHist *toMerge;
  // make a temporary list
  TList *pTemp = new TList();
  while ((toMerge=(AliFlowCommonHist*)next())) {
    pTemp->Add(toMerge->GetHistList()); 
    iCount++;
  }
  // Now call merge for fHistList providing temp list
  fHistList->Merge(pTemp);
  // Cleanup
  delete pTemp;
    
  cout<<"Merged"<<endl;
  return (double)iCount;
    
}

void AliFlowCommonHist::Print(Option_t *option) const
{
  //   -*-*-*-*-*Print some global quantities for this histogram collection class *-*-*-*-*-*-*-*
  //             ===============================================
  //   printf( "TH1.Print Name  = %s, Entries= %d, Total sum= %g\n",GetName(),Int_t(fEntries),GetSumOfWeights());
  printf( "Class.Print Name = %s, Histogram list:\n",GetName());

  if (fHistList) {  
    fHistList->Print(option);
  }
  else
    {
      printf( "Empty histogram list \n");
    }
}

//----------------------------------------------------------------------- 
 void AliFlowCommonHist::Browse(TBrowser *b)
{

  if (!b) return;
  if (fHistList) b->Add(fHistList,"AliFlowCommonHistList");
}
Commit	Line	Data
f1d945a1	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
f1d945a1	16	#include "Riostream.h" //needed as include
	17	#include "AliFlowCommonConstants.h" //needed as include
	18	#include "AliFlowCommonHist.h"
	19	#include "AliFlowEventSimple.h"
	20	#include "AliFlowTrackSimple.h"
	21
	22	#include "TString.h"
	23	#include "TProfile.h"
	24	#include "TMath.h" //needed as include
e35ddff0	25	#include "TList.h"
f1d945a1	26	#include "AliFlowVector.h"
04f6283b	27	#include "TBrowser.h"
f1d945a1	28
	29	class TH1F;
	30	class TH1D;
	31
	32	// AliFlowCommonHist:
	33	//
	34	// Description: Class to organise common histograms for Flow Analysis
	35
20c03187	36	// authors: N. van der Kolk (kolk@nikhef.nl), A. Bilandzic (anteb@nikhef.nl), RS
f1d945a1	37
	38
	39	ClassImp(AliFlowCommonHist)
	40
	41	//-----------------------------------------------------------------------
	42
7573885c	43	AliFlowCommonHist::AliFlowCommonHist():TNamed(),
	44	fHistMultOrig(NULL),
	45	fHistMultInt(NULL),
	46	fHistMultDiff(NULL),
	47	fHistPtInt(NULL),
	48	fHistPtDiff(NULL),
	49	fHistPhiInt(NULL),
	50	fHistPhiDiff(NULL),
	51	fHistEtaInt(NULL),
	52	fHistEtaDiff(NULL),
	53	fHistProMeanPtperBin(NULL),
	54	fHistQ(NULL),
	55	fHistList(NULL)
	56	{
	57
	58	//default constructor
	59
	60	}
	61
	62	AliFlowCommonHist::AliFlowCommonHist(const AliFlowCommonHist& a):
	63	TNamed(),
	64	fHistMultOrig(new TH1F(*a.fHistMultOrig)),
	65	fHistMultInt(new TH1F(*a.fHistMultInt)),
	66	fHistMultDiff(new TH1F(*a.fHistMultDiff)),
	67	fHistPtInt(new TH1F(*a.fHistPtInt)),
	68	fHistPtDiff(new TH1F(*a.fHistPtDiff)),
	69	fHistPhiInt(new TH1F(*a.fHistPhiInt)),
	70	fHistPhiDiff(new TH1F(*a.fHistPhiDiff)),
	71	fHistEtaInt(new TH1F(*a.fHistEtaInt)),
	72	fHistEtaDiff(new TH1F(*a.fHistEtaDiff)),
	73	fHistProMeanPtperBin(new TProfile(*a.fHistProMeanPtperBin)),
	74	fHistQ(new TH1F(*a.fHistQ)),
	75	fHistList(NULL)
	76	{
	77	// copy constructor
e35ddff0	78
7573885c	79	fHistList = new TList();
	80	fHistList-> Add(fHistMultOrig);
	81	fHistList-> Add(fHistMultInt);
	82	fHistList-> Add(fHistMultDiff);
	83	fHistList-> Add(fHistPtInt);
	84	fHistList-> Add(fHistPtDiff);
	85	fHistList-> Add(fHistPhiInt);
	86	fHistList-> Add(fHistPhiDiff);
	87	fHistList-> Add(fHistEtaInt);
	88	fHistList-> Add(fHistEtaDiff);
	89	fHistList-> Add(fHistProMeanPtperBin);
	90	fHistList-> Add(fHistQ);
	91	// TListIter next = TListIter(a.fHistList);
	92
	93	}
	94
04f6283b	95	// AliFlowCommonHist& AliFlowCommonHist::operator=(const AliFlowCommonHist& a)
	96	// {
	97	// fHistMultOrig = a.fHistMultOrig;
	98	// fHistMultInt = a.fHistMultInt;
	99	// fHistMultDiff = a.fHistMultDiff;
	100	// fHistPtInt = a.fHistPtInt;
	101	// fHistPtDiff = a.fHistPtDiff;
	102	// fHistPhiInt = a.fHistPhiInt;
	103	// fHistPhiDiff = a.fHistPhiDiff;
	104	// fHistEtaInt = a.fHistEtaInt;
	105	// fHistEtaDiff = a.fHistEtaDiff;
	106	// fHistProMeanPtperBin = a.fHistProMeanPtperBin;
	107	// fHistQ = a.fHistQ;
	108	// // fHistList = a.fHistList;
	109	// fHistList = NULL;
7573885c	110
04f6283b	111	// return *this;
04f6283b	112	// }
e35ddff0	113
	114	//-----------------------------------------------------------------------
	115
20c03187	116	AliFlowCommonHist::AliFlowCommonHist(const char anInput,const char title):TNamed(anInput,title),
e35ddff0	117	fHistMultOrig(NULL),
	118	fHistMultInt(NULL),
	119	fHistMultDiff(NULL),
	120	fHistPtInt(NULL),
	121	fHistPtDiff(NULL),
	122	fHistPhiInt(NULL),
	123	fHistPhiDiff(NULL),
	124	fHistEtaInt(NULL),
	125	fHistEtaDiff(NULL),
	126	fHistProMeanPtperBin(NULL),
	127	fHistQ(NULL),
	128	fHistList(NULL)
	129	{
	130
f1d945a1	131	//constructor creating histograms
e35ddff0	132	Int_t iNbinsMult = AliFlowCommonConstants::GetNbinsMult();
	133	Int_t iNbinsPt = AliFlowCommonConstants::GetNbinsPt();
	134	Int_t iNbinsPhi = AliFlowCommonConstants::GetNbinsPhi();
	135	Int_t iNbinsEta = AliFlowCommonConstants::GetNbinsEta();
	136	Int_t iNbinsQ = AliFlowCommonConstants::GetNbinsQ();
	137	TString sName;
	138
	139	Double_t dMultMin = AliFlowCommonConstants::GetMultMin();
	140	Double_t dMultMax = AliFlowCommonConstants::GetMultMax();
	141	Double_t dPtMin = AliFlowCommonConstants::GetPtMin();
	142	Double_t dPtMax = AliFlowCommonConstants::GetPtMax();
	143	Double_t dPhiMin = AliFlowCommonConstants::GetPhiMin();
	144	Double_t dPhiMax = AliFlowCommonConstants::GetPhiMax();
	145	Double_t dEtaMin = AliFlowCommonConstants::GetEtaMin();
	146	Double_t dEtaMax = AliFlowCommonConstants::GetEtaMax();
	147	Double_t dQMin = AliFlowCommonConstants::GetQMin();
	148	Double_t dQMax = AliFlowCommonConstants::GetQMax();
f1d945a1	149
f1d945a1	150	cout<<"The settings for the common histograms are as follows:"<<endl;
e35ddff0	151	cout<<"Multiplicity: "<<iNbinsMult<<" bins between "<<dMultMin<<" and "<<dMultMax<<endl;
	152	cout<<"Pt: "<<iNbinsPt<<" bins between "<<dPtMin<<" and "<<dPtMax<<endl;
	153	cout<<"Phi: "<<iNbinsPhi<<" bins between "<<dPhiMin<<" and "<<dPhiMax<<endl;
	154	cout<<"Eta: "<<iNbinsEta<<" bins between "<<dEtaMin<<" and "<<dEtaMax<<endl;
	155	cout<<"Q: "<<iNbinsQ<<" bins between "<<dQMin<<" and "<<dQMax<<endl;
f1d945a1	156
f1d945a1	157	//Multiplicity
e35ddff0	158	sName = "Control_Flow_OrigMult_";
	159	sName +=anInput;
	160	fHistMultOrig = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
f1d945a1	161	fHistMultOrig ->SetXTitle("Original Multiplicity");
	162	fHistMultOrig ->SetYTitle("Counts");
	163
e35ddff0	164	sName = "Control_Flow_MultInt_";
	165	sName +=anInput;
	166	fHistMultInt = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
f1d945a1	167	fHistMultInt ->SetXTitle("Multiplicity for integrated flow");
	168	fHistMultInt ->SetYTitle("Counts");
	169
e35ddff0	170	sName = "Control_Flow_MultDiff_";
	171	sName +=anInput;
	172	fHistMultDiff = new TH1F(sName.Data(), sName.Data(),iNbinsMult, dMultMin, dMultMax);
f1d945a1	173	fHistMultDiff ->SetXTitle("Multiplicity for differential flow");
	174	fHistMultDiff ->SetYTitle("Counts");
	175
	176	//Pt
e35ddff0	177	sName = "Control_Flow_PtInt_";
	178	sName +=anInput;
	179	fHistPtInt = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
f1d945a1	180	fHistPtInt ->SetXTitle("Pt (GeV/c) for integrated flow");
	181	fHistPtInt ->SetYTitle("Counts");
	182
e35ddff0	183	sName = "Control_Flow_PtDiff_";
	184	sName +=anInput;
	185	fHistPtDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPt, dPtMin, dPtMax);
f1d945a1	186	//binning has to be the same as for fHistProVPt! use to get Nprime!
	187	fHistPtDiff ->SetXTitle("Pt (GeV/c) for differential flow");
	188	fHistPtDiff ->SetYTitle("Counts");
	189
	190	//Phi
e35ddff0	191	sName = "Control_Flow_PhiInt_";
	192	sName +=anInput;
	193	fHistPhiInt = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
f1d945a1	194	fHistPhiInt ->SetXTitle("Phi for integrated flow");
	195	fHistPhiInt ->SetYTitle("Counts");
	196
e35ddff0	197	sName = "Control_Flow_PhiDiff_";
	198	sName +=anInput;
	199	fHistPhiDiff = new TH1F(sName.Data(), sName.Data(),iNbinsPhi, dPhiMin, dPhiMax);
f1d945a1	200	fHistPhiDiff ->SetXTitle("Phi for differential flow");
	201	fHistPhiDiff ->SetYTitle("Counts");
	202
	203	//Eta
e35ddff0	204	sName = "Control_Flow_EtaInt_";
	205	sName +=anInput;
	206	fHistEtaInt = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
f1d945a1	207	fHistEtaInt ->SetXTitle("Eta for integrated flow");
	208	fHistEtaInt ->SetYTitle("Counts");
	209
e35ddff0	210	sName = "Control_Flow_EtaDiff_";
	211	sName +=anInput;
	212	fHistEtaDiff = new TH1F(sName.Data(), sName.Data(),iNbinsEta, dEtaMin, dEtaMax);
f1d945a1	213	fHistEtaDiff ->SetXTitle("Eta for differential flow");
	214	fHistEtaDiff ->SetYTitle("Counts");
	215
	216	//Mean Pt per pt bin
e35ddff0	217	sName = "Control_FlowPro_MeanPtperBin_";
	218	sName +=anInput;
	219	fHistProMeanPtperBin = new TProfile(sName.Data(), sName.Data(),iNbinsPt,dPtMin,dPtMax);
f1d945a1	220	fHistProMeanPtperBin ->SetXTitle("Pt");
	221	fHistProMeanPtperBin ->SetYTitle("<Pt>");
	222
	223	//Q vector
e35ddff0	224	sName = "Control_Flow_Q_";
	225	sName +=anInput;
	226	fHistQ = new TH1F(sName.Data(), sName.Data(),iNbinsQ, dQMin, dQMax);
f1d945a1	227	fHistQ ->SetXTitle("Qvector/Mult");
f1d945a1	228	fHistQ ->SetYTitle("Counts");
e35ddff0	229
7573885c	230	//list of histograms if added here also add in copy constructor
e35ddff0	231	fHistList = new TList();
	232	fHistList-> Add(fHistMultOrig);
	233	fHistList-> Add(fHistMultInt);
	234	fHistList-> Add(fHistMultDiff);
	235	fHistList-> Add(fHistPtInt);
	236	fHistList-> Add(fHistPtDiff);
	237	fHistList-> Add(fHistPhiInt);
	238	fHistList-> Add(fHistPhiDiff);
	239	fHistList-> Add(fHistEtaInt);
	240	fHistList-> Add(fHistEtaDiff);
	241	fHistList-> Add(fHistProMeanPtperBin);
	242	fHistList-> Add(fHistQ);
	243
	244
	245
f1d945a1	246	}
	247
	248
	249	//-----------------------------------------------------------------------
	250
	251	AliFlowCommonHist::~AliFlowCommonHist()
	252	{
	253	//deletes histograms
	254	delete fHistMultOrig;
	255	delete fHistMultInt;
	256	delete fHistMultDiff;
	257	delete fHistPtInt;
	258	delete fHistPtDiff;
	259	delete fHistPhiInt;
	260	delete fHistPhiDiff;
	261	delete fHistEtaInt;
	262	delete fHistEtaDiff;
	263	delete fHistProMeanPtperBin;
	264	delete fHistQ;
e35ddff0	265	delete fHistList;
f1d945a1	266	}
	267
	268
	269	//-----------------------------------------------------------------------
	270
e35ddff0	271	Bool_t AliFlowCommonHist::FillControlHistograms(AliFlowEventSimple* anEvent)
f1d945a1	272	{
f1d945a1	273	//Fills the control histograms
e35ddff0	274	if (!anEvent){
f1d945a1	275	cout<<"##### FillControlHistograms: FlowEvent pointer null"<<endl;
	276	return kFALSE;
	277	}
	278
e35ddff0	279	Double_t dPt, dPhi, dEta;
f1d945a1	280
	281
	282	//fill the histograms
e35ddff0	283	Int_t iNumberOfTracks = anEvent->NumberOfTracks();
e35ddff0	284	fHistMultOrig->Fill(iNumberOfTracks);
f1d945a1	285
e35ddff0	286	AliFlowVector vQ = anEvent->GetQ();
f1d945a1	287	//weight by the Multiplicity
e35ddff0	288	Double_t dQX = vQ.X()/vQ.GetMult();
	289	Double_t dQY = vQ.Y()/vQ.GetMult();
	290	vQ.Set(dQX,dQY);
	291	fHistQ->Fill(vQ.Mod());
f1d945a1	292
e35ddff0	293	Int_t iMultInt = 0;
e35ddff0	294	Int_t iMultDiff = 0;
7ffdc193	295
e35ddff0	296	AliFlowTrackSimple* pTrack = NULL;
	297
	298	for (Int_t i=0;i<iNumberOfTracks;i++) {
	299	pTrack = anEvent->GetTrack(i);
	300	if (pTrack ) {
	301	if (pTrack->UseForIntegratedFlow()){
	302	dPt = pTrack->Pt();
	303	fHistPtInt->Fill(dPt);
	304	dPhi = pTrack->Phi();
	305	if (dPhi<0.) dPhi+=2*TMath::Pi();
	306	fHistPhiInt->Fill(dPhi);
	307	dEta = pTrack->Eta();
	308	fHistEtaInt->Fill(dEta);
	309	iMultInt++;
f1d945a1	310	}
e35ddff0	311	if (pTrack->UseForDifferentialFlow()){
	312	dPt = pTrack->Pt();
	313	fHistPtDiff->Fill(dPt);
	314	dPhi = pTrack->Phi();
	315	if (dPhi<0.) dPhi+=2*TMath::Pi();
	316	fHistPhiDiff->Fill(dPhi);
	317	dEta = pTrack->Eta();
	318	fHistEtaDiff->Fill(dEta);
	319	fHistProMeanPtperBin->Fill(dPt,dPt);
	320	iMultDiff++;
f1d945a1	321	}
	322	} //track
	323	} //loop over tracks
	324
e35ddff0	325	fHistMultInt->Fill(iMultInt);
e35ddff0	326	fHistMultDiff->Fill(iMultDiff);
f1d945a1	327
	328	return kTRUE;
	329	}
	330
	331	//-----------------------------------------------------------------------
	332
e35ddff0	333	Double_t AliFlowCommonHist::GetEntriesInPtBin(Int_t aBin)
f1d945a1	334	{
e35ddff0	335	//get entries in bin aBin from fHistPtDiff
e35ddff0	336	Double_t dEntries = fHistPtDiff->GetBinContent(aBin);
f1d945a1	337
e35ddff0	338	return dEntries;
f1d945a1	339
	340	}
	341
	342	//-----------------------------------------------------------------------
	343
e35ddff0	344	Double_t AliFlowCommonHist::GetMeanPt(Int_t aBin)
f1d945a1	345	{
e35ddff0	346	//Get entry from bin aBin from fHistProMeanPtperBin
e35ddff0	347	Double_t dMeanPt = fHistProMeanPtperBin->GetBinContent(aBin);
f1d945a1	348
e35ddff0	349	return dMeanPt;
f1d945a1	350
0683b7d5	351	}
	352
	353
e35ddff0	354	//-----------------------------------------------------------------------
	355	Double_t AliFlowCommonHist::Merge(TCollection *aList)
	356	{
	357	//merge fuction
	358	cout<<"entering merge function"<<endl;
	359	if (!aList) return 0;
	360	if (aList->IsEmpty()) return 0; //no merging is needed
	361
	362	Int_t iCount = 0;
	363	TIter next(aList); // list is supposed to contain only objects of the same type as this
	364	AliFlowCommonHist *toMerge;
	365	// make a temporary list
	366	TList *pTemp = new TList();
	367	while ((toMerge=(AliFlowCommonHist*)next())) {
	368	pTemp->Add(toMerge->GetHistList());
	369	iCount++;
	370	}
	371	// Now call merge for fHistList providing temp list
	372	fHistList->Merge(pTemp);
	373	// Cleanup
	374	delete pTemp;
	375
	376	cout<<"Merged"<<endl;
	377	return (double)iCount;
	378
	379	}
	380
9825d4a9	381	void AliFlowCommonHist::Print(Option_t *option) const
9825d4a9	382	{
20c03187	383	// -----Print some global quantities for this histogram collection class -------*
20c03187	384	// ===============================================
9825d4a9	385	// printf( "TH1.Print Name = %s, Entries= %d, Total sum= %g\n",GetName(),Int_t(fEntries),GetSumOfWeights());
20c03187	386	printf( "Class.Print Name = %s, Histogram list:\n",GetName());
099e1753	387
	388	if (fHistList) {
	389	fHistList->Print(option);
	390	}
	391	else
	392	{
	393	printf( "Empty histogram list \n");
	394	}
9825d4a9	395	}
9825d4a9	396
04f6283b	397	//-----------------------------------------------------------------------
	398	void AliFlowCommonHist::Browse(TBrowser *b)
	399	{
9825d4a9	400
04f6283b	401	if (!b) return;
	402	if (fHistList) b->Add(fHistList,"AliFlowCommonHistList");
	403	}
9825d4a9	404
e35ddff0	405
	406
	407