reverting 56154 and 56161 - does not compile
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 May 2012 07:29:32 +0000 (07:29 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 May 2012 07:29:32 +0000 (07:29 +0000)
PWGCF/Correlations/JCORRAN/AliJCORRANTask.h
PWGCF/Correlations/JCORRAN/AliJConst.h
PWGCF/Correlations/JCORRAN/AliJEventHeader.cxx
PWGCF/Correlations/JCORRAN/AliJEventHeader.h
PWGCF/Correlations/JCORRAN/AliJPhoton.cxx
PWGCF/Correlations/JCORRAN/AliJPhoton.h
PWGCF/Correlations/JCORRAN/AliJRunHeader.cxx
PWGCF/Correlations/JCORRAN/AliJRunHeader.h

index 61a26bf..e3e9df4 100755 (executable)
@@ -33,7 +33,6 @@
 #include "AliJConst.h"
 #include "AliESDpid.h"
 #include "AliEMCALGeometry.h"
-#include "AliEMCALRecoUtils.h"
 #include "AliPHOSGeoUtils.h"
 #include "AliPIDResponse.h"
 #include "AliPIDCombined.h"
@@ -101,18 +100,15 @@ class AliJCORRANTask : public AliAnalysisTaskSE {
   // 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:
@@ -121,6 +117,8 @@ class AliJCORRANTask : public AliAnalysisTaskSE {
   const char* GetOADBPath() const { return fOADBPath.Data(); }
 
   // method to fill jcorran
+  bool SetAliceTriggerDef(AliJRunHeader *runHeader);
+  bool SetAliceFilterMapDef(AliJRunHeader *runHeader); //TODO Check
   void PrintOut();
   
   // UTILS
@@ -138,16 +136,16 @@ class AliJCORRANTask : public AliAnalysisTaskSE {
   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;
 
@@ -157,8 +155,7 @@ class AliJCORRANTask : public AliAnalysisTaskSE {
   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 
 
 
index 8727ff4..9705402 100755 (executable)
@@ -52,9 +52,7 @@ const char* const kParticleProtoType[kNumberOfExperiments][kNumberOfParticleType
 
 //=======================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;
 
index a96a566..665da4b 100755 (executable)
@@ -40,7 +40,6 @@ AliJEventHeader::AliJEventHeader():
     fSPDTrackletMult(-999),
     fV0Mult(-999),
     fEventType(0),
-    fFiredTriggers(), 
     fVtxMult(-9999)   //FK// EFF
 {
   // default constructor
@@ -59,7 +58,6 @@ AliJEventHeader::AliJEventHeader(int eventid, float cent, float vrtz, ULong64_t
     fSPDTrackletMult(refmult),
     fV0Mult(v0mult),
     fEventType(eventType),
-    fFiredTriggers(), 
     fVtxMult(-9999)  //FK// EFF
 {
   //constructor
@@ -74,7 +72,6 @@ AliJEventHeader::AliJEventHeader(const AliJEventHeader& a):
     fSPDTrackletMult(a.fSPDTrackletMult),
     fV0Mult(a.fV0Mult),
     fEventType(a.fEventType),
-    fFiredTriggers(a.fFiredTriggers), 
     fVtxMult(a.fVtxMult)  //FK// EFF
 {
   //copy constructor
@@ -92,7 +89,6 @@ AliJEventHeader&  AliJEventHeader::operator=(const AliJEventHeader& header){
     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];
   }
 
index b1d72ba..f520179 100755 (executable)
@@ -68,9 +68,6 @@ class AliJEventHeader : public AliJBaseEventHeader {
   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:
@@ -80,7 +77,6 @@ class AliJEventHeader : public AliJBaseEventHeader {
   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];  //?//
 
index 6c4a2ff..924c893 100644 (file)
@@ -37,7 +37,6 @@ AliJPhoton::AliJPhoton() :
   fSuperModuleId(-999),
   fCellsAbsId(0x0),
   fCellsAmpFraction(0x0)
-//  fCellsAmp(0x0)
 
 {
   // default constructor
@@ -67,14 +66,12 @@ AliJPhoton::AliJPhoton(const AliJPhoton& a) :
   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 );
 }
 
 //_____________________________________________________________________________
@@ -103,7 +100,6 @@ AliJPhoton& AliJPhoton::operator=(const AliJPhoton& photon){
     fSuperModuleId =  photon.fSuperModuleId;
     SetCellsAbsId( photon.fCellsAbsId );
     SetCellsAmplitudeFraction( photon.fCellsAmpFraction );
-//    SetCellsAmplitude( photon.fCellsAmp );
 
   }
 
@@ -131,19 +127,8 @@ void  AliJPhoton::SetCellsAmplitudeFraction(const Double32_t *array)
     }
 }
 
-// //_______________________________________________________________________
-// 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];
index 301cce8..dd808d3 100644 (file)
@@ -50,22 +50,21 @@ class AliJPhoton : public AliJBaseTrack {
   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);
 
@@ -76,24 +75,20 @@ class AliJPhoton : public AliJBaseTrack {
   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; }
@@ -102,18 +97,17 @@ class AliJPhoton : public AliJBaseTrack {
 
   //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:
 
@@ -125,18 +119,17 @@ class AliJPhoton : public AliJBaseTrack {
 
  //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)
 
index e2dafd3..073baeb 100755 (executable)
@@ -41,11 +41,11 @@ AliJRunHeader::AliJRunHeader():
     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++){
@@ -70,11 +70,11 @@ AliJRunHeader::AliJRunHeader(const AliJRunHeader& ap):
     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
 }
@@ -142,11 +142,10 @@ AliJRunHeader& AliJRunHeader::operator=(const  AliJRunHeader& header){
     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;
 }
index 5a031dc..6aacb8a 100755 (executable)
@@ -56,6 +56,26 @@ class AliJRunHeader : public TNamed {
   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);
@@ -82,15 +102,15 @@ class AliJRunHeader : public TNamed {
   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)
 
 };