AliAnalysisTaskCounter(const char *name);
virtual ~AliAnalysisTaskCounter() ;
- private:
- AliAnalysisTaskCounter(const AliAnalysisTaskCounter&); // not implemented
- AliAnalysisTaskCounter& operator=(const AliAnalysisTaskCounter&); // not implemented
-
- public:
-
virtual void UserCreateOutputObjects();
virtual void UserExec(Option_t *option);
virtual void FinishTaskOutput();
- void SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta ; }
- void SetZVertexCut(Float_t vcut) { fZVertexCut = vcut ; }
+ void SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta ; }
+ void SetZVertexCut(Float_t vcut) { fZVertexCut = vcut ; }
- void SwitchOnCaloFilterPatch() { fCaloFilterPatch = kTRUE ; }
- void SwitchOffCaloFilterPatch() { fCaloFilterPatch = kFALSE ; }
- Bool_t IsCaloFilterPatchOn() { return fCaloFilterPatch ; }
+ void SwitchOnCaloFilterPatch() { fCaloFilterPatch = kTRUE ; }
+ void SwitchOffCaloFilterPatch() { fCaloFilterPatch = kFALSE ; }
+ Bool_t IsCaloFilterPatchOn() const { return fCaloFilterPatch ; }
- void AcceptFastCluster() { fAcceptFastCluster = kTRUE ; }
- void RejectFastCluster() { fAcceptFastCluster = kFALSE ; }
- Bool_t IsFastClusterAccepted() { return fAcceptFastCluster ; }
+ void AcceptFastCluster() { fAcceptFastCluster = kTRUE ; }
+ void RejectFastCluster() { fAcceptFastCluster = kFALSE ; }
+ Bool_t IsFastClusterAccepted() const { return fAcceptFastCluster ; }
- Bool_t CheckForPrimaryVertex() ;
+ Bool_t CheckForPrimaryVertex() ;
private:
Bool_t fAcceptFastCluster; // Accept events from fast cluster, exclude thiese events for LHC11a
TH1F * fhYGoodVertex; //! Y Vertex good distribution
TH1F * fhZGoodVertex; //! Z Vertex good distribution
+ AliAnalysisTaskCounter(const AliAnalysisTaskCounter&); // not implemented
+ AliAnalysisTaskCounter& operator=(const AliAnalysisTaskCounter&); // not implemented
+
ClassDef(AliAnalysisTaskCounter, 1);
};
-#ifndef AliAnalysisTaskParticleCorrelationM_H
-#define AliAnalysisTaskParticleCorrelationM_H
+#ifndef ALIANALYSISTASKPARTICLECORRELATIONM_H
+#define ALIANALYSISTASKPARTICLECORRELATIONM_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
ClassDef(AliAnalysisTaskParticleCorrelationM, 3); // Analysis task for standard gamma correlation analysis
};
-#endif //AliAnalysisTaskParticleCorrelationM_H
+#endif //ALIANALYSISTASKPARTICLECORRELATIONM_H
#include <TString.h>
#include <TList.h>
-//---- ANALYSIS system ----
+// ---- ANALYSIS system ----
#include "AliCaloPID.h"
#include "AliVCluster.h"
#include "AliVTrack.h"
#include "AliCalorimeterUtils.h"
#include "AliVEvent.h"
+// ---- Detector ----
+#include "AliEMCALPIDUtils.h"
+
ClassImp(AliCaloPID)
}
+//______________________________________________
+AliEMCALPIDUtils *AliCaloPID::GetEMCALPIDUtils()
+{
+ // return pointer to AliEMCALPIDUtils, create it if needed
+
+ if(!fEMCALPIDUtils) fEMCALPIDUtils = new AliEMCALPIDUtils ;
+ return fEMCALPIDUtils ;
+
+}
+
+
//______________________________________________________________________
Int_t AliCaloPID::GetIdentifiedParticleType(const TString calo,
const TLorentzVector mom,
//--- AliRoot system ---
class AliVCluster;
class AliAODPWG4Particle;
-#include "AliEMCALPIDUtils.h"
+class AliEMCALPIDUtils;
class AliCalorimeterUtils;
class AliVEvent;
AliCaloPID(const Int_t particleFlux) ; // ctor, to be used when recalculating bayesian PID
AliCaloPID(const TNamed * emcalpid) ; // ctor, to be used when recalculating bayesian PID and need different parameters
virtual ~AliCaloPID() ;//virtual dtor
-
-private:
- AliCaloPID & operator = (const AliCaloPID & g) ;//cpy assignment
- AliCaloPID(const AliCaloPID & g) ; // cpy ctor
-
-public:
-
+
enum PidType {
kPhoton = 22,
kPi0 = 111,
void SwitchOnBayesianRecalculation() { fRecalculateBayesian = kTRUE ; fUseBayesianWeights = kTRUE ;} // EMCAL
void SwitchOffBayesianRecalculation() { fRecalculateBayesian = kFALSE; } // EMCAL
- AliEMCALPIDUtils * GetEMCALPIDUtils() {
- if(!fEMCALPIDUtils) fEMCALPIDUtils = new AliEMCALPIDUtils;
- return fEMCALPIDUtils ; }
+ AliEMCALPIDUtils * GetEMCALPIDUtils() ;
//Weight getters
Float_t GetEMCALPhotonWeight() const { return fEMCALPhotonWeight ; }
TH2F *fhTrackMatchedDPhi ; //! Phi distance between track and cluster vs cluster E
TH2F *fhTrackMatchedDEtaDPhi ; //! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV
+ AliCaloPID & operator = (const AliCaloPID & g) ; // cpy assignment
+ AliCaloPID(const AliCaloPID & g) ; // cpy ctor
+
ClassDef(AliCaloPID,10)
} ;
AliCaloTrackAODReader() ; // ctor
virtual ~AliCaloTrackAODReader() {;} //virtual dtor
-
-private:
- AliCaloTrackAODReader(const AliCaloTrackAODReader & ) ; // cpy ctor
- AliCaloTrackAODReader & operator = (const AliCaloTrackAODReader & g) ;//cpy assignment
-
-public:
-
+
AliCentrality* GetCentrality() const ;
void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ;
AliVEvent *fOrgInputEvent; //! Original input event, not from filtering
+ AliCaloTrackAODReader(const AliCaloTrackAODReader & ) ; // cpy ctor
+ AliCaloTrackAODReader & operator = (const AliCaloTrackAODReader & g) ;//cpy assignment
+
ClassDef(AliCaloTrackAODReader,6)
} ;
public:
AliCaloTrackMCReader() ; // ctor
virtual ~AliCaloTrackMCReader() ;//virtual dtor
- private :
- AliCaloTrackMCReader(const AliCaloTrackMCReader & g) ; // cpy ctor
- AliCaloTrackMCReader & operator = (const AliCaloTrackMCReader & g) ;//cpy assignment
-public:
void InitParameters();
void Print(const Option_t * opt) const;
Int_t fIndex2ndPhoton; // Check overlap of first decay photon already done, internal use.
Bool_t fOnlyGeneratorParticles; // Use particles only generated by PYTHIA/HERWIG/... and not by the MC tranport G3/G4/FLUKA ...
+ AliCaloTrackMCReader(const AliCaloTrackMCReader & g) ; // cpy ctor
+ AliCaloTrackMCReader & operator = (const AliCaloTrackMCReader & g) ;//cpy assignment
+
ClassDef(AliCaloTrackMCReader,4)
} ;
// --- ROOT system ---
#include <TFile.h>
-//---- ANALYSIS system ----
+// ---- ANALYSIS system ----
#include "AliMCEvent.h"
#include "AliAODMCHeader.h"
#include "AliGenPythiaEventHeader.h"
#include "AliESDtrackCuts.h"
#include "AliTriggerAnalysis.h"
#include "AliESDVZERO.h"
+#include "AliVCaloCells.h"
-//---- PartCorr/EMCAL ---
-#include "AliEMCALRecoUtils.h"
+// ---- Detectors ----
+#include "AliPHOSGeoUtils.h"
+#include "AliEMCALGeometry.h"
+
+// ---- PartCorr ---
+#include "AliCalorimeterUtils.h"
#include "AliCaloTrackReader.h"
ClassImp(AliCaloTrackReader)
}
-//____________________________________________________________________________
-Bool_t AliCaloTrackReader::IsEMCALCluster(AliVCluster* cluster) const {
+//___________________________________________________________________
+Bool_t AliCaloTrackReader::IsEMCALCluster(AliVCluster* cluster) const
+{
// Check if it is a cluster from EMCAL. For old AODs cluster type has
// different number and need to patch here
}
-//____________________________________________________________________________
-Bool_t AliCaloTrackReader::IsPHOSCluster(AliVCluster * cluster) const {
+//___________________________________________________________________
+Bool_t AliCaloTrackReader::IsPHOSCluster(AliVCluster * cluster) const
+{
//Check if it is a cluster from PHOS.For old AODs cluster type has
// different number and need to patch here
}
-//____________________________________________________________________________
-Bool_t AliCaloTrackReader::CheckForPrimaryVertex(){
+//________________________________________________
+Bool_t AliCaloTrackReader::CheckForPrimaryVertex()
+{
//Check if the vertex was well reconstructed, copy from V0Reader of conversion group
//Only for ESDs ...
}
+//____________________________________________________________
+void AliCaloTrackReader::SetTrackCuts(AliESDtrackCuts * cuts)
+{
+ // Set Track cuts
+
+ if(fESDtrackCuts) delete fESDtrackCuts ;
+
+ fESDtrackCuts = cuts ;
+}
class TTree ;
//--- ANALYSIS system ---
-#include "AliVCaloCells.h"
-class AliStack ;
-class AliHeader ;
-class AliGenEventHeader ;
-#include "AliVEvent.h"
+class AliVCaloCells;
+class AliStack;
+class AliHeader;
+class AliGenEventHeader;
+class AliVEvent;
class AliAODEvent;
class AliMCEvent;
class AliMixedEvent;
class AliAODMCHeader;
-#include "AliESDtrackCuts.h"
+class AliESDtrackCuts;
class AliCentrality;
class AliTriggerAnalysis;
class AliEventplane;
-// --- PartCorr
-#include "AliCalorimeterUtils.h"
+// --- PartCorr / EMCAL ---
+#include "AliEMCALRecoUtils.h"
#include "AliFiducialCut.h"
+class AliCalorimeterUtils;
class AliCaloTrackReader : public TObject {
Int_t GetV0Multiplicity(Int_t i) const { return fV0Mul[i] ; }
void SetEMCALClusterListName(TString &name) { fEMCALClustersListName = name ; }
- TString GetEMCALClusterListName() { return fEMCALClustersListName ; }
+ TString GetEMCALClusterListName() const { return fEMCALClustersListName ; }
// Arrayes with clusters/track/cells access method
virtual TObjArray* GetCTSTracks() const { return fCTSTracks ; }
void AcceptFastClusterEvents() { fAcceptFastCluster = kTRUE ; }
void RejectFastClusterEvents() { fAcceptFastCluster = kFALSE ; }
- Bool_t IsFastClusterAccepted() { return fAcceptFastCluster ; }
+ Bool_t IsFastClusterAccepted() const { return fAcceptFastCluster ; }
void SwitchOnLEDEventsRemoval() { fRemoveLEDEvents = kTRUE ; }
void SwitchOffLEDEventsRemoval() { fRemoveLEDEvents = kFALSE ; }
- Bool_t IsLEDEventRemoved() { return fRemoveLEDEvents ; }
+ Bool_t IsLEDEventRemoved() const { return fRemoveLEDEvents ; }
void SetFiredTriggerClassName(TString name ) { fFiredTriggerClassName = name ; }
TString GetFiredTriggerClassName() const { return fFiredTriggerClassName ; }
void SetTrackFilterMask(ULong_t bit) { fTrackFilterMask = bit ; }
AliESDtrackCuts* GetTrackCuts() const { return fESDtrackCuts ; }
- void SetTrackCuts(AliESDtrackCuts * cuts) { if(fESDtrackCuts) delete fESDtrackCuts ;
- fESDtrackCuts = cuts ; }
+ void SetTrackCuts(AliESDtrackCuts * cuts) ;
+
Int_t GetTrackMultiplicity() const { return fTrackMult ; }
Float_t GetTrackMultiplicityEtaCut() const { return fTrackMultEtaCut ; }
void SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta ; }
// --- ROOT system ---
#include "TGeoManager.h"
-//---- ANALYSIS system ----
+// --- ANALYSIS system ---
#include "AliCalorimeterUtils.h"
#include "AliESDEvent.h"
#include "AliMCEvent.h"
#include "AliVCaloCells.h"
#include "AliMixedEvent.h"
+// --- Detector ---
+#include "AliEMCALGeometry.h"
+#include "AliPHOSGeoUtils.h"
+
ClassImp(AliCalorimeterUtils)
icol = relId[3];
imod = relId[0]-1;
if(fPHOSBadChannelMap->GetEntries() <= imod)continue;
- if(GetPHOSChannelStatus(imod, icol, irow)) return kTRUE;
+ //printf("PHOS bad channels imod %d, icol %d, irow %d\n",imod, irow, icol);
+ if(GetPHOSChannelStatus(imod, irow, icol)) return kTRUE;
}
else return kFALSE;
}
-//___________________________________________________________________________________________________________________
-Int_t AliCalorimeterUtils::GetMaxEnergyCell(AliVCaloCells* cells, AliVCluster* clu, Float_t & clusterFraction) const
+//________________________________________________________________________________________
+Int_t AliCalorimeterUtils::GetMaxEnergyCell(AliVCaloCells* cells, const AliVCluster* clu,
+ Float_t & clusterFraction) const
{
//For a given CaloCluster gets the absId of the cell
if(IsRecalibrationOn()) {
if(calo=="EMCAL") recalFactor = GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
- else recalFactor = GetPHOSChannelRecalibrationFactor(iSupMod,ieta,iphi);
+ else recalFactor = GetPHOSChannelRecalibrationFactor (iSupMod,iphi,ieta);
}
eCell = cells->GetCellAmplitude(cellAbsId)*fraction*recalFactor;
TH1::AddDirectory(kFALSE);
fPHOSBadChannelMap = new TObjArray(5);
- for (int i = 0; i < 5; i++)fPHOSBadChannelMap->Add(new TH2I(Form("PHOSBadChannelMap_Mod%d",i),Form("PHOSBadChannelMap_Mod%d",i), 56, 0, 56, 64, 0, 64));
+ for (int i = 0; i < 5; i++)fPHOSBadChannelMap->Add(new TH2I(Form("PHOS_BadMap_mod%d",i),Form("PHOS_BadMap_mod%d",i), 64, 0, 64, 56, 0, 56));
fPHOSBadChannelMap->SetOwner(kTRUE);
fPHOSBadChannelMap->Compress();
TH1::AddDirectory(kFALSE);
fPHOSRecalibrationFactors = new TObjArray(5);
- for (int i = 0; i < 5; i++)fPHOSRecalibrationFactors->Add(new TH2F(Form("PHOSRecalFactors_Mod%d",i),Form("PHOSRecalFactors_Mod%d",i), 56, 0, 56, 64, 0, 64));
+ for (int i = 0; i < 5; i++)fPHOSRecalibrationFactors->Add(new TH2F(Form("PHOSRecalFactors_Mod%d",i),Form("PHOSRecalFactors_Mod%d",i), 64, 0, 64, 56, 0, 56));
//Init the histograms with 1
for (Int_t m = 0; m < 5; m++) {
for (Int_t i = 0; i < 56; i++) {
for (Int_t j = 0; j < 64; j++) {
- SetPHOSChannelRecalibrationFactor(m,i,j,1.);
+ SetPHOSChannelRecalibrationFactor(m,j,i,1.);
}
}
}
frac = fraction[icell];
if(frac < 1e-3) frac = 1; //in case of EMCAL, this is set as 0, not used.
module = GetModuleNumberCellIndexes(absId,calo,icol,irow,iRCU);
- if(cluster->IsPHOS()) factor = GetPHOSChannelRecalibrationFactor (module,icol,irow);
+ if(cluster->IsPHOS()) factor = GetPHOSChannelRecalibrationFactor (module,irow,icol);
else factor = GetEMCALChannelRecalibrationFactor(module,icol,irow);
if(fDebug>2)
printf("AliCalorimeterUtils::RecalibrateClusterEnergy() - recalibrate cell: %s, module %d, col %d, row %d, cell fraction %f, recalibration factor %f, cell energy %f\n",
//Get the EMCAL transformation geometry matrices from ESD
if(!fEMCALGeoMatrixSet && fEMCALGeo){
if(fLoadEMCALMatrices){
- printf("AliCalorimeterUtils::SetGeometryTransformationMatrices() - Load user defined geometry matrices\n");
+ printf("AliCalorimeterUtils::SetGeometryTransformationMatrices() - Load user defined EMCAL geometry matrices\n");
for(Int_t mod=0; mod < (fEMCALGeo->GetEMCGeometry())->GetNumberOfSuperModules(); mod++){
if(fEMCALMatrix[mod]){
if(fDebug > 1)
fEMCALGeo->SetMisalMatrix(((AliESDEvent*)inputEvent)->GetEMCALMatrix(mod),mod) ;
}
}// loop over super modules
+
fEMCALGeoMatrixSet = kTRUE;//At least one, so good
}//ESD as input
fEMCALGeoMatrixSet = kTRUE;
}
}//EMCAL geo && no geoManager
-
+
//Get the PHOS transformation geometry matrices from ESD
if(!fPHOSGeoMatrixSet && fPHOSGeo){
+
if(fLoadPHOSMatrices){
- printf("AliCalorimeterUtils::SetGeometryTransformationMatrices() - Load user defined geometry matrices\n");
- for(Int_t mod=0; mod < 5; mod++){
+ printf("AliCalorimeterUtils::SetGeometryTransformationMatrices() - Load user defined PHOS geometry matrices\n");
+ for(Int_t mod = 0 ; mod < 5 ; mod++){
if(fPHOSMatrix[mod]){
- if(fDebug > 1)
+ if(fDebug > 1 )
fPHOSMatrix[mod]->Print();
- fPHOSGeo->SetMisalMatrix(fPHOSMatrix[mod],mod) ;
+ fPHOSGeo->SetMisalMatrix(fPHOSMatrix[mod],mod+1) ;
}
}//SM loop
fPHOSGeoMatrixSet = kTRUE;//At least one, so good
+
}//Load matrices
else if (!gGeoManager) {
if(fDebug > 1)
fPHOSGeoMatrixSet = kTRUE;
}
}//PHOS geo and geoManager was not set
+
}
//__________________________________________________________________________________________
class AliAODPWG4Particle;
class AliVCluster;
class AliVCaloCells;
-#include "AliPHOSGeoUtils.h"
-#include "AliEMCALGeometry.h"
+class AliPHOSGeoUtils;
+class AliEMCALGeometry;
#include "AliEMCALRecoUtils.h"
class AliCalorimeterUtils : public TObject {
public:
AliCalorimeterUtils() ; // ctor
virtual ~AliCalorimeterUtils() ;//virtual dtor
- private:
- AliCalorimeterUtils(const AliCalorimeterUtils & g) ; // cpy ctor
- AliCalorimeterUtils & operator = (const AliCalorimeterUtils & g) ;//cpy assignment
-
- public:
virtual void InitParameters();
virtual void Print(const Option_t * opt) const ;
//virtual void Init();
- Int_t GetMaxEnergyCell(AliVCaloCells* cells, AliVCluster* clu, Float_t & fraction) const ;
+ Int_t GetMaxEnergyCell(AliVCaloCells* cells, const AliVCluster* clu, Float_t & fraction) const ;
//Calorimeters Geometry Methods
AliEMCALGeometry * GetEMCALGeometry() const { return fEMCALGeo ; }
Float_t fCutEta; // dEta cut on matching (EMCAL)
Float_t fCutPhi; // dPhi cut on matching (EMCAL)
+ AliCalorimeterUtils(const AliCalorimeterUtils & g) ; // cpy ctor
+ AliCalorimeterUtils & operator = (const AliCalorimeterUtils & g) ;//cpy assignment
+
ClassDef(AliCalorimeterUtils,7)
} ;
class AliFiducialCut : public TObject {
-
- public:
+
+public:
AliFiducialCut() ; // ctor
- virtual ~AliFiducialCut() ;//virtual dtor
-
- private:
- AliFiducialCut(const AliFiducialCut & g) ; // cpy ctor
- AliFiducialCut & operator = (const AliFiducialCut & g) ;//cpy assignment
+ virtual ~AliFiducialCut() ;//virtual dtor
- public:
-
- void InitParameters();
+ void InitParameters();
+
+ Bool_t CheckFiducialRegion(const TLorentzVector lv,
+ const TArrayF* minphi, const TArrayF* maxphi,
+ const TArrayF* mineta, const TArrayF* maxeta) const ;
- void Print(const Option_t * opt)const;
- Bool_t CheckFiducialRegion(const TLorentzVector lv, const TArrayF* minphi, const TArrayF* maxphi, const TArrayF* mineta, const TArrayF* maxeta) const ;
- Bool_t IsInFiducialCut (const TLorentzVector lv, const TString det) const ;
+ Bool_t IsInFiducialCut (const TLorentzVector lv, const TString det) const ;
- void DoCTSFiducialCut(Bool_t b) {fCTSFiducialCut = b; }
- void DoEMCALFiducialCut(Bool_t b) {fEMCALFiducialCut = b; }
- void DoPHOSFiducialCut(Bool_t b) {fPHOSFiducialCut = b; }
-
- Bool_t GetCTSFiducialCutStatus() const {return fCTSFiducialCut ; }
- Bool_t GetEMCALFiducialCut() const {return fEMCALFiducialCut ; }
- Bool_t GetPHOSFiducialCutStatus() const {return fPHOSFiducialCut ; }
+ void DoCTSFiducialCut (Bool_t b) {fCTSFiducialCut = b ; }
+ void DoEMCALFiducialCut(Bool_t b) {fEMCALFiducialCut = b ; }
+ void DoPHOSFiducialCut (Bool_t b) {fPHOSFiducialCut = b ; }
+
+ Bool_t GetCTSFiducialCutStatus() const {return fCTSFiducialCut ; }
+ Bool_t GetEMCALFiducialCut() const {return fEMCALFiducialCut ; }
+ Bool_t GetPHOSFiducialCutStatus() const {return fPHOSFiducialCut ; }
+
+ void SetSimpleCTSFiducialCut (const Float_t abseta, const Float_t phimin, const Float_t phimax) ;
+ void SetSimpleEMCALFiducialCut(const Float_t abseta, const Float_t phimin, const Float_t phimax) ;
+ void SetSimplePHOSFiducialCut (const Float_t abseta, const Float_t phimin, const Float_t phimax) ;
+
+ void Print(const Option_t * opt)const;
- void SetSimpleCTSFiducialCut(const Float_t abseta, const Float_t phimin, const Float_t phimax) ;
- void SetSimpleEMCALFiducialCut(const Float_t abseta, const Float_t phimin, const Float_t phimax) ;
- void SetSimplePHOSFiducialCut(const Float_t abseta, const Float_t phimin, const Float_t phimax) ;
+
+ void AddCTSFidCutMaxEtaArray(Int_t size, Float_t* array)
+ { fCTSFidCutMaxEta->Set(size,array) ; }
+ TArrayF * GetCTSFidCutMaxEtaArray() const { return fCTSFidCutMaxEta ; }
+
+ void AddCTSFidCutMaxPhiArray(Int_t size, Float_t* array)
+ { fCTSFidCutMaxPhi->Set(size,array) ; }
+ TArrayF * GetCTSFidCutMaxPhiArray() const { return fCTSFidCutMaxPhi ; }
+
+ void AddCTSFidCutMinEtaArray(Int_t size, Float_t* array)
+ { fCTSFidCutMinEta->Set(size,array) ; }
+ TArrayF * GetCTSFidCutMinEtaArray() const { return fCTSFidCutMinEta ; }
+
+ void AddCTSFidCutMinPhiArray(Int_t size, Float_t* array)
+ { fCTSFidCutMinPhi->Set(size,array) ; }
+ TArrayF * GetCTSFidCutMinPhiArray() const { return fCTSFidCutMinPhi ; }
+
+ void AddEMCALFidCutMaxEtaArray(Int_t size, Float_t* array)
+ { fEMCALFidCutMaxEta->Set(size,array) ; }
+ TArrayF * GetEMCALFidCutMaxEtaArray() const { return fEMCALFidCutMaxEta ; }
+
+ void AddEMCALFidCutMaxPhiArray(Int_t size, Float_t* array)
+ { fEMCALFidCutMaxPhi->Set(size,array) ; }
+ TArrayF * GetEMCALFidCutMaxPhiArray() const { return fEMCALFidCutMaxPhi ; }
+
+ void AddEMCALFidCutMinEtaArray(Int_t size, Float_t* array)
+ { fEMCALFidCutMinEta->Set(size,array) ; }
+ TArrayF * GetEMCALFidCutMinEtaArray() const { return fEMCALFidCutMinEta ; }
+
+ void AddEMCALFidCutMinPhiArray(Int_t size, Float_t* array)
+ { fEMCALFidCutMinPhi->Set(size,array) ; }
+ TArrayF * GetEMCALFidCutMinPhiArray() const { return fEMCALFidCutMinPhi ; }
+
+ void AddPHOSFidCutMaxEtaArray(Int_t size, Float_t* array)
+ { fPHOSFidCutMaxEta->Set(size,array) ; }
+ TArrayF * GetPHOSFidCutMaxEtaArray() const { return fPHOSFidCutMaxEta ; }
+
+ void AddPHOSFidCutMaxPhiArray(Int_t size, Float_t* array)
+ { fPHOSFidCutMaxPhi->Set(size,array) ; }
+ TArrayF * GetPHOSFidCutMaxPhiArray() const { return fPHOSFidCutMaxPhi ; }
+
+ void AddPHOSFidCutMinEtaArray(Int_t size, Float_t* array)
+ { fPHOSFidCutMinEta->Set(size,array) ; }
+ TArrayF * GetPHOSFidCutMinEtaArray() const { return fPHOSFidCutMinEta ; }
- void AddCTSFidCutMaxEtaArray(Int_t size, Float_t* array)
- { fCTSFidCutMaxEta->Set(size,array); }
- TArrayF * GetCTSFidCutMaxEtaArray() const {return fCTSFidCutMaxEta;}
-
- void AddCTSFidCutMaxPhiArray(Int_t size, Float_t* array)
- { fCTSFidCutMaxPhi->Set(size,array); }
- TArrayF * GetCTSFidCutMaxPhiArray() const {return fCTSFidCutMaxPhi;}
-
- void AddCTSFidCutMinEtaArray(Int_t size, Float_t* array)
- { fCTSFidCutMinEta->Set(size,array); }
- TArrayF * GetCTSFidCutMinEtaArray() const {return fCTSFidCutMinEta;}
-
- void AddCTSFidCutMinPhiArray(Int_t size, Float_t* array)
- { fCTSFidCutMinPhi->Set(size,array); }
- TArrayF * GetCTSFidCutMinPhiArray() const {return fCTSFidCutMinPhi;}
-
- void AddEMCALFidCutMaxEtaArray(Int_t size, Float_t* array)
- { fEMCALFidCutMaxEta->Set(size,array); }
- TArrayF * GetEMCALFidCutMaxEtaArray() const {return fEMCALFidCutMaxEta;}
-
- void AddEMCALFidCutMaxPhiArray(Int_t size, Float_t* array)
- { fEMCALFidCutMaxPhi->Set(size,array); }
- TArrayF * GetEMCALFidCutMaxPhiArray() const {return fEMCALFidCutMaxPhi;}
-
- void AddEMCALFidCutMinEtaArray(Int_t size, Float_t* array)
- { fEMCALFidCutMinEta->Set(size,array); }
- TArrayF * GetEMCALFidCutMinEtaArray() const {return fEMCALFidCutMinEta;}
-
- void AddEMCALFidCutMinPhiArray(Int_t size, Float_t* array)
- { fEMCALFidCutMinPhi->Set(size,array); }
- TArrayF * GetEMCALFidCutMinPhiArray() const {return fEMCALFidCutMinPhi;}
-
- void AddPHOSFidCutMaxEtaArray(Int_t size, Float_t* array)
- { fPHOSFidCutMaxEta->Set(size,array); }
- TArrayF * GetPHOSFidCutMaxEtaArray() const {return fPHOSFidCutMaxEta;}
-
- void AddPHOSFidCutMaxPhiArray(Int_t size, Float_t* array)
- { fPHOSFidCutMaxPhi->Set(size,array); }
- TArrayF * GetPHOSFidCutMaxPhiArray() const {return fPHOSFidCutMaxPhi;}
-
- void AddPHOSFidCutMinEtaArray(Int_t size, Float_t* array)
- { fPHOSFidCutMinEta->Set(size,array); }
- TArrayF * GetPHOSFidCutMinEtaArray() const {return fPHOSFidCutMinEta;}
-
- void AddPHOSFidCutMinPhiArray(Int_t size, Float_t* array)
- { fPHOSFidCutMinPhi->Set(size,array); }
- TArrayF * GetPHOSFidCutMinPhiArray() const {return fPHOSFidCutMinPhi;}
-
-
-
- protected:
-
- //Detector acceptance cuts
- Bool_t fEMCALFiducialCut ; // Apply fiducial cuts to EMCAL clusters
- Bool_t fPHOSFiducialCut ;// Apply fiducial cuts to PHOS clusters
- Bool_t fCTSFiducialCut ;//Apply fiducial cuts to CTS tracks
-
- TArrayF * fCTSFidCutMinEta ; //Take particles in CTS with eta > fCTSFidCutMinEta
- TArrayF * fCTSFidCutMinPhi ; //Take particles in CTS with phi > fCTSFidCutMinPhi
- TArrayF * fCTSFidCutMaxEta ; //Take particles in CTS with eta < fCTSFidCutMaxEta
- TArrayF * fCTSFidCutMaxPhi ; //Take particles in CTS with phi > fCTSFidCutMaxPhi
-
- TArrayF * fEMCALFidCutMinEta ; //Take particles in EMCAL with eta > fEMCALFidCutMinEta
- TArrayF * fEMCALFidCutMinPhi ; //Take particles in EMCAL with phi > fEMCALFidCutMinPhi
- TArrayF * fEMCALFidCutMaxEta ; //Take particles in EMCAL with eta < fEMCALFidCutMaxEta
- TArrayF * fEMCALFidCutMaxPhi ; //Take particles in EMCAL with phi > fEMCALFidCutMaxPhi
-
- TArrayF * fPHOSFidCutMinEta ; //Take particles in PHOS with eta > fPHOSFidCutMinEta
- TArrayF * fPHOSFidCutMinPhi ; //Take particles in PHOS with phi > fPHOSFidCutMinPhi
- TArrayF * fPHOSFidCutMaxEta ; //Take particles in PHOS with eta < fPHOSFidCutMaxEta
- TArrayF * fPHOSFidCutMaxPhi ; //Take particles in PHOS with phi > fPHOSFidCutMaxPhi
+ void AddPHOSFidCutMinPhiArray(Int_t size, Float_t* array)
+ { fPHOSFidCutMinPhi->Set(size,array) ; }
+ TArrayF * GetPHOSFidCutMinPhiArray() const { return fPHOSFidCutMinPhi ; }
+
+protected:
+
+ //Detector acceptance cuts
+ Bool_t fEMCALFiducialCut ; // Apply fiducial cuts to EMCAL clusters
+ Bool_t fPHOSFiducialCut ; // Apply fiducial cuts to PHOS clusters
+ Bool_t fCTSFiducialCut ; // Apply fiducial cuts to CTS tracks
+
+ TArrayF * fCTSFidCutMinEta ; // Take particles in CTS with eta > fCTSFidCutMinEta
+ TArrayF * fCTSFidCutMinPhi ; // Take particles in CTS with phi > fCTSFidCutMinPhi
+ TArrayF * fCTSFidCutMaxEta ; // Take particles in CTS with eta < fCTSFidCutMaxEta
+ TArrayF * fCTSFidCutMaxPhi ; // Take particles in CTS with phi > fCTSFidCutMaxPhi
+
+ TArrayF * fEMCALFidCutMinEta ; // Take particles in EMCAL with eta > fEMCALFidCutMinEta
+ TArrayF * fEMCALFidCutMinPhi ; // Take particles in EMCAL with phi > fEMCALFidCutMinPhi
+ TArrayF * fEMCALFidCutMaxEta ; // Take particles in EMCAL with eta < fEMCALFidCutMaxEta
+ TArrayF * fEMCALFidCutMaxPhi ; // Take particles in EMCAL with phi > fEMCALFidCutMaxPhi
+
+ TArrayF * fPHOSFidCutMinEta ; // Take particles in PHOS with eta > fPHOSFidCutMinEta
+ TArrayF * fPHOSFidCutMinPhi ; // Take particles in PHOS with phi > fPHOSFidCutMinPhi
+ TArrayF * fPHOSFidCutMaxEta ; // Take particles in PHOS with eta < fPHOSFidCutMaxEta
+ TArrayF * fPHOSFidCutMaxPhi ; // Take particles in PHOS with phi > fPHOSFidCutMaxPhi
+
+ AliFiducialCut(const AliFiducialCut & g) ; // cpy ctor
+ AliFiducialCut & operator = (const AliFiducialCut & g) ;// cpy assignment
ClassDef(AliFiducialCut,1)
- } ;
+
+} ;
#endif //ALIFIDUCIALCUT_H
// --- ROOT system ---
-//#include <Riostream.h>
#include <TLorentzVector.h>
#include <TObjArray.h>
ClassImp(AliIsolationCut)
-//____________________________________________________________________________
- AliIsolationCut::AliIsolationCut() :
- TObject(),
- fConeSize(0.),fPtThreshold(0.), fSumPtThreshold(0.), fPtFraction(0.), fICMethod(0),fPartInCone(0)
-
+//____________________________________
+AliIsolationCut::AliIsolationCut() :
+TObject(),
+fConeSize(0.),
+fPtThreshold(0.),
+fSumPtThreshold(0.),
+fPtFraction(0.),
+fICMethod(0),
+fPartInCone(0)
+
{
//default ctor
//Initialize parameters
InitParameters();
-
+
}
-//____________________________________________________________________________
+//____________________________________________
TString AliIsolationCut::GetICParametersList()
{
//Put data member values in string to keep in output container
}
-//__________________________________________________________________
-void AliIsolationCut::MakeIsolationCut(TObjArray * const plCTS, TObjArray * const plNe, AliCaloTrackReader * const reader,
- const Bool_t bFillAOD, AliAODPWG4ParticleCorrelation *pCandidate,
- const TString & aodArrayRefName,
- Int_t & n, Int_t & nfrac, Float_t &coneptsum, Bool_t &isolated) const
+//________________________________________________________________________________
+void AliIsolationCut::MakeIsolationCut(const TObjArray * plCTS,
+ const TObjArray * plNe,
+ const AliCaloTrackReader * reader,
+ const Bool_t bFillAOD,
+ AliAODPWG4ParticleCorrelation *pCandidate,
+ const TString & aodArrayRefName,
+ Int_t & n,
+ Int_t & nfrac,
+ Float_t &coneptsum,
+ Bool_t &isolated) const
{
//Search in cone around a candidate particle if it is isolated
Float_t phiC = pCandidate->Phi() ;
}
-//__________________________________________________________________
+//_____________________________________________________
void AliIsolationCut::Print(const Option_t * opt) const
{
printf("**** Print %s %s **** \n", GetName(), GetTitle() ) ;
- printf("IC method = %d\n", fICMethod) ;
- printf("Cone Size = %1.2f\n", fConeSize) ;
+ printf("IC method = %d\n", fICMethod ) ;
+ printf("Cone Size = %1.2f\n", fConeSize ) ;
printf("pT threshold = %2.1f\n", fPtThreshold) ;
- printf("pT fraction = %3.1f\n", fPtFraction) ;
- printf("particle type in cone = %d\n",fPartInCone);
+ printf("pT fraction = %3.1f\n", fPtFraction ) ;
+ printf("particle type in cone = %d\n", fPartInCone ) ;
printf(" \n") ;
}
class AliIsolationCut : public TObject {
public:
- AliIsolationCut() ; // default ctor
- virtual ~AliIsolationCut() {;} //virtual dtalr
- private:
- AliIsolationCut(const AliIsolationCut & g) ; // cpy ctor
- AliIsolationCut & operator = (const AliIsolationCut & g) ;//cpy assignment
-
- public:
+
+ AliIsolationCut() ; // default ctor
+ virtual ~AliIsolationCut() {;} // virtual dtor
// Enums
TString GetICParametersList() ;
- void MakeIsolationCut(TObjArray * const plCTS, TObjArray * const plNe, AliCaloTrackReader * const reader,
+ void MakeIsolationCut(const TObjArray * plCTS, const TObjArray * plNe, const AliCaloTrackReader * reader,
const Bool_t bFillAOD, AliAODPWG4ParticleCorrelation * pCandidate, const TString &aodObjArrayName,
Int_t &n, Int_t & nfrac, Float_t &ptsum, Bool_t & isolated) const ;
// kSumPtFracIC: Cone pt sum , fraction of cone sum, method
Int_t fPartInCone; // Type of particles inside cone:
// kNeutralAndCharged, kOnlyNeutral, kOnlyCharged
-
+
+ AliIsolationCut(const AliIsolationCut & g) ; // cpy ctor
+ AliIsolationCut & operator = (const AliIsolationCut & g) ; // cpy assignment
+
ClassDef(AliIsolationCut,3)
} ;
ClassImp(AliMCAnalysisUtils)
-//________________________________________________
- AliMCAnalysisUtils::AliMCAnalysisUtils() :
- TObject(), fCurrentEvent(-1), fDebug(-1),
- fJetsList(new TList), fMCGenerator("PYTHIA")
+//________________________________________
+AliMCAnalysisUtils::AliMCAnalysisUtils() :
+TObject(),
+fCurrentEvent(-1),
+fDebug(-1),
+fJetsList(new TList),
+fMCGenerator("PYTHIA")
{
//Ctor
}
-//____________________________________________________________________________
+//_______________________________________
AliMCAnalysisUtils::~AliMCAnalysisUtils()
{
// Remove all pointers.
}
}
-//_________________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckCommonAncestor(const Int_t index1, const Int_t index2, AliCaloTrackReader* reader,
- Int_t & ancPDG, Int_t & ancStatus, TLorentzVector & momentum, TVector3 & prodVertex)
+//_____________________________________________________________________________________________
+Int_t AliMCAnalysisUtils::CheckCommonAncestor(const Int_t index1, const Int_t index2,
+ const AliCaloTrackReader* reader,
+ Int_t & ancPDG, Int_t & ancStatus,
+ TLorentzVector & momentum, TVector3 & prodVertex)
{
//Check the first common ancestor of 2 clusters, given the most likely labels of the primaries generating such clusters.
Int_t label1[100];
return ancLabel;
}
-//_________________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t * label, const Int_t nlabels, AliCaloTrackReader* reader, const Int_t input = 0)
+//_____________________________________________________________________
+Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t * label,
+ const Int_t nlabels,
+ const AliCaloTrackReader* reader,
+ const Int_t input = 0)
{
//Play with the montecarlo particles if available
Int_t tag = 0;
return tag ;
}
-//_________________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t label, AliCaloTrackReader* reader, const Int_t input = 0)
+//_____________________________________________________________________
+Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t label,
+ const AliCaloTrackReader* reader,
+ const Int_t input = 0)
{
//Play with the montecarlo particles if available
Int_t tag = 0;
return tag ;
}
-//_________________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckOriginInStack(const Int_t *labels, const Int_t nlabels, AliStack* stack)
+//_________________________________________________________________
+Int_t AliMCAnalysisUtils::CheckOriginInStack(const Int_t *labels,
+ const Int_t nlabels,
+ AliStack* stack)
{
// Play with the MC stack if available. Tag particles depending on their origin.
// Do same things as in CheckOriginInAOD but different input.
//_________________________________________________________________________
-Int_t AliMCAnalysisUtils::CheckOriginInAOD(const Int_t *labels, const Int_t nlabels, TClonesArray *mcparticles)
+Int_t AliMCAnalysisUtils::CheckOriginInAOD(const Int_t *labels,
+ const Int_t nlabels,
+ const TClonesArray *mcparticles)
{
// Play with the MCParticles in AOD if available. Tag particles depending on their origin.
// Do same things as in CheckOriginInStack but different input.
}
//printf("Final mother mPDG %d\n",mPdg);
-
+
// conversion into electrons/photons checked
//first check for typical charged particles
}
//_________________________________________________________________________
-void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels, const Int_t nlabels, const Int_t mesonIndex,
- AliStack *stack, Int_t &tag)
+void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels,
+ const Int_t nlabels,
+ const Int_t mesonIndex,
+ AliStack *stack,
+ Int_t &tag)
{
//Check if cluster is formed from the contribution of 2 decay photons from pi0 or eta. Input in stack
if(fDebug > 3) printf("\t \t parent index %d\n",tmpindex);
daught = stack->Particle(tmpindex);
if (iPhoton0 == tmpindex) {
- okPhoton0 = kTRUE;
- break;
+ okPhoton0 = kTRUE;
+ break;
}
else if (iPhoton1 == tmpindex) {
- okPhoton1 = kTRUE;
- break;
+ okPhoton1 = kTRUE;
+ break;
}
tmpindex = daught->GetFirstMother();
}//While to check if pi0/eta daughter was one of these contributors to the cluster
}
-//_________________________________________________________________________
-void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels, const Int_t nlabels, const Int_t mesonIndex,
- TClonesArray *mcparticles, Int_t &tag)
+//__________________________________________________________________________________
+void AliMCAnalysisUtils::CheckOverlapped2GammaDecay(const Int_t *labels,
+ const Int_t nlabels,
+ const Int_t mesonIndex,
+ const TClonesArray *mcparticles,
+ Int_t & tag )
{
//Check if cluster is formed from the contribution of 2 decay photons from pi0 or eta. Input in AODMCParticles
labels[0],mcparticles->GetEntriesFast(), nlabels);
return;
}
-
+
AliAODMCParticle * meson = (AliAODMCParticle *) mcparticles->At(mesonIndex);
Int_t mesonPdg = meson->GetPdgCode();
if(mesonPdg != 111 && mesonPdg != 221) {
}
//_________________________________________________________________________
-TList * AliMCAnalysisUtils::GetJets(AliCaloTrackReader * const reader)
+TList * AliMCAnalysisUtils::GetJets(const AliCaloTrackReader * reader)
{
//Return list of jets (TParticles) and index of most likely parton that originated it.
AliStack * stack = reader->GetStack();
}
-//________________________________________________________________
+//________________________________________________________
void AliMCAnalysisUtils::Print(const Option_t * opt) const
{
//Print some relevant parameters set for the analysis
public:
AliMCAnalysisUtils() ; // ctor
virtual ~AliMCAnalysisUtils() ;//virtual dtor
- private:
- AliMCAnalysisUtils & operator = (const AliMCAnalysisUtils & ) ;//cpy assignment
- AliMCAnalysisUtils(const AliMCAnalysisUtils & mcu) ; // cpy ctor
-
- public:
-
+
//--------------------------------------
//Enum with tag for origin of particles
//--------------------------------------
//come from pi0 decay)
//then charged particles on line 3,
//followed by other and unknown on line 4
- enum mcTypes { kMCPhoton, kMCPrompt, kMCFragmentation, kMCISR, kMCPi0Decay, kMCEtaDecay, kMCOtherDecay, kMCConversion,
- kMCElectron, kMCEFromCFromB, kMCEFromC, kMCEFromB, kMCZDecay, kMCWDecay,
- kMCMuon, kMCPion, kMCPi0, kMCKaon, kMCEta, kMCProton, kMCAntiProton, kMCNeutron, kMCAntiNeutron,
- kMCOther, kMCUnknown, kMCBadLabel } ;
+ enum mcTypes { kMCPhoton, kMCPrompt, kMCFragmentation, kMCISR,
+ kMCPi0Decay, kMCEtaDecay, kMCOtherDecay, kMCConversion,
+ kMCElectron, kMCEFromCFromB, kMCEFromC, kMCEFromB, kMCZDecay, kMCWDecay,
+ kMCMuon, kMCPion, kMCPi0, kMCKaon, kMCEta, kMCProton,
+ kMCAntiProton, kMCNeutron, kMCAntiNeutron,
+ kMCOther, kMCUnknown, kMCBadLabel } ;
//--------------------------------------
// Methods to check origin of clusters
//--------------------------------------
- Int_t CheckCommonAncestor(const Int_t index1, const Int_t index2, AliCaloTrackReader* reader,
+ Int_t CheckCommonAncestor(const Int_t index1, const Int_t index2, const AliCaloTrackReader* reader,
Int_t & ancPDG, Int_t & ancStatus, TLorentzVector & momentum, TVector3 & v) ;
- Int_t CheckOrigin(const Int_t label, AliCaloTrackReader * reader, const Int_t input) ;
+ Int_t CheckOrigin(const Int_t label, const AliCaloTrackReader * reader, const Int_t input) ;
//Check the label of the most significant particle but do checks on the rest of the contributing labels
- Int_t CheckOrigin(const Int_t *label, const Int_t nlabels, AliCaloTrackReader * reader, const Int_t input) ;
+ Int_t CheckOrigin(const Int_t *label, const Int_t nlabels, const AliCaloTrackReader * reader, const Int_t input) ;
Int_t CheckOriginInStack(const Int_t *labels, const Int_t nlabels, AliStack * stack) ;
- Int_t CheckOriginInAOD (const Int_t *labels, const Int_t nlabels, TClonesArray* mcparticles) ;
+ Int_t CheckOriginInAOD (const Int_t *labels, const Int_t nlabels, const TClonesArray* mcparticles) ;
void CheckOverlapped2GammaDecay(const Int_t *labels, const Int_t nlabels, const Int_t mesonIndex, AliStack * stack, Int_t & tag);
- void CheckOverlapped2GammaDecay(const Int_t *labels, const Int_t nlabels, const Int_t mesonIndex, TClonesArray* mcparticles, Int_t & tag);
+ void CheckOverlapped2GammaDecay(const Int_t *labels, const Int_t nlabels, const Int_t mesonIndex, const TClonesArray* mcparticles, Int_t & tag);
//Check or set the bits produced in the above methods
void SetTagBit(Int_t &tag, const UInt_t set) const {
//--------------------------------------
// Method to recover MC jets stored in generator
- TList * GetJets(AliCaloTrackReader * const reader) ;
+ TList * GetJets(const AliCaloTrackReader * reader) ;
void SetDebug(Int_t deb) { fDebug=deb ; }
Int_t GetDebug() const { return fDebug ; }
TList * fJetsList; // List of jets
TString fMCGenerator; // MC geneator used to generate data in simulation
+ AliMCAnalysisUtils & operator = (const AliMCAnalysisUtils & ) ; // cpy assignment
+ AliMCAnalysisUtils(const AliMCAnalysisUtils & mcu) ; // cpy ctor
+
ClassDef(AliMCAnalysisUtils,3)
} ;
public:
AliNeutralMesonSelection() ; // default ctor
virtual ~AliNeutralMesonSelection() { ; } //virtual dtor
- private:
- AliNeutralMesonSelection(const AliNeutralMesonSelection & g) ; // cpy ctor
- AliNeutralMesonSelection & operator = (const AliNeutralMesonSelection & g) ;//cpy assignment
-
- public:
+
// General
TList * GetCreateOutputObjects();
Int_t fHistoNIMBins ; // Number of bins in Invariant Mass axis
Float_t fHistoIMMax ; // Maximum value of Invariant Mass histogram range
- Float_t fHistoIMMin ; // Minimum value of Invariant Mass histogram range
+ Float_t fHistoIMMin ; // Minimum value of Invariant Mass histogram range
+
+ AliNeutralMesonSelection(const AliNeutralMesonSelection & g) ; // cpy ctor
+ AliNeutralMesonSelection & operator = (const AliNeutralMesonSelection & g) ; // cpy assignment
ClassDef(AliNeutralMesonSelection,6)
#include "AliAODPid.h"
#include "AliExternalTrackParam.h"
+// --- Detectors ---
+#include "AliPHOSGeoUtils.h"
+#include "AliEMCALGeometry.h"
+
ClassImp(AliAnaCalorimeterQA)
//________________________________________
InitParameters();
}
-//_______________________________________________________________________________________________________________
-void AliAnaCalorimeterQA::BadClusterHistograms(AliVCluster* clus, TObjArray *caloClusters, AliVCaloCells * cells,
+//_____________________________________________________________________________________________________________________
+void AliAnaCalorimeterQA::BadClusterHistograms(AliVCluster* clus, const TObjArray *caloClusters, AliVCaloCells * cells,
const Int_t absIdMax, const Double_t maxCellFraction,
const Double_t tmax, Double_t timeAverages[2]
)
}
-//___________________________________________________________________________________________________________
-void AliAnaCalorimeterQA::ClusterHistograms(AliVCluster* clus,TObjArray *caloClusters, AliVCaloCells * cells,
+//_________________________________________________________________________________________________________________
+void AliAnaCalorimeterQA::ClusterHistograms(AliVCluster* clus,const TObjArray *caloClusters, AliVCaloCells * cells,
const Int_t absIdMax, const Double_t maxCellFraction,
const Double_t tmax, Double_t timeAverages[2])
{
//Overlapped pi0 (or eta, there will be very few)
if(GetMCAnalysisUtils()->CheckTagBit(tag, AliMCAnalysisUtils::kMCPi0)){
- fhRecoMCE [mcPi0][matched] ->Fill(e,eMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCEta[mcPi0][(matched)]->Fill(eta,etaMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[mcPi0][(matched)]->Fill(phi,phiMC);
- if(eMC > 0) fhRecoMCRatioE [mcPi0][(matched)]->Fill(e,e/eMC);
- fhRecoMCDeltaE [mcPi0][(matched)]->Fill(e,eMC-e);
- fhRecoMCDeltaPhi[mcPi0][(matched)]->Fill(e,phiMC-phi);
- fhRecoMCDeltaEta[mcPi0][(matched)]->Fill(e,etaMC-eta);
+ fhRecoMCE [kmcPi0][matched] ->Fill(e,eMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCEta[kmcPi0][(matched)]->Fill(eta,etaMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[kmcPi0][(matched)]->Fill(phi,phiMC);
+ if(eMC > 0) fhRecoMCRatioE [kmcPi0][(matched)]->Fill(e,e/eMC);
+ fhRecoMCDeltaE [kmcPi0][(matched)]->Fill(e,eMC-e);
+ fhRecoMCDeltaPhi[kmcPi0][(matched)]->Fill(e,phiMC-phi);
+ fhRecoMCDeltaEta[kmcPi0][(matched)]->Fill(e,etaMC-eta);
}//Overlapped pizero decay
else if(GetMCAnalysisUtils()->CheckTagBit(tag, AliMCAnalysisUtils::kMCEta)){
- fhRecoMCE [mcEta][(matched)] ->Fill(e,eMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCEta[mcEta][(matched)]->Fill(eta,etaMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[mcEta][(matched)]->Fill(phi,phiMC);
- if(eMC > 0) fhRecoMCRatioE [mcEta][(matched)]->Fill(e,e/eMC);
- fhRecoMCDeltaE [mcEta][(matched)]->Fill(e,eMC-e);
- fhRecoMCDeltaPhi[mcEta][(matched)]->Fill(e,phiMC-phi);
- fhRecoMCDeltaEta[mcEta][(matched)]->Fill(e,etaMC-eta);
+ fhRecoMCE [kmcEta][(matched)] ->Fill(e,eMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCEta[kmcEta][(matched)]->Fill(eta,etaMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[kmcEta][(matched)]->Fill(phi,phiMC);
+ if(eMC > 0) fhRecoMCRatioE [kmcEta][(matched)]->Fill(e,e/eMC);
+ fhRecoMCDeltaE [kmcEta][(matched)]->Fill(e,eMC-e);
+ fhRecoMCDeltaPhi[kmcEta][(matched)]->Fill(e,phiMC-phi);
+ fhRecoMCDeltaEta[kmcEta][(matched)]->Fill(e,etaMC-eta);
}//Overlapped eta decay
else if(GetMCAnalysisUtils()->CheckTagBit(tag, AliMCAnalysisUtils::kMCPhoton)){
- fhRecoMCE [mcPhoton][(matched)] ->Fill(e,eMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCEta[mcPhoton][(matched)]->Fill(eta,etaMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[mcPhoton][(matched)]->Fill(phi,phiMC);
- if(eMC > 0) fhRecoMCRatioE [mcPhoton][(matched)]->Fill(e,e/eMC);
- fhRecoMCDeltaE [mcPhoton][(matched)]->Fill(e,eMC-e);
- fhRecoMCDeltaPhi[mcPhoton][(matched)]->Fill(e,phiMC-phi);
- fhRecoMCDeltaEta[mcPhoton][(matched)]->Fill(e,etaMC-eta);
+ fhRecoMCE [kmcPhoton][(matched)] ->Fill(e,eMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCEta[kmcPhoton][(matched)]->Fill(eta,etaMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[kmcPhoton][(matched)]->Fill(phi,phiMC);
+ if(eMC > 0) fhRecoMCRatioE [kmcPhoton][(matched)]->Fill(e,e/eMC);
+ fhRecoMCDeltaE [kmcPhoton][(matched)]->Fill(e,eMC-e);
+ fhRecoMCDeltaPhi[kmcPhoton][(matched)]->Fill(e,phiMC-phi);
+ fhRecoMCDeltaEta[kmcPhoton][(matched)]->Fill(e,etaMC-eta);
}//photon
else if(GetMCAnalysisUtils()->CheckTagBit(tag, AliMCAnalysisUtils::kMCElectron)){
- fhRecoMCE [mcElectron][(matched)] ->Fill(e,eMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCEta[mcElectron][(matched)]->Fill(eta,etaMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[mcElectron][(matched)]->Fill(phi,phiMC);
- if(eMC > 0) fhRecoMCRatioE [mcElectron][(matched)]->Fill(e,e/eMC);
- fhRecoMCDeltaE [mcElectron][(matched)]->Fill(e,eMC-e);
- fhRecoMCDeltaPhi[mcElectron][(matched)]->Fill(e,phiMC-phi);
- fhRecoMCDeltaEta[mcElectron][(matched)]->Fill(e,etaMC-eta);
+ fhRecoMCE [kmcElectron][(matched)] ->Fill(e,eMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCEta[kmcElectron][(matched)]->Fill(eta,etaMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[kmcElectron][(matched)]->Fill(phi,phiMC);
+ if(eMC > 0) fhRecoMCRatioE [kmcElectron][(matched)]->Fill(e,e/eMC);
+ fhRecoMCDeltaE [kmcElectron][(matched)]->Fill(e,eMC-e);
+ fhRecoMCDeltaPhi[kmcElectron][(matched)]->Fill(e,phiMC-phi);
+ fhRecoMCDeltaEta[kmcElectron][(matched)]->Fill(e,etaMC-eta);
fhEMVxyz ->Fill(vxMC,vyMC);//,vz);
fhEMR ->Fill(e,rVMC);
}
else if(charge == 0){
- fhRecoMCE [mcNeHadron][(matched)] ->Fill(e,eMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCEta[mcNeHadron][(matched)]->Fill(eta,etaMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[mcNeHadron][(matched)]->Fill(phi,phiMC);
- if(eMC > 0) fhRecoMCRatioE [mcNeHadron][(matched)]->Fill(e,e/eMC);
- fhRecoMCDeltaE [mcNeHadron][(matched)]->Fill(e,eMC-e);
- fhRecoMCDeltaPhi[mcNeHadron][(matched)]->Fill(e,phiMC-phi);
- fhRecoMCDeltaEta[mcNeHadron][(matched)]->Fill(e,etaMC-eta);
+ fhRecoMCE [kmcNeHadron][(matched)] ->Fill(e,eMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCEta[kmcNeHadron][(matched)]->Fill(eta,etaMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[kmcNeHadron][(matched)]->Fill(phi,phiMC);
+ if(eMC > 0) fhRecoMCRatioE [kmcNeHadron][(matched)]->Fill(e,e/eMC);
+ fhRecoMCDeltaE [kmcNeHadron][(matched)]->Fill(e,eMC-e);
+ fhRecoMCDeltaPhi[kmcNeHadron][(matched)]->Fill(e,phiMC-phi);
+ fhRecoMCDeltaEta[kmcNeHadron][(matched)]->Fill(e,etaMC-eta);
fhHaVxyz ->Fill(vxMC,vyMC);//,vz);
fhHaR ->Fill(e,rVMC);
}
else if(charge!=0){
- fhRecoMCE [mcChHadron][(matched)] ->Fill(e,eMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCEta[mcChHadron][(matched)]->Fill(eta,etaMC);
- if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[mcChHadron][(matched)]->Fill(phi,phiMC);
- if(eMC > 0) fhRecoMCRatioE [mcChHadron][(matched)]->Fill(e,e/eMC);
- fhRecoMCDeltaE [mcChHadron][(matched)]->Fill(e,eMC-e);
- fhRecoMCDeltaPhi[mcChHadron][(matched)]->Fill(e,phiMC-phi);
- fhRecoMCDeltaEta[mcChHadron][(matched)]->Fill(e,etaMC-eta);
+ fhRecoMCE [kmcChHadron][(matched)] ->Fill(e,eMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCEta[kmcChHadron][(matched)]->Fill(eta,etaMC);
+ if(e > 0.5 && eMC > 0.5) fhRecoMCPhi[kmcChHadron][(matched)]->Fill(phi,phiMC);
+ if(eMC > 0) fhRecoMCRatioE [kmcChHadron][(matched)]->Fill(e,e/eMC);
+ fhRecoMCDeltaE [kmcChHadron][(matched)]->Fill(e,eMC-e);
+ fhRecoMCDeltaPhi[kmcChHadron][(matched)]->Fill(e,phiMC-phi);
+ fhRecoMCDeltaEta[kmcChHadron][(matched)]->Fill(e,etaMC-eta);
fhHaVxyz ->Fill(vxMC,vyMC);//,vz);
fhHaR ->Fill(e,rVMC);
}
}
-//_____________________________________________________________________________________________
+//__________________________________________________________________________________________________
void AliAnaCalorimeterQA::InvariantMassHistograms(const Int_t iclus, const TLorentzVector mom,
- const Int_t nModule, TObjArray* caloClusters,
+ const Int_t nModule, const TObjArray* caloClusters,
AliVCaloCells * cells)
{
// Fill Invariant mass histograms
}
if (pdg==22) {
- fhGenMCE[mcPhoton] ->Fill(eMC);
- if(eMC > 0.5) fhGenMCEtaPhi[mcPhoton]->Fill(etaMC,phiMC);
+ fhGenMCE[kmcPhoton] ->Fill(eMC);
+ if(eMC > 0.5) fhGenMCEtaPhi[kmcPhoton]->Fill(etaMC,phiMC);
if(in){
- fhGenMCAccE[mcPhoton] ->Fill(eMC);
- if(eMC > 0.5) fhGenMCAccEtaPhi[mcPhoton]->Fill(etaMC,phiMC);
+ fhGenMCAccE[kmcPhoton] ->Fill(eMC);
+ if(eMC > 0.5) fhGenMCAccEtaPhi[kmcPhoton]->Fill(etaMC,phiMC);
}
}
else if (pdg==111) {
- fhGenMCE[mcPi0] ->Fill(eMC);
- if(eMC > 0.5) fhGenMCEtaPhi[mcPi0]->Fill(etaMC,phiMC);
+ fhGenMCE[kmcPi0] ->Fill(eMC);
+ if(eMC > 0.5) fhGenMCEtaPhi[kmcPi0]->Fill(etaMC,phiMC);
if(in){
- fhGenMCAccE[mcPi0] ->Fill(eMC);
- if(eMC > 0.5) fhGenMCAccEtaPhi[mcPi0]->Fill(etaMC,phiMC);
+ fhGenMCAccE[kmcPi0] ->Fill(eMC);
+ if(eMC > 0.5) fhGenMCAccEtaPhi[kmcPi0]->Fill(etaMC,phiMC);
}
}
else if (pdg==221) {
- fhGenMCE[mcEta] ->Fill(eMC);
- if(eMC > 0.5) fhGenMCEtaPhi[mcEta]->Fill(etaMC,phiMC);
+ fhGenMCE[kmcEta] ->Fill(eMC);
+ if(eMC > 0.5) fhGenMCEtaPhi[kmcEta]->Fill(etaMC,phiMC);
if(in){
- fhGenMCAccE[mcEta] ->Fill(eMC);
- if(eMC > 0.5) fhGenMCAccEtaPhi[mcEta]->Fill(etaMC,phiMC);
+ fhGenMCAccE[kmcEta] ->Fill(eMC);
+ if(eMC > 0.5) fhGenMCAccEtaPhi[kmcEta]->Fill(etaMC,phiMC);
}
}
else if (TMath::Abs(pdg)==11) {
- fhGenMCE[mcElectron] ->Fill(eMC);
- if(eMC > 0.5) fhGenMCEtaPhi[mcElectron]->Fill(etaMC,phiMC);
+ fhGenMCE[kmcElectron] ->Fill(eMC);
+ if(eMC > 0.5) fhGenMCEtaPhi[kmcElectron]->Fill(etaMC,phiMC);
if(in){
- fhGenMCAccE[mcElectron] ->Fill(eMC);
- if(eMC > 0.5) fhGenMCAccEtaPhi[mcElectron]->Fill(etaMC,phiMC);
+ fhGenMCAccE[kmcElectron] ->Fill(eMC);
+ if(eMC > 0.5) fhGenMCAccEtaPhi[kmcElectron]->Fill(etaMC,phiMC);
}
}
}
public:
AliAnaCalorimeterQA() ; // default ctor
virtual ~AliAnaCalorimeterQA() {;} //virtual dtor
-private:
- AliAnaCalorimeterQA & operator = (const AliAnaCalorimeterQA & g) ;//cpy assignment
- AliAnaCalorimeterQA(const AliAnaCalorimeterQA & g) ; // cpy ctor
-
-public:
-
+
// General methods
TObjString * GetAnalysisCuts();
// Main methods
- void BadClusterHistograms(AliVCluster* clus, TObjArray *caloClusters, AliVCaloCells * cells,
- const Int_t absIdMax, const Double_t maxCellFraction, const Double_t tmax,
+ void BadClusterHistograms(AliVCluster* clus, const TObjArray *caloClusters, AliVCaloCells * cells,
+ const Int_t absIdMax, const Double_t maxCellFraction, const Double_t tmax,
Double_t timeAverages[2]);
void CalculateAverageTime(AliVCluster *clus, AliVCaloCells *cells, Double_t timeAverages[2]);
void ClusterAsymmetryHistograms(AliVCluster* clus, const Int_t absIdMax);
- void ClusterHistograms(AliVCluster* cluster, TObjArray *caloClusters, AliVCaloCells * cells,
- const Int_t absIdMax, const Double_t maxCellFraction, const Double_t tmax,
+ void ClusterHistograms(AliVCluster* cluster, const TObjArray *caloClusters, AliVCaloCells * cells,
+ const Int_t absIdMax, const Double_t maxCellFraction, const Double_t tmax,
Double_t timeAverages[2]);
void ClusterLoopHistograms(TObjArray * clusters, AliVCaloCells * cells);
Float_t GetECross(const Int_t absId, AliVCaloCells* cells);
void InvariantMassHistograms(const Int_t iclus, const TLorentzVector mom, const Int_t nModule,
- TObjArray* caloClusters, AliVCaloCells * cells);
+ const TObjArray* caloClusters, AliVCaloCells * cells);
Bool_t IsGoodCluster(const Int_t absIdMax, AliVCaloCells *cells);
//Pure MC
- enum mcTypes {mcPhoton = 0, mcPi0 = 1, mcEta = 2, mcElectron = 3, mcNeHadron = 4, mcChHadron = 5 };
+ enum mcTypes {kmcPhoton = 0, kmcPi0 = 1, kmcEta = 2, kmcElectron = 3, kmcNeHadron = 4, kmcChHadron = 5 };
TH2F * fhRecoMCE[6][2] ; //! E generated particle vs reconstructed E
TH2F * fhRecoMCPhi[6][2] ; //! phi generated particle vs reconstructed phi
TH2F * fhMCChHad1pOverER02; //! p/E for track-cluster matches, dR > 0.2, MC charged hadrons
TH2F * fhMCNeutral1pOverER02; //! p/E for track-cluster matches, dR > 0.2, MC neutral
+ AliAnaCalorimeterQA & operator = (const AliAnaCalorimeterQA & g) ;//cpy assignment
+ AliAnaCalorimeterQA(const AliAnaCalorimeterQA & g) ; // cpy ctor
+
ClassDef(AliAnaCalorimeterQA,21)
} ;
public:
AliAnaChargedParticles() ; // default ctor
virtual ~AliAnaChargedParticles() { ; } //virtual dtor
- private:
- AliAnaChargedParticles(const AliAnaChargedParticles & g) ; // cpy ctor
- AliAnaChargedParticles & operator = (const AliAnaChargedParticles & g) ;//cpy assignment
-
- public:
TList * GetCreateOutputObjects();
TH2F * fhPhiUnknown; //! phi distribution vs pT
TH2F * fhEtaUnknown; //! eta distribution vs pT
+ AliAnaChargedParticles(const AliAnaChargedParticles & g) ; // cpy ctor
+ AliAnaChargedParticles & operator = (const AliAnaChargedParticles & g) ;//cpy assignment
+
ClassDef(AliAnaChargedParticles,3)
} ;
!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion) &&
!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) &&
!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta)){
- fhMCELambda0[pidIndex][mcssPhoton] ->Fill(energy, lambda0);
+ fhMCELambda0[pidIndex][kmcssPhoton] ->Fill(energy, lambda0);
}//photon no conversion
else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron &&
!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion))){
- fhMCELambda0[pidIndex][mcssElectron] ->Fill(energy, lambda0);
+ fhMCELambda0[pidIndex][kmcssElectron] ->Fill(energy, lambda0);
if(!GetReader()->IsEmbeddedClusterSelectionOn()){
//Check particle overlaps in cluster
}//electron
else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron) &&
GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion) ){
- fhMCELambda0[pidIndex][mcssConversion] ->Fill(energy, lambda0);
+ fhMCELambda0[pidIndex][kmcssConversion] ->Fill(energy, lambda0);
}//conversion photon
else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) ){
- fhMCELambda0[pidIndex][mcssPi0] ->Fill(energy, lambda0);
+ fhMCELambda0[pidIndex][kmcssPi0] ->Fill(energy, lambda0);
}//pi0
else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) ){
- fhMCELambda0[pidIndex][mcssEta] ->Fill(energy, lambda0);
+ fhMCELambda0[pidIndex][kmcssEta] ->Fill(energy, lambda0);
}//eta
else {
- fhMCELambda0[pidIndex][mcssOther] ->Fill(energy, lambda0);
+ fhMCELambda0[pidIndex][kmcssOther] ->Fill(energy, lambda0);
}//other particles
}//MC data
//PID selection via dEdx
//-------------------------------------
- Int_t pid = AliCaloPID::kChargedHadron;
AliVTrack *track = 0;
if(!strcmp("AliESDCaloCluster",Form("%s",calo->ClassName()))){
Int_t iESDtrack = calo->GetTrackMatchedIndex();
fhdEdxvsE->Fill(calo->E(), dEdx);
fhdEdxvsP->Fill(track->P(),dEdx);
+ Int_t pid = AliCaloPID::kChargedHadron;
+
if( dEdx < fdEdxMax && dEdx > fdEdxMin) {
Float_t eOverp = calo->E()/track->P();
Int_t tag =ph->GetTag();
- if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) && fhMCE[pidIndex][mcPhoton])
+ if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) && fhMCE[pidIndex][kmcPhoton])
{
- fhMCE [pidIndex][mcPhoton] ->Fill(ecluster);
- fhMCPt [pidIndex][mcPhoton] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcPhoton] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcPhoton] ->Fill(ecluster,etacluster);
+ fhMCE [pidIndex][kmcPhoton] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcPhoton] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcPhoton] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcPhoton] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcPhoton] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcPhoton] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcPhoton] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcPhoton] ->Fill(ecluster,eprim-ecluster);
- if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion) && fhMCE[pidIndex][mcConversion])
+ if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion) && fhMCE[pidIndex][kmcConversion])
{
- fhMCE [pidIndex][mcConversion] ->Fill(ecluster);
- fhMCPt [pidIndex][mcConversion] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcConversion] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcConversion] ->Fill(ecluster,etacluster);
+ fhMCE [pidIndex][kmcConversion] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcConversion] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcConversion] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcConversion] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcConversion] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcConversion] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcConversion] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcConversion] ->Fill(ecluster,eprim-ecluster);
}
else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay) &&
- !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) && fhMCE[pidIndex][mcPi0Decay])
+ !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) && fhMCE[pidIndex][kmcPi0Decay])
{
- fhMCE [pidIndex][mcPi0Decay] ->Fill(ecluster);
- fhMCPt [pidIndex][mcPi0Decay] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcPi0Decay] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcPi0Decay] ->Fill(ecluster,etacluster);
+ fhMCE [pidIndex][kmcPi0Decay] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcPi0Decay] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcPi0Decay] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcPi0Decay] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcPi0Decay] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcPi0Decay] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcPi0Decay] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcPi0Decay] ->Fill(ecluster,eprim-ecluster);
}
else if( (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) ||
- GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay) ) && fhMCE[pidIndex][mcOtherDecay])
+ GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay) ) && fhMCE[pidIndex][kmcOtherDecay])
{
- fhMCE [pidIndex][mcOtherDecay] ->Fill(ecluster);
- fhMCPt [pidIndex][mcOtherDecay] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcOtherDecay] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcOtherDecay] ->Fill(ecluster,etacluster);
+ fhMCE [pidIndex][kmcOtherDecay] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcOtherDecay] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcOtherDecay] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcOtherDecay] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcOtherDecay] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcOtherDecay] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcOtherDecay] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcOtherDecay] ->Fill(ecluster,eprim-ecluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) && fhMCE [pidIndex][mcPi0])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) && fhMCE [pidIndex][kmcPi0])
{
- fhMCE [pidIndex][mcPi0] ->Fill(ecluster);
- fhMCPt [pidIndex][mcPi0] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcPi0] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcPi0] ->Fill(ecluster,etacluster);
+ fhMCE [pidIndex][kmcPi0] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcPi0] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcPi0] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcPi0] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcPi0] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcPi0] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcPi0] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcPi0] ->Fill(ecluster,eprim-ecluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) && fhMCE[pidIndex][mcEta])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) && fhMCE[pidIndex][kmcEta])
{
- fhMCE [pidIndex][mcEta] ->Fill(ecluster);
- fhMCPt [pidIndex][mcEta] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcEta] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcEta] ->Fill(ecluster,etacluster);
+ fhMCE [pidIndex][kmcEta] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcEta] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcEta] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcEta] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcEta] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcEta] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcEta] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcEta] ->Fill(ecluster,eprim-ecluster);
}
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiNeutron) && fhMCE[pidIndex][mcAntiNeutron])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiNeutron) && fhMCE[pidIndex][kmcAntiNeutron])
{
- fhMCE [pidIndex][mcAntiNeutron] ->Fill(ecluster);
- fhMCPt [pidIndex][mcAntiNeutron] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcAntiNeutron] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcAntiNeutron] ->Fill(ecluster,etacluster);
+ fhMCE [pidIndex][kmcAntiNeutron] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcAntiNeutron] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcAntiNeutron] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcAntiNeutron] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcAntiNeutron] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcAntiNeutron] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcAntiNeutron] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcAntiNeutron] ->Fill(ecluster,eprim-ecluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiProton) && fhMCE[pidIndex][mcAntiProton])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiProton) && fhMCE[pidIndex][kmcAntiProton])
{
- fhMCE [pidIndex][mcAntiProton] ->Fill(ecluster);
- fhMCPt [pidIndex][mcAntiProton] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcAntiProton] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcAntiProton] ->Fill(ecluster,etacluster);
+ fhMCE [pidIndex][kmcAntiProton] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcAntiProton] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcAntiProton] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcAntiProton] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcAntiProton] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcAntiProton] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcAntiProton] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcAntiProton] ->Fill(ecluster,eprim-ecluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron) && fhMCE[pidIndex][mcElectron])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron) && fhMCE[pidIndex][kmcElectron])
{
- fhMCE [pidIndex][mcElectron] ->Fill(ecluster);
- fhMCPt [pidIndex][mcElectron] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcElectron] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcElectron] ->Fill(ecluster,etacluster);
+ fhMCE [pidIndex][kmcElectron] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcElectron] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcElectron] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcElectron] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcElectron] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcElectron] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcElectron] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcElectron] ->Fill(ecluster,eprim-ecluster);
}
- else if( fhMCE[pidIndex][mcOther]){
- fhMCE [pidIndex][mcOther] ->Fill(ecluster);
- fhMCPt [pidIndex][mcOther] ->Fill(ptcluster);
- fhMCPhi[pidIndex][mcOther] ->Fill(ecluster,phicluster);
- fhMCEta[pidIndex][mcOther] ->Fill(ecluster,etacluster);
+ else if( fhMCE[pidIndex][kmcOther]){
+ fhMCE [pidIndex][kmcOther] ->Fill(ecluster);
+ fhMCPt [pidIndex][kmcOther] ->Fill(ptcluster);
+ fhMCPhi[pidIndex][kmcOther] ->Fill(ecluster,phicluster);
+ fhMCEta[pidIndex][kmcOther] ->Fill(ecluster,etacluster);
- fhMC2E[pidIndex][mcOther] ->Fill(ecluster, eprim);
- fhMCDeltaE[pidIndex][mcOther] ->Fill(ecluster,eprim-ecluster);
+ fhMC2E[pidIndex][kmcOther] ->Fill(ecluster, eprim);
+ fhMCDeltaE[pidIndex][kmcOther] ->Fill(ecluster,eprim-ecluster);
}
AliAnaElectron() ; // default ctor
virtual ~AliAnaElectron() { ; } // virtual dtor
-
- private:
-
- AliAnaElectron(const AliAnaElectron & g) ; // cpy ctor
-
- AliAnaElectron & operator = (const AliAnaElectron & g) ; // cpy assignment
-
- public:
//---------------------------------------
// General analysis frame methods
if(n > 10) fNOriginHistograms = 10; }
// For histograms in arrays, index in the array, corresponding to a particle
- enum mcTypes { mcPhoton = 0, mcPi0Decay = 1, mcOtherDecay = 2,
- mcPi0 = 3, mcEta = 4, mcElectron = 5,
- mcConversion = 6, mcOther = 7, mcAntiNeutron = 8,
- mcAntiProton = 9 };
+ enum mcTypes { kmcPhoton = 0, kmcPi0Decay = 1, kmcOtherDecay = 2,
+ kmcPi0 = 3, kmcEta = 4, kmcElectron = 5,
+ kmcConversion = 6, kmcOther = 7, kmcAntiNeutron = 8,
+ kmcAntiProton = 9 };
- enum mcssTypes { mcssPhoton = 0, mcssOther = 1, mcssPi0 = 2,
- mcssEta = 3, mcssConversion = 4, mcssElectron = 5 };
+ enum mcssTypes { kmcssPhoton = 0, kmcssOther = 1, kmcssPi0 = 2,
+ kmcssEta = 3, kmcssConversion = 4, kmcssElectron = 5 };
private:
TH2F * fhEmbedElectronELambda0MostlyBkg ; //! Lambda0 vs E for embedded electrons with 50%<fraction<10%
TH2F * fhEmbedElectronELambda0FullBkg ; //! Lambda0 vs E for embedded electrons with less than 10% of the cluster energy
- ClassDef(AliAnaElectron,2)
+ AliAnaElectron(const AliAnaElectron & g) ; // cpy ctor
+ AliAnaElectron & operator = (const AliAnaElectron & g) ; // cpy assignment
+
+ ClassDef(AliAnaElectron,2)
} ;
#include <TClonesArray.h>
#include <TObjString.h>
#include <TH3F.h>
-//#include "Riostream.h"
// --- Analysis system ---
#include "AliAnaInsideClusterInvariantMass.h"
#include "AliAODMCParticle.h"
#include "AliEMCALGeoParams.h"
+// --- Detectors ---
+//#include "AliPHOSGeoUtils.h"
+#include "AliEMCALGeometry.h"
+
ClassImp(AliAnaInsideClusterInvariantMass)
//__________________________________________________________________
if (nMax <= 0) {
printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - No local maximum found!");
- delete absIdList ;
- delete maxEList ;
+ delete [] absIdList ;
+ delete [] maxEList ;
return;
}
Int_t tag = GetMCAnalysisUtils()->CheckOrigin(cluster->GetLabels(),cluster->GetNLabels(), GetReader(), 0);
- if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ) mcindex = mcPi0;
- else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) ) mcindex = mcEta;
+ if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ) mcindex = kmcPi0;
+ else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) ) mcindex = kmcEta;
else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
- !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = mcPhoton;
+ !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPhoton;
else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
- GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = mcConversion;
- else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) mcindex = mcElectron;
- else mcindex = mcHadron;
+ GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcConversion;
+ else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) mcindex = kmcElectron;
+ else mcindex = kmcHadron;
/* printf("AliAnaInsideClusterInvariantMass::FillAnalysisMakeHistograms() - tag %d, photon %d, prompt %d, frag %d, isr %d, pi0 decay %d, eta decay %d, other decay %d \n conv %d, pi0 %d, hadron %d, electron %d, unk %d, muon %d,pion %d, proton %d, neutron %d, kaon %d, antiproton %d, antineutron %d, bad %d\n",tag,
GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton),
}//Work with MC truth first
- delete absIdList ;
- delete maxEList ;
+ delete [] absIdList ;
+ delete [] maxEList ;
}//loop
}
}
-//____________________________________________________________________________________________
-void AliAnaInsideClusterInvariantMass::SplitEnergy(const Int_t absId1, const Int_t absId2, AliVCaloCells* cells,
+//________________________________________________________________________________________
+void AliAnaInsideClusterInvariantMass::SplitEnergy(const Int_t absId1, const Int_t absId2,
+ const AliVCaloCells* cells,
Float_t & e1, Float_t & e2 )
{
public:
AliAnaInsideClusterInvariantMass() ; // default ctor
virtual ~AliAnaInsideClusterInvariantMass() { ; } //virtual dtor
- private:
- AliAnaInsideClusterInvariantMass(const AliAnaInsideClusterInvariantMass & g) ; // cpy ctor
- AliAnaInsideClusterInvariantMass & operator = (const AliAnaInsideClusterInvariantMass & g) ;//cpy assignment
- public:
-
Bool_t AreNeighbours(const Int_t absId1, const Int_t absId2) const ;
TObjString * GetAnalysisCuts();
void SetMinNCells(Float_t cut) { fMinNCells = cut ; }
- void SplitEnergy(const Int_t absId1, const Int_t absId2, AliVCaloCells* cells,
+ void SplitEnergy(const Int_t absId1, const Int_t absId2, const AliVCaloCells* cells,
Float_t & e1, Float_t & e2 );
void Print(const Option_t * opt) const;
//For histograms
- enum mcTypes { mcPhoton = 1, mcConversion = 2, mcPi0 = 3,
- mcEta = 4, mcElectron = 5, mcHadron = 6 };
+ enum mcTypes { kmcPhoton = 1, kmcConversion = 2, kmcPi0 = 3,
+ kmcEta = 4, kmcElectron = 5, kmcHadron = 6 };
private:
TH2F * fhInvMassAllCells[7] ; //! Inv mass of all cells
+ AliAnaInsideClusterInvariantMass(const AliAnaInsideClusterInvariantMass & g) ; // cpy ctor
+ AliAnaInsideClusterInvariantMass & operator = (const AliAnaInsideClusterInvariantMass & g) ;//cpy assignment
ClassDef(AliAnaInsideClusterInvariantMass,1)
AliAnaOmegaToPi0Gamma::AliAnaOmegaToPi0Gamma() : AliAnaPartCorrBaseClass(),
fInputAODPi0(0), fInputAODGammaName(""),
fEventsList(0x0),fNVtxZBin(0), fNCentBin(0), fNRpBin(0), fNBadChDistBin(0), fNpid(0),
-fNmaxMixEv(0), fVtxZCut(0), fCent(0), fRp(0),
+fVtxZCut(0), fCent(0), fRp(0),
fPi0Mass(0),fPi0MassWindow(0),fPi0OverOmegaPtCut(0),
fGammaOverOmegaPtCut(0), fEOverlapCluster(0),
fhEtalon(0),
//Default Ctor
InitParameters();
}
-/*
-//______________________________________________________________________________
-AliAnaOmegaToPi0Gamma::AliAnaOmegaToPi0Gamma(const AliAnaOmegaToPi0Gamma & ex) : AliAnaPartCorrBaseClass(ex),
-fInputAODPi0(new TClonesArray (*ex.fInputAODPi0)),
-fInputAODGammaName(ex.fInputAODGammaName),
-fEventsList(0x0),
-fNVtxZBin(ex.fNVtxZBin), fNCentBin(ex.fNCentBin), fNRpBin(ex.fNRpBin),
-fNBadChDistBin(ex.fNBadChDistBin),fNpid(ex.fNpid),
-fNmaxMixEv(ex.fNmaxMixEv),
-fVtxZCut(ex.fVtxZCut), fCent(ex.fCent), fRp(ex.fRp),
-fPi0Mass(ex.fPi0Mass),
-fPi0MassWindow(ex.fPi0MassWindow),
-fPi0OverOmegaPtCut(ex.fPi0OverOmegaPtCut),
-fGammaOverOmegaPtCut(ex.fGammaOverOmegaPtCut),
-fhEtalon(ex.fhEtalon),
-fRealOmega0(ex.fRealOmega0), fMixAOmega0(ex.fMixAOmega0),
-fMixBOmega0(ex.fMixBOmega0), fMixCOmega0(ex.fMixCOmega0),
-fRealOmega1(ex.fRealOmega1), fMixAOmega1(ex.fMixAOmega1),
-fMixBOmega1(ex.fMixBOmega1), fMixCOmega1(ex.fMixCOmega1),
-fRealOmega2(ex.fRealOmega2), fMixAOmega2(ex.fMixAOmega2),
-fMixBOmega2(ex.fMixBOmega2), fMixCOmega2(ex.fMixCOmega2),
-fhOmegaPriPt(ex.fhOmegaPriPt)
-{
- // cpy ctor
- //Do not need it
-}
-*/
-/*
-//______________________________________________________________________________
-AliAnaOmegaToPi0Gamma & AliAnaOmegaToPi0Gamma::operator = (const AliAnaOmegaToPi0Gamma & ex)
-{
- // assignment operator
-
- if(this == &ex)return *this;
- ((AliAnaPartCorrBaseClass *)this)->operator=(ex);
- fInputAODPi0 = new TClonesArray(*ex.fInputAODPi0);
- fInputAODGammaName = ex.fInputAODGammaName;
- fEventsList = ex.fEventsList;
-
- fNVtxZBin=ex.fNVtxZBin;
- fNCentBin=ex.fNCentBin;
- fNRpBin=ex.fNRpBin;
- fNBadChDistBin=ex.fNBadChDistBin;
- fNpid=ex.fNpid;
- fNmaxMixEv =ex.fNmaxMixEv;
-
- fVtxZCut=ex.fVtxZCut;
- fCent=ex.fCent;
- fRp=ex.fRp;
-
- fPi0Mass=ex.fPi0Mass;
- fPi0MassWindow=ex.fPi0MassWindow;
- fPi0OverOmegaPtCut=ex.fPi0OverOmegaPtCut;
- fGammaOverOmegaPtCut=ex.fGammaOverOmegaPtCut;
-
- fhEtalon=ex.fhEtalon;
- fRealOmega0=ex.fRealOmega0;
- fMixAOmega0=ex.fMixAOmega0;
- fMixBOmega0=ex.fMixBOmega0;
- fMixCOmega0=ex.fMixCOmega0;
- fRealOmega1=ex.fRealOmega1;
- fMixAOmega1=ex.fMixAOmega1;
- fMixBOmega1=ex.fMixBOmega1;
- fMixCOmega1=ex.fMixCOmega1;
- fRealOmega2=ex.fRealOmega2;
- fMixAOmega2=ex.fMixAOmega2;
- fMixBOmega2=ex.fMixBOmega2;
- fMixCOmega2=ex.fMixCOmega2;
- fhOmegaPriPt=ex.fhOmegaPriPt;
- return *this;
-
-}
-*/
//______________________________________________________________________________
AliAnaOmegaToPi0Gamma::~AliAnaOmegaToPi0Gamma() {
fNRpBin=1;
fNBadChDistBin=3;
fNpid=1;
- fNmaxMixEv=8;
fPi0Mass=0.1348;
fPi0MassWindow=0.015;
printf("Cuts at AOD particle level:\n");
printf("Number of PID: %d \n", fNpid);
printf("Number of DistToBadChannel cuts: %d\n", fNBadChDistBin);
- printf("number of events buffer to be mixed: %d\n",fNmaxMixEv);
}
//______________________________________________________________________________
if(currentEvent->GetEntriesFast()>0){
fEventsList[curEventBin]->AddFirst(currentEvent) ;
currentEvent=0 ;
- if(fEventsList[curEventBin]->GetSize()>=fNmaxMixEv) {
+ if(fEventsList[curEventBin]->GetSize()>=GetNMaxEvMix()) {
TClonesArray * tmp = (TClonesArray*) (fEventsList[curEventBin]->Last()) ;
fEventsList[curEventBin]->RemoveLast() ;
delete tmp ;
AliAnaOmegaToPi0Gamma() ; // default ctor
AliAnaOmegaToPi0Gamma(const char *name) ; // default ctor
virtual ~AliAnaOmegaToPi0Gamma() ;//virtual dtor
-
- private:
- AliAnaOmegaToPi0Gamma(const AliAnaOmegaToPi0Gamma & ex) ; // cpy ctor
- AliAnaOmegaToPi0Gamma & operator = (const AliAnaOmegaToPi0Gamma & ex) ;//cpy assignment
-
- public:
+
TList * GetCreateOutputObjects();
void Print(const Option_t * opt) const;
void MakeAnalysisFillHistograms();
void Terminate(TList * outList);
- TString GetInputAODPhotonName() const {return fInputAODGammaName;}
- void SetInputAODPhotonName(TString & name) { fInputAODGammaName = name; }
- Bool_t IsBadRun(Int_t /*iRun*/) const {return kFALSE;} //Tests if this run bad according to private list
-
- void SetNEventsMixed(Int_t nevents) { fNmaxMixEv=nevents;} //events to be mixed
+ TString GetInputAODPhotonName() const { return fInputAODGammaName;}
+ void SetInputAODPhotonName(TString & name) { fInputAODGammaName = name; }
+ Bool_t IsBadRun(Int_t /*iRun*/) const { return kFALSE;} //Tests if this run bad according to private list
void SetNCentBin(Int_t nbin){fNCentBin = nbin;}
void SetNPID(Int_t pid) {fNpid=pid;} //N pid cut
Int_t fNRpBin; //Number of reaction plane cut
Int_t fNBadChDistBin; //Number of bad channel dist cut
Int_t fNpid; //Number of PID cut
- Int_t fNmaxMixEv; //buffer size events to be mixed
Double_t *fVtxZCut; //![fNVtxZBin] vtertx z cut
Double_t *fCent; //![fNCentBin] centrality cut
Double_t fPi0MassWindow; //pi0 mass windows
Double_t fPi0OverOmegaPtCut; //pi0 Pt over omega pt cut
Double_t fGammaOverOmegaPtCut; //gamma pt over omega pt cut
- Double_t fEOverlapCluster; //the pt when the two photons overlapped
+ Double_t fEOverlapCluster; //the pt when the two photons overlapped
TH2F * fhEtalon; //an etalon of 3D histograms
- TH2F **fRealOmega0; //real omega IVM(asy, pt, m), with Asy_pi0<1
- TH2F **fMixAOmega0; //mixA omega IVM(asy, pt, m)
- TH2F **fMixBOmega0; //mixB omega IVM(asy, pt, m)
- TH2F **fMixCOmega0; //mixC omega IVM(asy, pt, m)
+ TH2F **fRealOmega0; //real omega IVM(asy, pt, m), with Asy_pi0<1
+ TH2F **fMixAOmega0; //mixA omega IVM(asy, pt, m)
+ TH2F **fMixBOmega0; //mixB omega IVM(asy, pt, m)
+ TH2F **fMixCOmega0; //mixC omega IVM(asy, pt, m)
TH2F **fRealOmega1; //real omega IVM(asy, pt, m), with Asy_pi0<0.7
TH2F **fMixAOmega1; //mixA omega IVM(asy, pt, m)
TH2F **fMixBOmega1; //mixB omega IVM(asy, pt, m)
TH2F **fMixBOmega2; //mixB omega IVM(asy, pt, m)
TH2F **fMixCOmega2; //mixC omega IVM(asy, pt, m)
- TH2F **fhFakeOmega; //high pt clusters assumed as pi0 + another gamma
+ TH2F **fhFakeOmega; //high pt clusters assumed as pi0 + another gamma
TH1F *fhOmegaPriPt; //MC primary omega pt in 2pi and |y|<0.5
-
+
+ AliAnaOmegaToPi0Gamma(const AliAnaOmegaToPi0Gamma & ex) ; // cpy ctor
+ AliAnaOmegaToPi0Gamma & operator = (const AliAnaOmegaToPi0Gamma & ex) ;// cpy assignment
+
ClassDef(AliAnaOmegaToPi0Gamma,2)
} ;
if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - End fill histograms \n");
}
-//_________________________________________________________________________________________________________
+//___________________________________________________________________________________________________________
Bool_t AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle,
- TObjArray* pl, const Bool_t bFillHisto)
+ const TObjArray* pl, const Bool_t bFillHisto)
{
// Charged Hadron Correlation Analysis
if(GetDebug() > 1)printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Make trigger particle - charged hadron correlation \n");
//________________________________________________________________________________________________________________
Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * const aodParticle,
- TObjArray* pi0list, const Bool_t bFillHisto)
+ const TObjArray* pi0list, const Bool_t bFillHisto)
{
// Neutral Pion Correlation Analysis
if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Make trigger particle - pi0 correlation, %d pi0's \n",pi0list->GetEntriesFast());
//Select only hadrons in pt range
if(mcTrackPt < GetMinPt() || mcTrackPt > GetMaxPt()) continue ;
//remove trigger itself for correlation when use charged triggers
- if(label==iParticle && mcTrackPt==ptprim && mcTrackPhi==phiprim && mcTrackEta==etaprim)
+ if(label==iParticle &&
+ TMath::Abs(mcTrackPt -ptprim ) < 1e-6 &&
+ TMath::Abs(mcTrackPhi-phiprim) < 1e-6 &&
+ TMath::Abs(mcTrackEta-etaprim) < 1e-6)
continue ;
//jumped out this event if near side associated partile pt larger than trigger
if( mcTrackPt> ptprim && TMath::Abs(mcTrackPhi-phiprim)<TMath::PiOver2())
if(mcTrackPhi < 0) mcTrackPhi+=TMath::TwoPi();
//Select only hadrons in pt range
if(mcTrackPt < GetMinPt() || mcTrackPt > GetMaxPt()) continue ;
+
//remove trigger itself for correlation when use charged triggers
- if(label==i && mcTrackPt==ptprim && mcTrackPhi==phiprim && mcTrackEta==etaprim)
- continue ;
+ if(label==i &&
+ TMath::Abs(mcTrackPt -ptprim ) < 1e-6 &&
+ TMath::Abs(mcTrackPhi-phiprim) < 1e-6 &&
+ TMath::Abs(mcTrackEta-etaprim) < 1e-6) continue ;
+
//jumped out this event if near side associated partile pt larger than trigger
if( mcTrackPt> ptprim && TMath::Abs(mcTrackPhi-phiprim)<TMath::PiOver2())
return ;
class AliAnaParticleHadronCorrelation : public AliAnaPartCorrBaseClass {
public:
+
AliAnaParticleHadronCorrelation() ; // default ctor
virtual ~AliAnaParticleHadronCorrelation() {;} //virtual dtor
- private:
- AliAnaParticleHadronCorrelation(const AliAnaParticleHadronCorrelation & ph) ; // cpy ctor
- AliAnaParticleHadronCorrelation & operator = (const AliAnaParticleHadronCorrelation & ph) ;//cpy assignment
-
- public:
// General methods
// Main analysis methods
- Bool_t MakeChargedCorrelation (AliAODPWG4ParticleCorrelation * aodParticle, TObjArray* pl, const Bool_t bFillHisto) ;
+ Bool_t MakeChargedCorrelation (AliAODPWG4ParticleCorrelation * aodParticle, const TObjArray* pl, const Bool_t bFillHisto) ;
- Bool_t MakeNeutralCorrelation (AliAODPWG4ParticleCorrelation * aodParticle, TObjArray* pl, const Bool_t bFillHisto) ;
+ Bool_t MakeNeutralCorrelation (AliAODPWG4ParticleCorrelation * aodParticle, const TObjArray* pl, const Bool_t bFillHisto) ;
void MakeMCChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle);
TH2F * fhMCPtTrigPout ; //! add explanation
TH2F * fhMCPtAssocDeltaPhi ; //! Pout =associated pt*sin(delta phi) distribution
+ AliAnaParticleHadronCorrelation(const AliAnaParticleHadronCorrelation & ph) ; // cpy ctor
+ AliAnaParticleHadronCorrelation & operator = (const AliAnaParticleHadronCorrelation & ph) ;//cpy assignment
ClassDef(AliAnaParticleHadronCorrelation,8)
} ;
AliAnaParticleIsolation() ; // default ctor
virtual ~AliAnaParticleIsolation() { ; } //virtual dtor
- private:
- AliAnaParticleIsolation(const AliAnaParticleIsolation & g) ; // cpy ctor
- AliAnaParticleIsolation & operator = (const AliAnaParticleIsolation & g) ;//cpy assignment
-
- public:
-
// Main general methods
TObjString * GetAnalysisCuts();
Float_t fHistoPtInConeMax; // PtInCone maximum in histogram
Float_t fHistoPtInConeMin; // PtInCone maximum in histogram
+ AliAnaParticleIsolation(const AliAnaParticleIsolation & g) ; // cpy ctor
+ AliAnaParticleIsolation & operator = (const AliAnaParticleIsolation & g) ;// cpy assignment
+
ClassDef(AliAnaParticleIsolation,4)
} ;
}
-//____________________________________________________________________________
+//_______________________________________________________
void AliAnaParticleJetFinderCorrelation::InitParameters()
{
-
//Initialize the parameters of the analysis.
SetInputAODName("PWG4Particle");
AddToHistogramsName("AnaJetFinderCorr_");
fUseJetRefTracks = kFALSE ;
fMakeCorrelationInHistoMaker = kFALSE ;
fSelectIsolated = kFALSE;
- }
+
+}
-//__________________________________________________________________
-Int_t AliAnaParticleJetFinderCorrelation::SelectJet(AliAODPWG4Particle * particle, AliAODEvent *event) const
+//__________________________________________________________________________________
+Int_t AliAnaParticleJetFinderCorrelation::SelectJet(AliAODPWG4Particle * particle,
+ const AliAODEvent *event) const
{
//Returns the index of the jet that is opposite to the particle
class AliAnaParticleJetFinderCorrelation : public AliAnaPartCorrBaseClass {
public:
- AliAnaParticleJetFinderCorrelation() ; // default ctor
- virtual ~AliAnaParticleJetFinderCorrelation() {;} //virtual dtor
- private:
- AliAnaParticleJetFinderCorrelation(const AliAnaParticleJetFinderCorrelation & g) ; // cpy ctor
- AliAnaParticleJetFinderCorrelation & operator = (const AliAnaParticleJetFinderCorrelation & g) ;//cpy assignment
+ AliAnaParticleJetFinderCorrelation() ; // default ctor
+ virtual ~AliAnaParticleJetFinderCorrelation() {;} // virtual dtor
- public:
-
- TList * GetCreateOutputObjects();
-
- Bool_t OnlyIsolated() const {return fSelectIsolated ; }
- void SelectIsolated(Bool_t select) {fSelectIsolated = select ; }
-
- void InitParameters();
+ // General methods
- void Print(const Option_t * opt) const;
+ void InitParameters();
- Float_t GetConeSize() const { return fConeSize ; }
- Float_t GetPtThresholdInCone() const { return fPtThresholdInCone ; }
- Double_t GetDeltaPhiMaxCut() const { return fDeltaPhiMaxCut ; }
- Double_t GetDeltaPhiMinCut() const { return fDeltaPhiMinCut ; }
- Double_t GetRatioMaxCut() const { return fRatioMaxCut ; }
- Double_t GetRatioMinCut() const { return fRatioMinCut ; }
- Bool_t AreJetRefTracks() const { return fUseJetRefTracks ; }
- Bool_t IsCorrelationMadeInHistoMaker() const {return fMakeCorrelationInHistoMaker ;}
+ TList * GetCreateOutputObjects();
+
+ void MakeAnalysisFillAOD() ;
- void SetConeSize(Float_t cone) {fConeSize = cone; }
- void SetPtThresholdInCone(Float_t pt){fPtThresholdInCone = pt; };
- void SetDeltaPhiCutRange(Double_t phimin, Double_t phimax)
- {fDeltaPhiMaxCut =phimax; fDeltaPhiMinCut =phimin;}
- void SetRatioCutRange(Double_t ratiomin, Double_t ratiomax)
- {fRatioMaxCut =ratiomax; fRatioMinCut = ratiomin ; }
- void UseJetRefTracks(Bool_t use) {fUseJetRefTracks = use ; }
- void SetMakeCorrelationInHistoMaker(Bool_t make) {fMakeCorrelationInHistoMaker = make ;}
+ void MakeAnalysisFillHistograms() ;
- private:
+ Int_t SelectJet(AliAODPWG4Particle * particle, const AliAODEvent * event) const ;
+
+ void Print(const Option_t * opt) const;
- Int_t SelectJet(AliAODPWG4Particle * particle, AliAODEvent * event) const ;
+ // Settings
- void MakeAnalysisFillAOD() ;
- void MakeAnalysisFillHistograms() ;
+ Bool_t OnlyIsolated() const { return fSelectIsolated ; }
+ void SelectIsolated(Bool_t select) { fSelectIsolated = select ; }
- private:
+ Float_t GetConeSize() const { return fConeSize ; }
+ Float_t GetPtThresholdInCone() const { return fPtThresholdInCone ; }
+ Double_t GetDeltaPhiMaxCut() const { return fDeltaPhiMaxCut ; }
+ Double_t GetDeltaPhiMinCut() const { return fDeltaPhiMinCut ; }
+ Double_t GetRatioMaxCut() const { return fRatioMaxCut ; }
+ Double_t GetRatioMinCut() const { return fRatioMinCut ; }
+ Bool_t AreJetRefTracks() const { return fUseJetRefTracks ; }
+ Bool_t IsCorrelationMadeInHistoMaker() const { return fMakeCorrelationInHistoMaker ; }
+ void SetConeSize(Float_t cone) { fConeSize = cone ; }
+ void SetPtThresholdInCone(Float_t pt) { fPtThresholdInCone = pt ; }
+ void SetDeltaPhiCutRange(Double_t phimin, Double_t phimax)
+ { fDeltaPhiMaxCut =phimax; fDeltaPhiMinCut =phimin ; }
+ void SetRatioCutRange(Double_t ratiomin, Double_t ratiomax)
+ { fRatioMaxCut =ratiomax; fRatioMinCut = ratiomin ; }
+ void UseJetRefTracks(Bool_t use) { fUseJetRefTracks = use ; }
+ void SetMakeCorrelationInHistoMaker(Bool_t make) { fMakeCorrelationInHistoMaker = make ; }
+
+private:
+
//selection parameters
- Double_t fDeltaPhiMaxCut ; //! Minimum Delta Phi Gamma-Leading
- Double_t fDeltaPhiMinCut ; //! Maximum Delta Phi Gamma-Leading
- Double_t fRatioMaxCut ; //! Jet/ particle Ratio cut maximum
- Double_t fRatioMinCut ; //! Jet/particle Ratio cut minimum
+ Double_t fDeltaPhiMaxCut ; //! Minimum Delta Phi Gamma-Leading
+ Double_t fDeltaPhiMinCut ; //! Maximum Delta Phi Gamma-Leading
+ Double_t fRatioMaxCut ; //! Jet/ particle Ratio cut maximum
+ Double_t fRatioMinCut ; //! Jet/particle Ratio cut minimum
Double_t fConeSize ; //! Jet cone size
Double_t fPtThresholdInCone ; //! Jet pT threshold in jet cone
- Bool_t fUseJetRefTracks ; //! Use track references from JETAN not the AOD tracks
+ Bool_t fUseJetRefTracks ; //! Use track references from JETAN not the AOD tracks
Bool_t fMakeCorrelationInHistoMaker ; //!Make particle-jet correlation in histogram maker
- Bool_t fSelectIsolated ; // Select only trigger particles isolated
+ Bool_t fSelectIsolated ; // Select only trigger particles isolated
+
+ // Histograms
+ TH2F * fhDeltaEta; //! Difference of jet eta and trigger particle eta as function of trigger particle pT
+ TH2F * fhDeltaPhi; //! Difference of jet phi and trigger particle phi as function of trigger particle pT
+ TH2F * fhDeltaPt; //! Difference of jet pT and trigger particle pT as function of trigger particle pT
+ TH2F * fhPtRatio; //! Ratio of jet pT and trigger particle pT as function of trigger particle pT
+ TH2F * fhPt; //! jet pT vs trigger particle pT
- TH2F * fhDeltaEta; //! Difference of jet eta and trigger particle eta as function of trigger particle pT
- TH2F * fhDeltaPhi; //! Difference of jet phi and trigger particle phi as function of trigger particle pT
- TH2F * fhDeltaPt; //! Difference of jet pT and trigger particle pT as function of trigger particle pT
- TH2F * fhPtRatio; //! Ratio of jet pT and trigger particle pT as function of trigger particle pT
- TH2F * fhPt; //! jet pT vs trigger particle pT
+ TH2F * fhFFz ; //! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
+ TH2F * fhFFxi; //! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
+ TH2F * fhFFpt; //! Jet particle pt distribution in cone
+ TH2F * fhNTracksInCone; //! jet multiplicity in cone
- TH2F * fhFFz ; //! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
- TH2F * fhFFxi; //! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
- TH2F * fhFFpt; //! Jet particle pt distribution in cone
- TH2F * fhNTracksInCone ; //! jet multiplicity in cone
+ AliAnaParticleJetFinderCorrelation(const AliAnaParticleJetFinderCorrelation & g) ; // cpy ctor
+ AliAnaParticleJetFinderCorrelation & operator = (const AliAnaParticleJetFinderCorrelation & g) ; // cpy assignment
ClassDef(AliAnaParticleJetFinderCorrelation,2)
+
} ;
-
#endif //ALIANAPARTICLEJETFINDERCORRELATION_H
public:
AliAnaParticleJetLeadingConeCorrelation() ; // default ctor
virtual ~AliAnaParticleJetLeadingConeCorrelation() ; //virtual dtor
- private:
- AliAnaParticleJetLeadingConeCorrelation(const AliAnaParticleJetLeadingConeCorrelation & g) ; // cpy ctor
- AliAnaParticleJetLeadingConeCorrelation & operator = (const AliAnaParticleJetLeadingConeCorrelation & g) ;//cpy assignment
-
- public:
TList * GetCreateOutputObjects();
TH2F * fhBkgFFpts[5][5]; //! Background particle pt distribution in cone
TH2F * fhBkgNTracksInCones[5][5]; //! Background multiplicity in cone
+ AliAnaParticleJetLeadingConeCorrelation(const AliAnaParticleJetLeadingConeCorrelation & g) ; // cpy ctor
+ AliAnaParticleJetLeadingConeCorrelation & operator = (const AliAnaParticleJetLeadingConeCorrelation & g) ;//cpy assignment
ClassDef(AliAnaParticleJetLeadingConeCorrelation,1)
} ;
class AliAnaParticlePartonCorrelation : public AliAnaPartCorrBaseClass {
- public:
+public:
+
AliAnaParticlePartonCorrelation() ; // default ctor
virtual ~AliAnaParticlePartonCorrelation() {;} //virtual dtor
- private:
- AliAnaParticlePartonCorrelation(const AliAnaParticlePartonCorrelation & g) ; // cpy ctor
- AliAnaParticlePartonCorrelation & operator = (const AliAnaParticlePartonCorrelation & g) ;//cpy assignment
-
- public:
-
- TList * GetCreateOutputObjects();
-
- void InitParameters();
-
- void Print(const Option_t * opt) const;
-
- void MakeAnalysisFillAOD() ;
-
- void MakeAnalysisFillHistograms() ;
-
- private:
-
- TH2F * fhDeltaEtaNearParton; //! Difference of parton eta and prompt trigger particle eta
- TH2F * fhDeltaPhiNearParton; //! Difference of parton phi and prompt trigger particle phi
- TH2F * fhDeltaPtNearParton; //! Difference of parton pT and prompt trigger particle pT
- TH2F * fhPtRatNearParton; //! Ratio of parton pT and prompt trigger particle pT
-
- TH2F * fhDeltaEtaAwayParton; //! Difference of parton eta and prompt trigger particle eta
- TH2F * fhDeltaPhiAwayParton; //! Difference of parton phi and prompt trigger particle phi
- TH2F * fhDeltaPtAwayParton; //! Difference of parton pT and prompt trigger particle pT
- TH2F * fhPtRatAwayParton; //! Ratio of parton pT and prompt trigger particle pT
-
- ClassDef(AliAnaParticlePartonCorrelation,1)
- } ;
+
+ TList * GetCreateOutputObjects();
+
+ void InitParameters();
+
+ void MakeAnalysisFillAOD() ;
+
+ void MakeAnalysisFillHistograms() ;
+
+ void Print(const Option_t * opt) const;
+
+private:
+
+ TH2F * fhDeltaEtaNearParton; //! Difference of parton eta and prompt trigger particle eta
+ TH2F * fhDeltaPhiNearParton; //! Difference of parton phi and prompt trigger particle phi
+ TH2F * fhDeltaPtNearParton; //! Difference of parton pT and prompt trigger particle pT
+ TH2F * fhPtRatNearParton; //! Ratio of parton pT and prompt trigger particle pT
+
+ TH2F * fhDeltaEtaAwayParton; //! Difference of parton eta and prompt trigger particle eta
+ TH2F * fhDeltaPhiAwayParton; //! Difference of parton phi and prompt trigger particle phi
+ TH2F * fhDeltaPtAwayParton; //! Difference of parton pT and prompt trigger particle pT
+ TH2F * fhPtRatAwayParton; //! Ratio of parton pT and prompt trigger particle pT
+
+ AliAnaParticlePartonCorrelation(const AliAnaParticlePartonCorrelation & g) ; // cpy ctor
+ AliAnaParticlePartonCorrelation & operator = (const AliAnaParticlePartonCorrelation & g) ; // cpy assignment
+
+ ClassDef(AliAnaParticlePartonCorrelation,1)
+
+} ;
#endif //ALIANAPARTICLEPARTONCORRELATION_H
#include "AliAODMCParticle.h"
#include "AliMixedEvent.h"
+// --- Detectors ---
+#include "AliPHOSGeoUtils.h"
+#include "AliEMCALGeometry.h"
ClassImp(AliAnaPhoton)
//Fill histograms
- fhYPrimMC[mcPPhoton]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPPhoton]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0)
{
- fhEPrimMC [mcPPhoton]->Fill(photonE ) ;
- fhPtPrimMC [mcPPhoton]->Fill(photonPt) ;
- fhPhiPrimMC[mcPPhoton]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPPhoton] ->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPPhoton]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPPhoton]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPPhoton]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPPhoton] ->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPPhoton] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPPhoton] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPPhoton]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPPhoton] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPPhoton] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPPhoton] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPPhoton]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPPhoton] ->Fill(photonE , photonY) ;
}//Accepted
//Origin of photon
- if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) && fhEPrimMC[mcPPrompt])
+ if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) && fhEPrimMC[kmcPPrompt])
{
- fhYPrimMC[mcPPrompt]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPPrompt]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPPrompt]->Fill(photonE ) ;
- fhPtPrimMC [mcPPrompt]->Fill(photonPt) ;
- fhPhiPrimMC[mcPPrompt]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPPrompt] ->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPPrompt]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPPrompt]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPPrompt]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPPrompt] ->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPPrompt] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPPrompt] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPPrompt]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPPrompt] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPPrompt] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPPrompt] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPPrompt]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPPrompt] ->Fill(photonE , photonY) ;
}//Accepted
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation) && fhEPrimMC[mcPFragmentation])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation) && fhEPrimMC[kmcPFragmentation])
{
- fhYPrimMC[mcPFragmentation]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPFragmentation]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPFragmentation]->Fill(photonE ) ;
- fhPtPrimMC [mcPFragmentation]->Fill(photonPt) ;
- fhPhiPrimMC[mcPFragmentation]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPFragmentation] ->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPFragmentation]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPFragmentation]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPFragmentation]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPFragmentation] ->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPFragmentation] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPFragmentation] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPFragmentation]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPFragmentation] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPFragmentation] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPFragmentation] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPFragmentation]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPFragmentation] ->Fill(photonE , photonY) ;
}//Accepted
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR) && fhEPrimMC[mcPISR])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR) && fhEPrimMC[kmcPISR])
{
- fhYPrimMC[mcPISR]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPISR]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPISR]->Fill(photonE ) ;
- fhPtPrimMC [mcPISR]->Fill(photonPt) ;
- fhPhiPrimMC[mcPISR]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPISR]->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPISR]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPISR]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPISR]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPISR]->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPISR] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPISR] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPISR]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPISR] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPISR] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPISR] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPISR]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPISR] ->Fill(photonE , photonY) ;
}//Accepted
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay)&& fhEPrimMC[mcPPi0Decay])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay)&& fhEPrimMC[kmcPPi0Decay])
{
- fhYPrimMC[mcPPi0Decay]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPPi0Decay]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPPi0Decay]->Fill(photonE ) ;
- fhPtPrimMC [mcPPi0Decay]->Fill(photonPt) ;
- fhPhiPrimMC[mcPPi0Decay]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPPi0Decay] ->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPPi0Decay]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPPi0Decay]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPPi0Decay]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPPi0Decay] ->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPPi0Decay] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPPi0Decay] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPPi0Decay]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPPi0Decay] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPPi0Decay] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPPi0Decay] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPPi0Decay]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPPi0Decay] ->Fill(photonE , photonY) ;
}//Accepted
}
else if( (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) ||
- GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)) && fhEPrimMC[mcPOtherDecay])
+ GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)) && fhEPrimMC[kmcPOtherDecay])
{
- fhYPrimMC[mcPOtherDecay]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPOtherDecay]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPOtherDecay]->Fill(photonE ) ;
- fhPtPrimMC [mcPOtherDecay]->Fill(photonPt) ;
- fhPhiPrimMC[mcPOtherDecay]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPOtherDecay] ->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPOtherDecay]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPOtherDecay]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPOtherDecay]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPOtherDecay] ->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPOtherDecay] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPOtherDecay] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPOtherDecay]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPOtherDecay] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPOtherDecay] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPOtherDecay] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPOtherDecay]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPOtherDecay] ->Fill(photonE , photonY) ;
}//Accepted
}
- else if(fhEPrimMC[mcPOther])
+ else if(fhEPrimMC[kmcPOther])
{
- fhYPrimMC[mcPOther]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPOther]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPOther]->Fill(photonE ) ;
- fhPtPrimMC [mcPOther]->Fill(photonPt) ;
- fhPhiPrimMC[mcPOther]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPOther] ->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPOther]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPOther]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPOther]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPOther] ->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPOther] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPOther] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPOther]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPOther] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPOther] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPOther] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPOther]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPOther] ->Fill(photonE , photonY) ;
}//Accepted
}//Other origin
}// Primary photon
//Fill histograms
- fhYPrimMC[mcPPhoton]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPPhoton]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0)
{
- fhEPrimMC [mcPPhoton]->Fill(photonE ) ;
- fhPtPrimMC [mcPPhoton]->Fill(photonPt) ;
- fhPhiPrimMC[mcPPhoton]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPPhoton]->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPPhoton]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPPhoton]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPPhoton]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPPhoton]->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPPhoton] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPPhoton] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPPhoton]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPPhoton] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPPhoton] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPPhoton] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPPhoton]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPPhoton] ->Fill(photonE , photonY) ;
}//Accepted
//Origin of photon
- if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) && fhEPrimMC[mcPPrompt])
+ if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) && fhEPrimMC[kmcPPrompt])
{
- fhYPrimMC[mcPPrompt]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPPrompt]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPPrompt]->Fill(photonE ) ;
- fhPtPrimMC [mcPPrompt]->Fill(photonPt) ;
- fhPhiPrimMC[mcPPrompt]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPPrompt]->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPPrompt]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPPrompt]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPPrompt]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPPrompt]->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPPrompt] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPPrompt] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPPrompt]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPPrompt] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPPrompt] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPPrompt] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPPrompt]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPPrompt] ->Fill(photonE , photonY) ;
}//Accepted
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation) && fhEPrimMC[mcPFragmentation] )
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation) && fhEPrimMC[kmcPFragmentation] )
{
- fhYPrimMC[mcPFragmentation]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPFragmentation]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPFragmentation]->Fill(photonE ) ;
- fhPtPrimMC [mcPFragmentation]->Fill(photonPt) ;
- fhPhiPrimMC[mcPFragmentation]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPFragmentation]->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPFragmentation]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPFragmentation]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPFragmentation]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPFragmentation]->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPFragmentation] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPFragmentation] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPFragmentation]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPFragmentation] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPFragmentation] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPFragmentation] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPFragmentation]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPFragmentation] ->Fill(photonE , photonY) ;
}//Accepted
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR) && fhEPrimMC[mcPISR])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR) && fhEPrimMC[kmcPISR])
{
- fhYPrimMC[mcPISR]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPISR]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPISR]->Fill(photonE ) ;
- fhPtPrimMC [mcPISR]->Fill(photonPt) ;
- fhPhiPrimMC[mcPISR]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPISR]->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPISR]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPISR]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPISR]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPISR]->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPISR] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPISR] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPISR]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPISR] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPISR] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPISR] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPISR]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPISR] ->Fill(photonE , photonY) ;
}//Accepted
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay)&& fhEPrimMC[mcPPi0Decay])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay)&& fhEPrimMC[kmcPPi0Decay])
{
- fhYPrimMC[mcPPi0Decay]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPPi0Decay]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPPi0Decay]->Fill(photonE ) ;
- fhPtPrimMC [mcPPi0Decay]->Fill(photonPt) ;
- fhPhiPrimMC[mcPPi0Decay]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPPi0Decay]->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPPi0Decay]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPPi0Decay]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPPi0Decay]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPPi0Decay]->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPPi0Decay] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPPi0Decay] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPPi0Decay]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPPi0Decay] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPPi0Decay] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPPi0Decay] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPPi0Decay]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPPi0Decay] ->Fill(photonE , photonY) ;
}//Accepted
}
else if((GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) ||
- GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay) ) && fhEPrimMC[mcPOtherDecay])
+ GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay) ) && fhEPrimMC[kmcPOtherDecay])
{
- fhYPrimMC[mcPOtherDecay]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPOtherDecay]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPOtherDecay]->Fill(photonE ) ;
- fhPtPrimMC [mcPOtherDecay]->Fill(photonPt) ;
- fhPhiPrimMC[mcPOtherDecay]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPOtherDecay]->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPOtherDecay]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPOtherDecay]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPOtherDecay]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPOtherDecay]->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPOtherDecay] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPOtherDecay] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPOtherDecay]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPOtherDecay] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPOtherDecay] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPOtherDecay] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPOtherDecay]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPOtherDecay] ->Fill(photonE , photonY) ;
}//Accepted
}
- else if(fhEPrimMC[mcPOther])
+ else if(fhEPrimMC[kmcPOther])
{
- fhYPrimMC[mcPOther]->Fill(photonPt, photonY) ;
+ fhYPrimMC[kmcPOther]->Fill(photonPt, photonY) ;
if(TMath::Abs(photonY) < 1.0){
- fhEPrimMC [mcPOther]->Fill(photonE ) ;
- fhPtPrimMC [mcPOther]->Fill(photonPt) ;
- fhPhiPrimMC[mcPOther]->Fill(photonE , photonPhi) ;
- fhYPrimMC[mcPOther]->Fill(photonE , photonEta) ;
+ fhEPrimMC [kmcPOther]->Fill(photonE ) ;
+ fhPtPrimMC [kmcPOther]->Fill(photonPt) ;
+ fhPhiPrimMC[kmcPOther]->Fill(photonE , photonPhi) ;
+ fhYPrimMC[kmcPOther]->Fill(photonE , photonEta) ;
}
if(inacceptance){
- fhEPrimMCAcc[mcPOther] ->Fill(photonE ) ;
- fhPtPrimMCAcc[mcPOther] ->Fill(photonPt) ;
- fhPhiPrimMCAcc[mcPOther]->Fill(photonE , photonPhi) ;
- fhYPrimMCAcc[mcPOther] ->Fill(photonE , photonY) ;
+ fhEPrimMCAcc[kmcPOther] ->Fill(photonE ) ;
+ fhPtPrimMCAcc[kmcPOther] ->Fill(photonPt) ;
+ fhPhiPrimMCAcc[kmcPOther]->Fill(photonE , photonPhi) ;
+ fhYPrimMCAcc[kmcPOther] ->Fill(photonE , photonY) ;
}//Accepted
}//Other origin
}// Primary photon
}//loop on primaries
- }//mc array exists and data is MC
+ }//kmc array exists and data is MC
} // read AOD MC
}
!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion) &&
!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) &&
!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta)){
- fhMCELambda0[mcssPhoton] ->Fill(energy, lambda0);
- fhMCELambda1[mcssPhoton] ->Fill(energy, lambda1);
- fhMCEDispersion[mcssPhoton] ->Fill(energy, disp);
- fhMCNCellsE[mcssPhoton] ->Fill(energy, ncells);
- fhMCMaxCellDiffClusterE[mcssPhoton]->Fill(energy,maxCellFraction);
+ fhMCELambda0[kmcssPhoton] ->Fill(energy, lambda0);
+ fhMCELambda1[kmcssPhoton] ->Fill(energy, lambda1);
+ fhMCEDispersion[kmcssPhoton] ->Fill(energy, disp);
+ fhMCNCellsE[kmcssPhoton] ->Fill(energy, ncells);
+ fhMCMaxCellDiffClusterE[kmcssPhoton]->Fill(energy,maxCellFraction);
if (energy < 2.){
- fhMCLambda0vsClusterMaxCellDiffE0[mcssPhoton]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE0[mcssPhoton] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE0[kmcssPhoton]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE0[kmcssPhoton] ->Fill(ncells, maxCellFraction);
}
else if(energy < 6.){
- fhMCLambda0vsClusterMaxCellDiffE2[mcssPhoton]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE2[mcssPhoton] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE2[kmcssPhoton]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE2[kmcssPhoton] ->Fill(ncells, maxCellFraction);
}
else{
- fhMCLambda0vsClusterMaxCellDiffE6[mcssPhoton]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE6[mcssPhoton] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE6[kmcssPhoton]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE6[kmcssPhoton] ->Fill(ncells, maxCellFraction);
}
if(!GetReader()->IsEmbeddedClusterSelectionOn()){
}//photon no conversion
else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron)){
- fhMCELambda0[mcssElectron] ->Fill(energy, lambda0);
- fhMCELambda1[mcssElectron] ->Fill(energy, lambda1);
- fhMCEDispersion[mcssElectron] ->Fill(energy, disp);
- fhMCNCellsE[mcssElectron] ->Fill(energy, ncells);
- fhMCMaxCellDiffClusterE[mcssElectron]->Fill(energy,maxCellFraction);
+ fhMCELambda0[kmcssElectron] ->Fill(energy, lambda0);
+ fhMCELambda1[kmcssElectron] ->Fill(energy, lambda1);
+ fhMCEDispersion[kmcssElectron] ->Fill(energy, disp);
+ fhMCNCellsE[kmcssElectron] ->Fill(energy, ncells);
+ fhMCMaxCellDiffClusterE[kmcssElectron]->Fill(energy,maxCellFraction);
if (energy < 2.){
- fhMCLambda0vsClusterMaxCellDiffE0[mcssElectron]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE0[mcssElectron] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE0[kmcssElectron]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE0[kmcssElectron] ->Fill(ncells, maxCellFraction);
}
else if(energy < 6.){
- fhMCLambda0vsClusterMaxCellDiffE2[mcssElectron]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE2[mcssElectron] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE2[kmcssElectron]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE2[kmcssElectron] ->Fill(ncells, maxCellFraction);
}
else{
- fhMCLambda0vsClusterMaxCellDiffE6[mcssElectron]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE6[mcssElectron] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE6[kmcssElectron]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE6[kmcssElectron] ->Fill(ncells, maxCellFraction);
}
}//electron
else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) &&
GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion) ){
- fhMCELambda0[mcssConversion] ->Fill(energy, lambda0);
- fhMCELambda1[mcssConversion] ->Fill(energy, lambda1);
- fhMCEDispersion[mcssConversion] ->Fill(energy, disp);
- fhMCNCellsE[mcssConversion] ->Fill(energy, ncells);
- fhMCMaxCellDiffClusterE[mcssConversion]->Fill(energy,maxCellFraction);
+ fhMCELambda0[kmcssConversion] ->Fill(energy, lambda0);
+ fhMCELambda1[kmcssConversion] ->Fill(energy, lambda1);
+ fhMCEDispersion[kmcssConversion] ->Fill(energy, disp);
+ fhMCNCellsE[kmcssConversion] ->Fill(energy, ncells);
+ fhMCMaxCellDiffClusterE[kmcssConversion]->Fill(energy,maxCellFraction);
if (energy < 2.){
- fhMCLambda0vsClusterMaxCellDiffE0[mcssConversion]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE0[mcssConversion] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE0[kmcssConversion]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE0[kmcssConversion] ->Fill(ncells, maxCellFraction);
}
else if(energy < 6.){
- fhMCLambda0vsClusterMaxCellDiffE2[mcssConversion]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE2[mcssConversion] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE2[kmcssConversion]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE2[kmcssConversion] ->Fill(ncells, maxCellFraction);
}
else{
- fhMCLambda0vsClusterMaxCellDiffE6[mcssConversion]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE6[mcssConversion] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE6[kmcssConversion]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE6[kmcssConversion] ->Fill(ncells, maxCellFraction);
}
}//conversion photon
else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) ){
- fhMCELambda0[mcssPi0] ->Fill(energy, lambda0);
- fhMCELambda1[mcssPi0] ->Fill(energy, lambda1);
- fhMCEDispersion[mcssPi0] ->Fill(energy, disp);
- fhMCNCellsE[mcssPi0] ->Fill(energy, ncells);
- fhMCMaxCellDiffClusterE[mcssPi0]->Fill(energy,maxCellFraction);
+ fhMCELambda0[kmcssPi0] ->Fill(energy, lambda0);
+ fhMCELambda1[kmcssPi0] ->Fill(energy, lambda1);
+ fhMCEDispersion[kmcssPi0] ->Fill(energy, disp);
+ fhMCNCellsE[kmcssPi0] ->Fill(energy, ncells);
+ fhMCMaxCellDiffClusterE[kmcssPi0]->Fill(energy,maxCellFraction);
if (energy < 2.){
- fhMCLambda0vsClusterMaxCellDiffE0[mcssPi0]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE0[mcssPi0] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE0[kmcssPi0]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE0[kmcssPi0] ->Fill(ncells, maxCellFraction);
}
else if(energy < 6.){
- fhMCLambda0vsClusterMaxCellDiffE2[mcssPi0]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE2[mcssPi0] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE2[kmcssPi0]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE2[kmcssPi0] ->Fill(ncells, maxCellFraction);
}
else{
- fhMCLambda0vsClusterMaxCellDiffE6[mcssPi0]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE6[mcssPi0] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE6[kmcssPi0]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE6[kmcssPi0] ->Fill(ncells, maxCellFraction);
}
//Fill histograms to check shape of embedded clusters
}//pi0
else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) ){
- fhMCELambda0[mcssEta] ->Fill(energy, lambda0);
- fhMCELambda1[mcssEta] ->Fill(energy, lambda1);
- fhMCEDispersion[mcssEta] ->Fill(energy, disp);
- fhMCNCellsE[mcssEta] ->Fill(energy, ncells);
- fhMCMaxCellDiffClusterE[mcssEta]->Fill(energy,maxCellFraction);
+ fhMCELambda0[kmcssEta] ->Fill(energy, lambda0);
+ fhMCELambda1[kmcssEta] ->Fill(energy, lambda1);
+ fhMCEDispersion[kmcssEta] ->Fill(energy, disp);
+ fhMCNCellsE[kmcssEta] ->Fill(energy, ncells);
+ fhMCMaxCellDiffClusterE[kmcssEta]->Fill(energy,maxCellFraction);
if (energy < 2.){
- fhMCLambda0vsClusterMaxCellDiffE0[mcssEta]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE0[mcssEta] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE0[kmcssEta]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE0[kmcssEta] ->Fill(ncells, maxCellFraction);
}
else if(energy < 6.){
- fhMCLambda0vsClusterMaxCellDiffE2[mcssEta]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE2[mcssEta] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE2[kmcssEta]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE2[kmcssEta] ->Fill(ncells, maxCellFraction);
}
else{
- fhMCLambda0vsClusterMaxCellDiffE6[mcssEta]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE6[mcssEta] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE6[kmcssEta]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE6[kmcssEta] ->Fill(ncells, maxCellFraction);
}
}//eta
else {
- fhMCELambda0[mcssOther] ->Fill(energy, lambda0);
- fhMCELambda1[mcssOther] ->Fill(energy, lambda1);
- fhMCEDispersion[mcssOther] ->Fill(energy, disp);
- fhMCNCellsE[mcssOther] ->Fill(energy, ncells);
- fhMCMaxCellDiffClusterE[mcssOther]->Fill(energy,maxCellFraction);
+ fhMCELambda0[kmcssOther] ->Fill(energy, lambda0);
+ fhMCELambda1[kmcssOther] ->Fill(energy, lambda1);
+ fhMCEDispersion[kmcssOther] ->Fill(energy, disp);
+ fhMCNCellsE[kmcssOther] ->Fill(energy, ncells);
+ fhMCMaxCellDiffClusterE[kmcssOther]->Fill(energy,maxCellFraction);
if (energy < 2.){
- fhMCLambda0vsClusterMaxCellDiffE0[mcssOther]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE0[mcssOther] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE0[kmcssOther]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE0[kmcssOther] ->Fill(ncells, maxCellFraction);
}
else if(energy < 6.){
- fhMCLambda0vsClusterMaxCellDiffE2[mcssOther]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE2[mcssOther] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE2[kmcssOther]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE2[kmcssOther] ->Fill(ncells, maxCellFraction);
}
else{
- fhMCLambda0vsClusterMaxCellDiffE6[mcssOther]->Fill(lambda0, maxCellFraction);
- fhMCNCellsvsClusterMaxCellDiffE6[mcssOther] ->Fill(ncells, maxCellFraction);
+ fhMCLambda0vsClusterMaxCellDiffE6[kmcssOther]->Fill(lambda0, maxCellFraction);
+ fhMCNCellsvsClusterMaxCellDiffE6[kmcssOther] ->Fill(ncells, maxCellFraction);
}
}//other particles
Int_t tag =ph->GetTag();
- if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) && fhMCE[mcPhoton])
+ if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) && fhMCE[kmcPhoton])
{
- fhMCE [mcPhoton] ->Fill(ecluster);
- fhMCPt [mcPhoton] ->Fill(ptcluster);
- fhMCPhi[mcPhoton] ->Fill(ecluster,phicluster);
- fhMCEta[mcPhoton] ->Fill(ecluster,etacluster);
+ fhMCE [kmcPhoton] ->Fill(ecluster);
+ fhMCPt [kmcPhoton] ->Fill(ptcluster);
+ fhMCPhi[kmcPhoton] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcPhoton] ->Fill(ecluster,etacluster);
- fhMC2E[mcPhoton] ->Fill(ecluster, eprim);
- fhMC2Pt[mcPhoton] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcPhoton] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcPhoton]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcPhoton] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcPhoton] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcPhoton] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcPhoton]->Fill(ptcluster,ptprim-ptcluster);
- if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion) && fhMCE[mcConversion])
+ if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion) && fhMCE[kmcConversion])
{
- fhMCE [mcConversion] ->Fill(ecluster);
- fhMCPt [mcConversion] ->Fill(ptcluster);
- fhMCPhi[mcConversion] ->Fill(ecluster,phicluster);
- fhMCEta[mcConversion] ->Fill(ecluster,etacluster);
+ fhMCE [kmcConversion] ->Fill(ecluster);
+ fhMCPt [kmcConversion] ->Fill(ptcluster);
+ fhMCPhi[kmcConversion] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcConversion] ->Fill(ecluster,etacluster);
- fhMC2E[mcConversion] ->Fill(ecluster, eprim);
- fhMC2Pt[mcConversion] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcConversion] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcConversion]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcConversion] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcConversion] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcConversion] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcConversion]->Fill(ptcluster,ptprim-ptcluster);
}
- if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) && fhMCE[mcPrompt]){
- fhMCE [mcPrompt] ->Fill(ecluster);
- fhMCPt [mcPrompt] ->Fill(ptcluster);
- fhMCPhi[mcPrompt] ->Fill(ecluster,phicluster);
- fhMCEta[mcPrompt] ->Fill(ecluster,etacluster);
+ if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) && fhMCE[kmcPrompt]){
+ fhMCE [kmcPrompt] ->Fill(ecluster);
+ fhMCPt [kmcPrompt] ->Fill(ptcluster);
+ fhMCPhi[kmcPrompt] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcPrompt] ->Fill(ecluster,etacluster);
- fhMC2E[mcPrompt] ->Fill(ecluster, eprim);
- fhMC2Pt[mcPrompt] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcPrompt] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcPrompt]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcPrompt] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcPrompt] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcPrompt] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcPrompt]->Fill(ptcluster,ptprim-ptcluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation)&& fhMCE[mcFragmentation])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation)&& fhMCE[kmcFragmentation])
{
- fhMCE [mcFragmentation] ->Fill(ecluster);
- fhMCPt [mcFragmentation] ->Fill(ptcluster);
- fhMCPhi[mcFragmentation] ->Fill(ecluster,phicluster);
- fhMCEta[mcFragmentation] ->Fill(ecluster,etacluster);
+ fhMCE [kmcFragmentation] ->Fill(ecluster);
+ fhMCPt [kmcFragmentation] ->Fill(ptcluster);
+ fhMCPhi[kmcFragmentation] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcFragmentation] ->Fill(ecluster,etacluster);
- fhMC2E[mcFragmentation] ->Fill(ecluster, eprim);
- fhMC2Pt[mcFragmentation] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcFragmentation] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcFragmentation]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcFragmentation] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcFragmentation] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcFragmentation] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcFragmentation]->Fill(ptcluster,ptprim-ptcluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR)&& fhMCE[mcISR])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR)&& fhMCE[kmcISR])
{
- fhMCE [mcISR] ->Fill(ecluster);
- fhMCPt [mcISR] ->Fill(ptcluster);
- fhMCPhi[mcISR] ->Fill(ecluster,phicluster);
- fhMCEta[mcISR] ->Fill(ecluster,etacluster);
+ fhMCE [kmcISR] ->Fill(ecluster);
+ fhMCPt [kmcISR] ->Fill(ptcluster);
+ fhMCPhi[kmcISR] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcISR] ->Fill(ecluster,etacluster);
- fhMC2E[mcISR] ->Fill(ecluster, eprim);
- fhMC2Pt[mcISR] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcISR] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcISR]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcISR] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcISR] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcISR] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcISR]->Fill(ptcluster,ptprim-ptcluster);
}
else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay) &&
- !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) && fhMCE[mcPi0Decay])
+ !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) && fhMCE[kmcPi0Decay])
{
- fhMCE [mcPi0Decay] ->Fill(ecluster);
- fhMCPt [mcPi0Decay] ->Fill(ptcluster);
- fhMCPhi[mcPi0Decay] ->Fill(ecluster,phicluster);
- fhMCEta[mcPi0Decay] ->Fill(ecluster,etacluster);
+ fhMCE [kmcPi0Decay] ->Fill(ecluster);
+ fhMCPt [kmcPi0Decay] ->Fill(ptcluster);
+ fhMCPhi[kmcPi0Decay] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcPi0Decay] ->Fill(ecluster,etacluster);
- fhMC2E[mcPi0Decay] ->Fill(ecluster, eprim);
- fhMC2Pt[mcPi0Decay] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcPi0Decay] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcPi0Decay]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcPi0Decay] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcPi0Decay] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcPi0Decay] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcPi0Decay]->Fill(ptcluster,ptprim-ptcluster);
}
else if( (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) ||
- GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay) ) && fhMCE[mcOtherDecay])
+ GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay) ) && fhMCE[kmcOtherDecay])
{
- fhMCE [mcOtherDecay] ->Fill(ecluster);
- fhMCPt [mcOtherDecay] ->Fill(ptcluster);
- fhMCPhi[mcOtherDecay] ->Fill(ecluster,phicluster);
- fhMCEta[mcOtherDecay] ->Fill(ecluster,etacluster);
+ fhMCE [kmcOtherDecay] ->Fill(ecluster);
+ fhMCPt [kmcOtherDecay] ->Fill(ptcluster);
+ fhMCPhi[kmcOtherDecay] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcOtherDecay] ->Fill(ecluster,etacluster);
- fhMC2E[mcOtherDecay] ->Fill(ecluster, eprim);
- fhMC2Pt[mcOtherDecay] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcOtherDecay] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcOtherDecay]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcOtherDecay] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcOtherDecay] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcOtherDecay] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcOtherDecay]->Fill(ptcluster,ptprim-ptcluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) && fhMCE [mcPi0])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) && fhMCE [kmcPi0])
{
- fhMCE [mcPi0] ->Fill(ecluster);
- fhMCPt [mcPi0] ->Fill(ptcluster);
- fhMCPhi[mcPi0] ->Fill(ecluster,phicluster);
- fhMCEta[mcPi0] ->Fill(ecluster,etacluster);
+ fhMCE [kmcPi0] ->Fill(ecluster);
+ fhMCPt [kmcPi0] ->Fill(ptcluster);
+ fhMCPhi[kmcPi0] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcPi0] ->Fill(ecluster,etacluster);
- fhMC2E[mcPi0] ->Fill(ecluster, eprim);
- fhMC2Pt[mcPi0] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcPi0] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcPi0]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcPi0] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcPi0] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcPi0] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcPi0]->Fill(ptcluster,ptprim-ptcluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) && fhMCE[mcEta])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) && fhMCE[kmcEta])
{
- fhMCE [mcEta] ->Fill(ecluster);
- fhMCPt [mcEta] ->Fill(ptcluster);
- fhMCPhi[mcEta] ->Fill(ecluster,phicluster);
- fhMCEta[mcEta] ->Fill(ecluster,etacluster);
+ fhMCE [kmcEta] ->Fill(ecluster);
+ fhMCPt [kmcEta] ->Fill(ptcluster);
+ fhMCPhi[kmcEta] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcEta] ->Fill(ecluster,etacluster);
- fhMC2E[mcEta] ->Fill(ecluster, eprim);
- fhMC2Pt[mcEta] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcEta] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcEta]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcEta] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcEta] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcEta] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcEta]->Fill(ptcluster,ptprim-ptcluster);
}
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiNeutron) && fhMCE[mcAntiNeutron])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiNeutron) && fhMCE[kmcAntiNeutron])
{
- fhMCE [mcAntiNeutron] ->Fill(ecluster);
- fhMCPt [mcAntiNeutron] ->Fill(ptcluster);
- fhMCPhi[mcAntiNeutron] ->Fill(ecluster,phicluster);
- fhMCEta[mcAntiNeutron] ->Fill(ecluster,etacluster);
+ fhMCE [kmcAntiNeutron] ->Fill(ecluster);
+ fhMCPt [kmcAntiNeutron] ->Fill(ptcluster);
+ fhMCPhi[kmcAntiNeutron] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcAntiNeutron] ->Fill(ecluster,etacluster);
- fhMC2E[mcAntiNeutron] ->Fill(ecluster, eprim);
- fhMC2Pt[mcAntiNeutron] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcAntiNeutron] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcAntiNeutron]->Fill(ptcluster,ptprim-ptcluster);
+ fhMC2E[kmcAntiNeutron] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcAntiNeutron] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcAntiNeutron] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcAntiNeutron]->Fill(ptcluster,ptprim-ptcluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiProton) && fhMCE[mcAntiProton])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiProton) && fhMCE[kmcAntiProton])
{
- fhMCE [mcAntiProton] ->Fill(ecluster);
- fhMCPt [mcAntiProton] ->Fill(ptcluster);
- fhMCPhi[mcAntiProton] ->Fill(ecluster,phicluster);
- fhMCEta[mcAntiProton] ->Fill(ecluster,etacluster);
+ fhMCE [kmcAntiProton] ->Fill(ecluster);
+ fhMCPt [kmcAntiProton] ->Fill(ptcluster);
+ fhMCPhi[kmcAntiProton] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcAntiProton] ->Fill(ecluster,etacluster);
- fhMC2E[mcAntiProton] ->Fill(ecluster, eprim);
- fhMC2Pt[mcAntiProton] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcAntiProton] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcAntiProton]->Fill(ecluster,ptprim-ptcluster);
+ fhMC2E[kmcAntiProton] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcAntiProton] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcAntiProton] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcAntiProton]->Fill(ecluster,ptprim-ptcluster);
}
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron) && fhMCE[mcElectron])
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron) && fhMCE[kmcElectron])
{
- fhMCE [mcElectron] ->Fill(ecluster);
- fhMCPt [mcElectron] ->Fill(ptcluster);
- fhMCPhi[mcElectron] ->Fill(ecluster,phicluster);
- fhMCEta[mcElectron] ->Fill(ecluster,etacluster);
+ fhMCE [kmcElectron] ->Fill(ecluster);
+ fhMCPt [kmcElectron] ->Fill(ptcluster);
+ fhMCPhi[kmcElectron] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcElectron] ->Fill(ecluster,etacluster);
- fhMC2E[mcElectron] ->Fill(ecluster, eprim);
- fhMC2Pt[mcElectron] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcElectron] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcElectron]->Fill(ecluster,ptprim-ptcluster);
+ fhMC2E[kmcElectron] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcElectron] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcElectron] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcElectron]->Fill(ecluster,ptprim-ptcluster);
}
- else if( fhMCE[mcOther]){
- fhMCE [mcOther] ->Fill(ecluster);
- fhMCPt [mcOther] ->Fill(ptcluster);
- fhMCPhi[mcOther] ->Fill(ecluster,phicluster);
- fhMCEta[mcOther] ->Fill(ecluster,etacluster);
+ else if( fhMCE[kmcOther]){
+ fhMCE [kmcOther] ->Fill(ecluster);
+ fhMCPt [kmcOther] ->Fill(ptcluster);
+ fhMCPhi[kmcOther] ->Fill(ecluster,phicluster);
+ fhMCEta[kmcOther] ->Fill(ecluster,etacluster);
- fhMC2E[mcOther] ->Fill(ecluster, eprim);
- fhMC2Pt[mcOther] ->Fill(ptcluster, ptprim);
- fhMCDeltaE[mcOther] ->Fill(ecluster,eprim-ecluster);
- fhMCDeltaPt[mcOther]->Fill(ecluster,ptprim-ptcluster);
+ fhMC2E[kmcOther] ->Fill(ecluster, eprim);
+ fhMC2Pt[kmcOther] ->Fill(ptcluster, ptprim);
+ fhMCDeltaE[kmcOther] ->Fill(ecluster,eprim-ecluster);
+ fhMCDeltaPt[kmcOther]->Fill(ecluster,ptprim-ptcluster);
// printf(" AliAnaPhoton::MakeAnalysisFillHistograms() - Label %d, pT %2.3f Unknown, bits set: ",
// ph->GetLabel(),ph->Pt());
public:
AliAnaPhoton() ; // default ctor
virtual ~AliAnaPhoton() { ; } // virtual dtor
- private:
- AliAnaPhoton(const AliAnaPhoton & g) ; // cpy ctor
- AliAnaPhoton & operator = (const AliAnaPhoton & g) ; // cpy assignment
-
- public:
//---------------------------------------
// General analysis frame methods
if(n > 7) fNPrimaryHistograms = 7; }
// For histograms in arrays, index in the array, corresponding to a particle
- enum mcTypes { mcPhoton = 0, mcPi0Decay = 1, mcOtherDecay = 2,
- mcPi0 = 3, mcEta = 4, mcElectron = 5,
- mcConversion = 6, mcOther = 7, mcAntiNeutron = 8,
- mcAntiProton = 9, mcPrompt = 10, mcFragmentation = 11,
- mcISR = 12, mcString = 13 };
+ enum mcTypes { kmcPhoton = 0, kmcPi0Decay = 1, kmcOtherDecay = 2,
+ kmcPi0 = 3, kmcEta = 4, kmcElectron = 5,
+ kmcConversion = 6, kmcOther = 7, kmcAntiNeutron = 8,
+ kmcAntiProton = 9, kmcPrompt = 10, kmcFragmentation = 11,
+ kmcISR = 12, kmcString = 13 };
- enum mcPTypes { mcPPhoton = 0, mcPPi0Decay = 1, mcPOtherDecay = 2, mcPOther = 3,
- mcPPrompt = 4, mcPFragmentation = 5, mcPISR = 6 };
+ enum mcPTypes { kmcPPhoton = 0, kmcPPi0Decay = 1, kmcPOtherDecay = 2, kmcPOther = 3,
+ kmcPPrompt = 4, kmcPFragmentation = 5, kmcPISR = 6 };
- enum mcssTypes { mcssPhoton = 0, mcssOther = 1, mcssPi0 = 2,
- mcssEta = 3, mcssConversion = 4, mcssElectron = 5 };
+ enum mcssTypes { kmcssPhoton = 0, kmcssOther = 1, kmcssPi0 = 2,
+ kmcssEta = 3, kmcssConversion = 4, kmcssElectron = 5 };
private:
TH2F * fhEmbedPi0ELambda0MostlyBkg ; //! Lambda0 vs E for embedded photons with 50%<fraction<10%
TH2F * fhEmbedPi0ELambda0FullBkg ; //! Lambda0 vs E for embedded photons with less than 10% of the cluster energy
- ClassDef(AliAnaPhoton,19)
+ AliAnaPhoton(const AliAnaPhoton & g) ; // cpy ctor
+ AliAnaPhoton & operator = (const AliAnaPhoton & g) ; // cpy assignment
+
+ ClassDef(AliAnaPhoton,19)
} ;
#include "AliMixedEvent.h"
#include "AliAODMCParticle.h"
+// --- Detectors ---
+#include "AliPHOSGeoUtils.h"
+#include "AliEMCALGeometry.h"
+
ClassImp(AliAnaPi0)
//________________________________________________________________________________________________________________________________________________
}
}
delete[] fEventsList;
- fEventsList=0 ;
}
}
public:
AliAnaPi0() ; // default ctor
virtual ~AliAnaPi0() ;//virtual dtor
- private:
- AliAnaPi0(const AliAnaPi0 & g) ; // cpy ctor
- AliAnaPi0 & operator = (const AliAnaPi0 & api0) ;//cpy assignment
- public:
-
//-------------------------------
// General analysis frame methods
//-------------------------------
TH2F * fhReMCFromNotConversion ; //! Invariant mass of 2 clusters not originated in conversions
TH2F * fhReMCFromMixConversion ; //! Invariant mass of 2 clusters one from conversion and the other not
-
+ AliAnaPi0(const AliAnaPi0 & g) ; // cpy ctor
+ AliAnaPi0 & operator = (const AliAnaPi0 & api0) ;//cpy assignment
ClassDef(AliAnaPi0,21)
} ;
if(IsDataMC()) {
//Photon1
if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ){
- fhEMCLambda0[mcPi0] ->Fill(e, l0);
- fhEMCLambda1[mcPi0] ->Fill(e, l1);
- fhEMCDispersion[mcPi0] ->Fill(e, disp);
+ fhEMCLambda0[kmcPi0] ->Fill(e, l0);
+ fhEMCLambda1[kmcPi0] ->Fill(e, l1);
+ fhEMCDispersion[kmcPi0] ->Fill(e, disp);
- fhEMCFracMaxCell[mcPi0]->Fill(e,maxCellFraction);
+ fhEMCFracMaxCell[kmcPi0]->Fill(e,maxCellFraction);
if(fCalorimeter=="EMCAL" && nSM < 6)
- fhEMCLambda0NoTRD[mcPi0]->Fill(e, l0 );
+ fhEMCLambda0NoTRD[kmcPi0]->Fill(e, l0 );
if(maxCellFraction < 0.5)
- fhEMCLambda0FracMaxCellCut[mcPi0]->Fill(e, l0 );
+ fhEMCLambda0FracMaxCellCut[kmcPi0]->Fill(e, l0 );
}//pi0
else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) ){
- fhEMCLambda0[mcEta] ->Fill(e, l0);
- fhEMCLambda1[mcEta] ->Fill(e, l1);
- fhEMCDispersion[mcEta] ->Fill(e, disp);
- fhEMCFracMaxCell[mcEta]->Fill(e,maxCellFraction);
+ fhEMCLambda0[kmcEta] ->Fill(e, l0);
+ fhEMCLambda1[kmcEta] ->Fill(e, l1);
+ fhEMCDispersion[kmcEta] ->Fill(e, disp);
+ fhEMCFracMaxCell[kmcEta]->Fill(e,maxCellFraction);
if(fCalorimeter=="EMCAL" && nSM < 6)
- fhEMCLambda0NoTRD[mcEta]->Fill(e, l0 );
+ fhEMCLambda0NoTRD[kmcEta]->Fill(e, l0 );
if(maxCellFraction < 0.5)
- fhEMCLambda0FracMaxCellCut[mcEta]->Fill(e, l0 );
+ fhEMCLambda0FracMaxCellCut[kmcEta]->Fill(e, l0 );
}//eta
else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion) ){
- fhEMCLambda0[mcConversion] ->Fill(e, l0);
- fhEMCLambda1[mcConversion] ->Fill(e, l1);
- fhEMCDispersion[mcConversion] ->Fill(e, disp);
- fhEMCFracMaxCell[mcConversion]->Fill(e,maxCellFraction);
+ fhEMCLambda0[kmcConversion] ->Fill(e, l0);
+ fhEMCLambda1[kmcConversion] ->Fill(e, l1);
+ fhEMCDispersion[kmcConversion] ->Fill(e, disp);
+ fhEMCFracMaxCell[kmcConversion]->Fill(e,maxCellFraction);
if(fCalorimeter=="EMCAL" && nSM < 6)
- fhEMCLambda0NoTRD[mcConversion]->Fill(e, l0 );
+ fhEMCLambda0NoTRD[kmcConversion]->Fill(e, l0 );
if(maxCellFraction < 0.5)
- fhEMCLambda0FracMaxCellCut[mcConversion]->Fill(e, l0 );
+ fhEMCLambda0FracMaxCellCut[kmcConversion]->Fill(e, l0 );
}//conversion photon
else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) ){
- fhEMCLambda0[mcPhoton] ->Fill(e, l0);
- fhEMCLambda1[mcPhoton] ->Fill(e, l1);
- fhEMCDispersion[mcPhoton] ->Fill(e, disp);
- fhEMCFracMaxCell[mcPhoton]->Fill(e,maxCellFraction);
+ fhEMCLambda0[kmcPhoton] ->Fill(e, l0);
+ fhEMCLambda1[kmcPhoton] ->Fill(e, l1);
+ fhEMCDispersion[kmcPhoton] ->Fill(e, disp);
+ fhEMCFracMaxCell[kmcPhoton]->Fill(e,maxCellFraction);
if(fCalorimeter=="EMCAL" && nSM < 6)
- fhEMCLambda0NoTRD[mcPhoton]->Fill(e, l0 );
+ fhEMCLambda0NoTRD[kmcPhoton]->Fill(e, l0 );
if(maxCellFraction < 0.5)
- fhEMCLambda0FracMaxCellCut[mcPhoton]->Fill(e, l0 );
+ fhEMCLambda0FracMaxCellCut[kmcPhoton]->Fill(e, l0 );
}//photon no conversion
else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)){
- fhEMCLambda0[mcElectron] ->Fill(e, l0);
- fhEMCLambda1[mcElectron] ->Fill(e, l1);
- fhEMCDispersion[mcElectron] ->Fill(e, disp);
- fhEMCFracMaxCell[mcElectron]->Fill(e,maxCellFraction);
+ fhEMCLambda0[kmcElectron] ->Fill(e, l0);
+ fhEMCLambda1[kmcElectron] ->Fill(e, l1);
+ fhEMCDispersion[kmcElectron] ->Fill(e, disp);
+ fhEMCFracMaxCell[kmcElectron]->Fill(e,maxCellFraction);
if(fCalorimeter=="EMCAL" && nSM < 6)
- fhEMCLambda0NoTRD[mcElectron]->Fill(e, l0 );
+ fhEMCLambda0NoTRD[kmcElectron]->Fill(e, l0 );
if(maxCellFraction < 0.5)
- fhEMCLambda0FracMaxCellCut[mcElectron]->Fill(e, l0 );
+ fhEMCLambda0FracMaxCellCut[kmcElectron]->Fill(e, l0 );
}//electron
else {
- fhEMCLambda0[mcHadron] ->Fill(e, l0);
- fhEMCLambda1[mcHadron] ->Fill(e, l1);
- fhEMCDispersion[mcHadron] ->Fill(e, disp);
- fhEMCFracMaxCell[mcHadron]->Fill(e,maxCellFraction);
+ fhEMCLambda0[kmcHadron] ->Fill(e, l0);
+ fhEMCLambda1[kmcHadron] ->Fill(e, l1);
+ fhEMCDispersion[kmcHadron] ->Fill(e, disp);
+ fhEMCFracMaxCell[kmcHadron]->Fill(e,maxCellFraction);
if(fCalorimeter=="EMCAL" && nSM < 6)
- fhEMCLambda0NoTRD[mcHadron]->Fill(e, l0 );
+ fhEMCLambda0NoTRD[kmcHadron]->Fill(e, l0 );
if(maxCellFraction < 0.5)
- fhEMCLambda0FracMaxCellCut[mcHadron]->Fill(e, l0 );
+ fhEMCLambda0FracMaxCellCut[kmcHadron]->Fill(e, l0 );
}//other particles
}//MC
}
public:
AliAnaPi0EbE() ; // default ctor
virtual ~AliAnaPi0EbE() { ; } //virtual dtor
- private:
- AliAnaPi0EbE(const AliAnaPi0EbE & g) ; // cpy ctor
- AliAnaPi0EbE & operator = (const AliAnaPi0EbE & g) ;//cpy assignment
-
- public:
-
- //General
-
+
TObjString * GetAnalysisCuts();
TList * GetCreateOutputObjects();
void MakeShowerShapeIdentification() ;
void RecalibrateCellAmplitude(Float_t & amp, const Int_t absId);
-
- void SwitchOnFillWeightHistograms() { fFillWeightHistograms = kTRUE ; }
- void SwitchOffFillWeightHistograms() { fFillWeightHistograms = kFALSE ; }
-
+
//Setters Getters
//Analysis types
void SetMinDistanceToBadChannel(Float_t m1, Float_t m2, Float_t m3) {
fMinDist = m1; fMinDist2 = m2; fMinDist3 = m3 ; }
+ void SwitchOnFillWeightHistograms() { fFillWeightHistograms = kTRUE ; }
+ void SwitchOffFillWeightHistograms() { fFillWeightHistograms = kFALSE ; }
+
//For histograms
- enum mcTypes { mcPhoton = 0, mcConversion = 1, mcPi0 = 2,
- mcEta = 3, mcElectron = 4, mcHadron = 5 };
+ enum mcTypes { kmcPhoton = 0, kmcConversion = 1, kmcPi0 = 2,
+ kmcEta = 3, kmcElectron = 4, kmcHadron = 5 };
private:
- anaTypes fAnaType; //Select analysis type
+ anaTypes fAnaType; // Select analysis type
//Only for pi0 SS identification case, kSSCalo
TString fCalorimeter ; // Calorimeter where the gamma is searched;
TH2F * fhECellClusterLogRatio; //! log (e cell / e cluster) vs e cluster for selected photons
TH2F * fhEMaxCellClusterRatio; //! e max cell / e cluster vs e cluster for selected photons
TH2F * fhEMaxCellClusterLogRatio;//! log (e max cell / e cluster) vs e cluster for selected photons
- TH2F * fhLambda0ForW0[14]; //! L0 for 7 defined w0= 3, 3.5 ... 6 for selected photons
+ TH2F * fhLambda0ForW0[14]; //! L0 for 7 defined w0= 3, 3.5 ... 6 for selected photons
//TH2F * fhLambda1ForW0[7]; //! L1 for 7 defined w0= 3, 3.5 ... 6 for selected photons
+ AliAnaPi0EbE(const AliAnaPi0EbE & g) ; // cpy ctor
+ AliAnaPi0EbE & operator = (const AliAnaPi0EbE & g) ; // cpy assignment
+
ClassDef(AliAnaPi0EbE,10)
} ;
public:
AliAnaShowerParameter() ; // default ctor
- AliAnaShowerParameter(const AliAnaShowerParameter & g) ; // cpy ctor
- AliAnaShowerParameter & operator = (const AliAnaShowerParameter & g) ;//cpy assignment
virtual ~AliAnaShowerParameter() ; //virtual dtor
TList * GetCreateOutputObjects();
private:
- TString fCalorimeter ; // Calorimeter where the gamma is searched;
- Float_t fNCellsCutMin ;
- Float_t fNCellsCutMax ;
- Float_t fLambdaCut ;
- Double_t fTimeCutMin ; // Remove clusters/cells with time smaller than this value, in ns
- Double_t fTimeCutMax ; // Remove clusters/cells with time larger than this value, in ns
+ TString fCalorimeter ; // Calorimeter where the gamma is searched;
+ Float_t fNCellsCutMin ; // N cells cut min
+ Float_t fNCellsCutMax ; // N cells cut max
+ Float_t fLambdaCut ; // l0 cut
+ Double_t fTimeCutMin ; // Remove clusters/cells with time smaller than this value, in ns
+ Double_t fTimeCutMax ; // Remove clusters/cells with time larger than this value, in ns
//Histograms
- TH1F * fhNClusters ;
- TH2F * fhNCellCluster;
- TH3F * fhEtaPhiPtCluster ;
- TH2F * fhLambdaPtCluster ;
+ TH1F * fhNClusters ; //! cluster
+ TH2F * fhNCellCluster; //! cells per cluster
+ TH3F * fhEtaPhiPtCluster; //! eta vs phi vs pt
+ TH2F * fhLambdaPtCluster; //! l0 vs pt
//MC
- TH2F * fhLambdaPtPhoton ;
- TH2F * fhLambdaPtPi0 ;
- TH2F * fhLambdaPtPion ;
- TH1D * fhPtTruthPi0 ;
+ TH2F * fhLambdaPtPhoton ; //! l0 vs pt mc photon
+ TH2F * fhLambdaPtPi0 ; //! l0 vs pt mc pi0
+ TH2F * fhLambdaPtPion ; //! l0 vs pt mc pi charged
+ TH1D * fhPtTruthPi0 ; //! pi0 pt mc
+ AliAnaShowerParameter(const AliAnaShowerParameter & g) ; // cpy ctor
+ AliAnaShowerParameter & operator = (const AliAnaShowerParameter & g) ; // cpy assignment
+
ClassDef(AliAnaShowerParameter,1)
} ;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff