#include "AliJConst.h"
#include "AliESDpid.h"
#include "AliEMCALGeometry.h"
-#include "AliEMCALRecoUtils.h"
#include "AliPHOSGeoUtils.h"
#include "AliPIDResponse.h"
#include "AliPIDCombined.h"
// methods to read data from ESD
void ReadESDTracks(AliESDEvent* esd);
void ReadESDCaloClusters(const AliESDEvent* esd);
- void ReadESDCaloCells(const AliESDEvent* esd);
void ReadESDHeader(AliESDEvent* esd);
void ReadESDPID(AliESDtrack* track, AliJTrack* ctrack);
// methods to read data from AOD
void ReadAODTracks(const AliAODEvent* aod);
void ReadAODCaloClusters(const AliAODEvent* aod);
- void ReadAODCaloCells(const AliAODEvent* aod);
void ReadAODHeader(AliAODEvent* aod);
void ReadFilter();
void ReadMCTracks(AliMCEvent* fMC);
- Int_t GetSuperModuleNumber(bool isemcal, AliVCluster *cluster, AliVCaloCells *cells, Int_t absId);
- Double_t* GetCellsAmplitude( bool isemcal, AliVCluster *cluster, AliVCaloCells *emCells, AliVCaloCells *phoCells );
+ Int_t GetSuperModuleNumber(bool isemcal, Int_t absId);
UInt_t ConvertTriggerMask();//Converts alice trigger mask to JCorran trigger mask
//functions used for event selction:
const char* GetOADBPath() const { return fOADBPath.Data(); }
// method to fill jcorran
+ bool SetAliceTriggerDef(AliJRunHeader *runHeader);
+ bool SetAliceFilterMapDef(AliJRunHeader *runHeader); //TODO Check
void PrintOut();
// UTILS
bool fStoreEventPlaneSource;
bool fStoreTPCTrack;
TString fOADBPath;
- TRefArray *fCaloClustersArr;
+
// jcorran output objects
TClonesArray * fTrackList; // list of charged track objects
TClonesArray * fMCTrackList; // list of charged track objects
TClonesArray * fPhotonList; // list of photons objects
- TClonesArray * fCaloCellList; // list of calo cells
TClonesArray * fHeaderList; // event details
TList * fRunInfoList; // run details
+ AliESDpid *fPIDesd;
AliPIDResponse *fPIDResponse; // PID response object
AliPIDCombined *fPIDCombined;
AliESDZDC* fZDCData;
AliJRunHeader* fAliRunHeader;// run details (mg field, trigger mask,etc...)
- AliEMCALGeometry * fEMCALGeometry;
- AliEMCALRecoUtils * fEMCALRecoUtils;
+ AliEMCALGeometry * fEMCALGeoUtils; // no AliEMCALGeoUtils.h in trunk aliroot (111130)
AliPHOSGeoUtils * fPHOSGeom; //phos geometry matrix
//=======================JCorran trigger table definition===========================
//internal JCorran trigger mask TBit=0 is MinBias, TBit=1 HighMultiplicityTrigger
-enum TriggerBitJCorran {kMinBiasTriggerBitJCorran, kHighMultTriggerBitJCorran,
- kEmc0TriggerBitJCorran,
- kEmc1GammaTriggerBitJCorran, kEmc1JetTriggerBitJCorran};
+enum TriggerBitJCorran {kMinBiasTriggerBitJCorran, kHighMultTriggerBitJCorran};
const int kRangeTriggerTableAlice = 50;
const int kRangeTriggerTableJCorran = 16;
fSPDTrackletMult(-999),
fV0Mult(-999),
fEventType(0),
- fFiredTriggers(),
fVtxMult(-9999) //FK// EFF
{
// default constructor
fSPDTrackletMult(refmult),
fV0Mult(v0mult),
fEventType(eventType),
- fFiredTriggers(),
fVtxMult(-9999) //FK// EFF
{
//constructor
fSPDTrackletMult(a.fSPDTrackletMult),
fV0Mult(a.fV0Mult),
fEventType(a.fEventType),
- fFiredTriggers(a.fFiredTriggers),
fVtxMult(a.fVtxMult) //FK// EFF
{
//copy constructor
fV0Mult = header.fV0Mult;
fEventType = header.fEventType;
fVtxMult = header.fVtxMult; //FK// EFF
- fFiredTriggers = header.fFiredTriggers;
for( int i=0;i<kcNTYPE;i++ ) fCentralityArray[i] = header.fCentralityArray[i];
}
void SetVtxMult(Int_t m){ fVtxMult = m; };//FK// EFF
void SetCentralityArray(UInt_t it, Float_t cen ){ if( it < kcNTYPE ) fCentralityArray[it]=cen; }
- TString GetFiredTriggers(){ return fFiredTriggers; }
- void SetFiredTriggers(TString s){ fFiredTriggers=s; }
-
AliJEventHeader& operator=(const AliJEventHeader& header);
private:
Int_t fSPDTrackletMult; //SPD tracklet multiplicity
Double32_t fV0Mult; // VZERO multiplicity
UInt_t fEventType; // Type of Event
- TString fFiredTriggers; // String with fired triggers from AOD
Int_t fVtxMult; //FK// EFF number of vertex contributors
Double32_t fCentralityArray[kcNTYPE]; //?//
fSuperModuleId(-999),
fCellsAbsId(0x0),
fCellsAmpFraction(0x0)
-// fCellsAmp(0x0)
{
// default constructor
fSuperModuleId(a.fSuperModuleId),
fCellsAbsId(NULL),
fCellsAmpFraction(NULL)
-// fCellsAmp(NULL)
{
//copy constructor
for(Int_t i=0;i<kUnknownAli+1;i++) fCaloPID[i] = a.fCaloPID[i];
SetCellsAbsId( a.fCellsAbsId );
SetCellsAmplitudeFraction( a.fCellsAmpFraction );
-// SetCellsAmplitude( a.fCellsAmp );
}
//_____________________________________________________________________________
fSuperModuleId = photon.fSuperModuleId;
SetCellsAbsId( photon.fCellsAbsId );
SetCellsAmplitudeFraction( photon.fCellsAmpFraction );
-// SetCellsAmplitude( photon.fCellsAmp );
}
}
}
-// //_______________________________________________________________________
-// void AliJPhoton::SetCellsAmplitude(const Double32_t *array)
-// {
-// // Set the array of cell amplitude fraction
-// if (fNCells) {
-// if(fCellsAmp){ delete [] fCellsAmp; fCellsAmp = NULL;}
-// fCellsAmp = new Double_t[fNCells];
-// for (Int_t i = 0; i < fNCells; i++) fCellsAmp[i] = array[i];
-// }
-// }
-
//______________________________________________________________________________
-void AliJPhoton::SetPID(const Double32_t *pid) {
+void AliJPhoton::SetPID(const Double_t *pid) {
//set pid
if(pid){
for(Int_t i=0; i<kUnknownAli+1; ++i) fCaloPID[i]=pid[i];
virtual ~AliJPhoton(){ //destructor
if(fCellsAbsId) delete [] fCellsAbsId;
if(fCellsAmpFraction) delete [] fCellsAmpFraction;
-// if(fCellsAmp) delete [] fCellsAmp;
}
- Double32_t GetChi2() const {return fChi2;}
- Double32_t GetTof() const {return fTof;}
- Double32_t GetX() const {return fX;}
- Double32_t GetY() const {return fY;}
- Double32_t GetZ() const {return fZ;}
- Double32_t GetProbPhot() const {return fProbPhot;}
+ float GetChi2() const {return fChi2;}
+ float GetTof() const {return fTof;}
+ float GetX() const {return fX;}
+ float GetY() const {return fY;}
+ float GetZ() const {return fZ;}
+ float GetProbPhot() const {return fProbPhot;}
- void SetChi2(Double32_t chi2) {fChi2=chi2;}
- void SetTof(Double32_t tof) {fTof=tof;}
- void SetPositionX(Double32_t x) {fX=x;}
- void SetPositionY(Double32_t y) {fY=y;}
- void SetPositionZ(Double32_t z) {fZ=z;}
- void SetProbPhot(Double32_t prob) {fProbPhot=prob;}
+ void SetChi2(float chi2) {fChi2=chi2;}
+ void SetTof(float tof) {fTof=tof;}
+ void SetPositionX(float x) {fX=x;}
+ void SetPositionY(float y) {fY=y;}
+ void SetPositionZ(float z) {fZ=z;}
+ void SetProbPhot(float prob) {fProbPhot=prob;}
AliJPhoton& operator=(const AliJPhoton& photon);
void GetPID(Double_t *pid) const {
for(Int_t i=0; i<kUnknownAli+1; ++i) pid[i]=fCaloPID[i];
}
- Double32_t GetDistToBadChannel() const {return fDistToBadChannel;}
- Double32_t GetDispersion() const {return fDispersion;}
- Double32_t GetM20() const {return fM20;}
- Double32_t GetM02() const {return fM02;}
- Double32_t GetEmcCpvDist() const {return fEmcCpvDist;}
- Int_t GetNCells() const { return fNCells;}
+ Double_t GetDistToBadChannel() const {return fDistToBadChannel;}
+ Double_t GetDispersion() const {return fDispersion;}
+ Double_t GetM20() const {return fM20;}
+ Double_t GetM02() const {return fM02;}
+ Double_t GetEmcCpvDist() const {return fEmcCpvDist;}
+ Double_t GetNCells() const { return fNCells;}
UShort_t *GetCellsAbsId() const {return fCellsAbsId;}
Int_t GetCellAbsId(Int_t i) const {
if (fCellsAbsId && i >=0 && i < fNCells ) return fCellsAbsId[i];
else return -1;}
Double32_t *GetCellsAmplitudeFraction() const {return fCellsAmpFraction;}
- Double32_t GetCellAmplitudeFraction(Int_t i) const {
+ Double_t GetCellAmplitudeFraction(Int_t i) const {
if (fCellsAmpFraction && i >=0 && i < fNCells ) return fCellsAmpFraction[i];
else return -1;}
-// Double32_t *GetCellsAmplitude() const {return fCellsAmp;}
-// Double32_t GetCellAmplitude(Int_t i) const {
-// if (fCellsAmp && i >=0 && i < fNCells ) return fCellsAmp[i];
-// else return -1;}
particleType GetParticleType();
Int_t GetSuperModuleID() const { return fSuperModuleId; }
void SetSuperModuleID(Int_t id) { fSuperModuleId = id; }
//setters
void SetCaloType(AliJCaloType calo) {fCaloType = calo;}
- void SetDistToBadChannel(Double32_t dist) {fDistToBadChannel = dist;}
- void SetDispersion(Double32_t disp) {fDispersion = disp;}
- void SetM20(Double32_t m20) {fM20 = m20;}
- void SetM02(Double32_t m02) {fM02 = m02;}
- void SetEmcCpvDist(Double32_t dist) {fEmcCpvDist = dist;}
- void SetPID(const Double32_t *pid);
+ void SetDistToBadChannel(Double_t dist) {fDistToBadChannel = dist;}
+ void SetDispersion(Double_t disp) {fDispersion = disp;}
+ void SetM20(Double_t m20) {fM20 = m20;}
+ void SetM02(Double_t m02) {fM02 = m02;}
+ void SetEmcCpvDist(Double_t dist) {fEmcCpvDist = dist;}
+ void SetPID(const Double_t *pid);
void SetNCells(Int_t n) { fNCells = n;}
void SetCellsAbsId(const UShort_t *array);
void SetCellsAmplitudeFraction(const Double32_t *array);
-// void SetCellsAmplitude(const Double32_t *array);
- void SetTrackDx(Double32_t trackDx) {fTrackDx = trackDx;}
- void SetTrackDz(Double32_t trackDz) {fTrackDz = trackDz;}
+ void SetTrackDx(Double_t trackDx) {fTrackDx = trackDx;}
+ void SetTrackDz(Double_t trackDz) {fTrackDz = trackDz;}
private:
//TODO
AliJCaloType fCaloType; // PHOS or EMCAL photon
- Double32_t fCaloPID[kUnknownAli+1]; // [0.,1.,8] pointer to PID object
- Double32_t fDistToBadChannel; // Distance to nearest bad channel
- Double32_t fDispersion; // cluster dispersion, for shape analysis
- Double32_t fM20; // 2-nd moment along the main eigen axis
- Double32_t fM02; // 2-nd moment along the second eigen axis
- Double32_t fEmcCpvDist; // the distance from PHOS EMC rec.point to the closest CPV rec.point
+ Double_t fCaloPID[kUnknownAli+1]; // [0.,1.,8] pointer to PID object
+ Double_t fDistToBadChannel; // Distance to nearest bad channel
+ Double_t fDispersion; // cluster dispersion, for shape analysis
+ Double_t fM20; // 2-nd moment along the main eigen axis
+ Double_t fM02; // 2-nd moment along the second eigen axis
+ Double_t fEmcCpvDist; // the distance from PHOS EMC rec.point to the closest CPV rec.point
Int_t fNCells ; //number of cells
Int_t fSuperModuleId ; //super module id
UShort_t *fCellsAbsId; //[fNCells] array of cell absId numbers
- Double32_t *fCellsAmpFraction; //[fNCells][0.,1.,16] array with cell amplitudes fraction (elements are 0 if unfolding off)
-// Double32_t *fCellsAmp; //[fNCells] array amplitudes of cluster cells
+ Double32_t *fCellsAmpFraction; //[fNCells][0.,1.,16] array with cell amplitudes fraction.
ClassDef(AliJPhoton,1)
fL3MagnetPolarity(0),
fMagneticFieldL3(0),
fActiveTriggersAlice(),
- fFiredTriggers(),
- fTriggerMask(0),
- fTriggerCluster(0),
fSizeOfTableJCorran(0),
- fActiveTriggersJCorran()
+// fAliceTriggerDef(),
+ fActiveTriggersJCorran(),
+ fAliceTriggerDef(),
+ fAliceFilterMapDef()
{ //constructor
for(Int_t i=0;i<kRangeTriggerTableAlice;i++){
fL3MagnetPolarity(ap.fL3MagnetPolarity),
fMagneticFieldL3(ap.fMagneticFieldL3),
fActiveTriggersAlice(ap.fActiveTriggersAlice),
- fFiredTriggers(ap.fFiredTriggers),
- fTriggerMask(ap.fTriggerMask),
- fTriggerCluster(ap.fTriggerCluster),
fSizeOfTableJCorran(ap.fSizeOfTableJCorran),
- fActiveTriggersJCorran(ap.fActiveTriggersJCorran)
+// fAliceTriggerDef(ap.fAliceTriggerDef),
+ fActiveTriggersJCorran(ap.fActiveTriggersJCorran),
+ fAliceTriggerDef(ap.fAliceTriggerDef),
+ fAliceFilterMapDef(ap.fAliceFilterMapDef)
{
//cpy ctor
}
fL3MagnetPolarity = header.fL3MagnetPolarity;
fMagneticFieldL3 = header.fMagneticFieldL3;
fActiveTriggersAlice = header.fActiveTriggersAlice;
- fFiredTriggers = header.fFiredTriggers;
- fTriggerMask = header.fTriggerMask;
- fTriggerCluster = header.fTriggerCluster;
fSizeOfTableJCorran = header.fSizeOfTableJCorran;
fActiveTriggersJCorran = header.fActiveTriggersJCorran;
+ fAliceTriggerDef = header.fAliceTriggerDef;
+ fAliceFilterMapDef = header.fAliceFilterMapDef;
}
return *this;
}
Short_t GetL3MagnetFieldPolarity() const { return fL3MagnetPolarity;}
Double_t GetL3MagnetFieldIntensity() const { return fMagneticFieldL3;}
+ //--- Alice event trigger definition by BS like "kMB", "kHighMulti"
+ const std::map<TString, ULong64_t>& GetAliceTriggerDef() const { return fAliceTriggerDef; }
+ ULong64_t GetAliceTriggerDef( const TString name ) const { return GetBitMaskDef( fAliceTriggerDef, name); }
+ void AddAliceTriggerDef( const TString name, const ULong64_t mask){ fAliceTriggerDef[name]=mask; }
+ void RemoveAliceTriggerDef( const TString name){ fAliceTriggerDef.erase(name); }
+
+ //--- Alice track FilterMap by BS like "kEsdTrackCutsL"
+ const std::map<TString, ULong64_t>& GetAliceFilterMapDef() const { return fAliceFilterMapDef; }
+ ULong64_t GetAliceFilterMapDef( const TString name ) const { return GetBitMaskDef( fAliceFilterMapDef, name); }
+ void AddAliceFilterMapDef( const TString name, const ULong64_t mask){ fAliceFilterMapDef[name]=mask; }
+ void RemoveAliceFilterMapDef( const TString name){ fAliceFilterMapDef.erase(name); }
+
+ //--- Common Method to handle BitMask Definition ( map<TString, ULong64_t> )
+ ULong64_t GetBitMaskDef( std::map<TString, ULong64_t> def, const TString name ) const{
+ std::map<TString, ULong64_t>::iterator _iter = def.find(name);
+ //iter = def.find(name);
+ if( _iter == def.end() ){ return 0; }
+ else{ return _iter->second; }
+ }
+
//-- Alice trigger table -- by Filip. "Trigger Class" like "+CMBACS2-B-NOPF-ALL"
void SetActiveTriggersAlice( const TString *triggers);
Int_t GetActiveTriggerBitAlice(TString TriggerName);
Double32_t fMagneticFieldL3; //Solenoid Magnetic Field in kG
TObjArray fActiveTriggersAlice; //array maping between trigger bit and trigger names
- // AOD
- TString fFiredTriggers; // String with fired triggers
- ULong64_t fTriggerMask; // Trigger Type (mask)
- UChar_t fTriggerCluster; // Trigger cluster (mask)
-
-
Int_t fSizeOfTableJCorran; //size of jcorran table
+// std::map<TString,ULong64_t> fAliceTriggerDef; //Alice event trigger definition by BS like "kMB", "kHighMulti"
+// std::map<TString,ULong64_t> fAliceFilterMapDef;//Alice track FilterMap by BS like "kEsdTrackCutsL"
+
TObjArray fActiveTriggersJCorran; //array maping between trigger bit and trigger names
//TBit 0 = MB
+ std::map<TString,ULong64_t> fAliceTriggerDef; //Alice event trigger definition by BS like "kMB", "kHighMulti"
+ std::map<TString,ULong64_t> fAliceFilterMapDef;//Alice track FilterMap by BS like "kEsdTrackCutsL"
+ //std::map<TString, ULong64_t>::iterator iter;
ClassDef(AliJRunHeader,2)
};
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff