possibility to read process type from phojet events (Christian)
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 30 May 2008 09:26:03 +0000 (09:26 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 30 May 2008 09:26:03 +0000 (09:26 +0000)
PWG0/AliPWG0Helper.cxx
PWG0/AliPWG0Helper.h
PWG0/dNdEta/AliMultiplicityMCSelector.cxx
PWG0/dNdEta/AlidNdEtaCorrection.cxx
PWG0/dNdEta/AlidNdEtaCorrectionTask.cxx
PWG0/dNdEta/AlidNdEtaSystematicsSelector.cxx
PWG0/dNdEta/AlidNdEtaTask.cxx
PWG0/multiplicity/AliMultiplicityTask.cxx

index 4ce653d..90c4a92 100644 (file)
@@ -24,6 +24,7 @@
 #include <AliGenEventHeader.h>
 #include <AliGenPythiaEventHeader.h>
 #include <AliGenCocktailEventHeader.h>
+#include <AliGenDPMjetEventHeader.h>
 
 //____________________________________________________________________
 ClassImp(AliPWG0Helper)
@@ -328,46 +329,123 @@ const char* AliPWG0Helper::GetAxisTitle(TH3* hist, const char axis)
   return 0;
 }
 
-//____________________________________________________________________
-Int_t AliPWG0Helper::GetPythiaEventProcessType(AliHeader* aHeader, Bool_t adebug) {
+
+Int_t AliPWG0Helper::GetPythiaEventProcessType(AliGenEventHeader* aHeader, Bool_t adebug) {
+
+  AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(aHeader);
+
+  if (!pythiaGenHeader) {
+    printf("AliPWG0Helper::GetProcessType : Unknown gen Header type). \n");
+    return kInvalidProcess;
+  }
+
+
+  Int_t pythiaType = pythiaGenHeader->ProcessType();
+  MCProcessType globalType = kInvalidProcess;  
+
+
+  if (adebug) {
+    printf("AliPWG0Helper::GetProcessType : Pythia process type found: %d \n",pythiaType);
+  }
+
+
+  if(pythiaType==92||pythiaType==93){
+    globalType = kSD;
+  }
+  else if(pythiaType==94){
+    globalType = kDD;
+  }
+  //else if(pythiaType != 91){ // also exclude elastic to be sure... CKB??
+  else {
+    globalType = kND;
+  }
+  return globalType;
+}
+
+
+Int_t AliPWG0Helper::GetDPMjetEventProcessType(AliGenEventHeader* aHeader, Bool_t adebug) {
   //
   // get the process type of the event.
   //
 
   // can only read pythia headers, either directly or from cocktalil header
+  AliGenDPMjetEventHeader* dpmJetGenHeader = dynamic_cast<AliGenDPMjetEventHeader*>(aHeader);
+
+  if (!dpmJetGenHeader) {
+    printf("AliPWG0Helper::GetDPMjetProcessType : Unknown header type (not DPMjet or). \n");
+    return kInvalidProcess;
+  }
+
+  Int_t dpmJetType = dpmJetGenHeader->ProcessType();
+  MCProcessType globalType = kInvalidProcess;  
+
+
+  if (adebug) {
+    printf("AliPWG0Helper::GetDPMJetProcessType : DPMJet process type found: %d \n",dpmJetType);
+  }
+
+
+  if(dpmJetType == 1){ // this is explicitly inelastic
+    globalType = kND;
+  }  
+  else if(dpmJetType==5||dpmJetType==6){
+    globalType = kSD;
+  }
+  else if(dpmJetType==7||dpmJetType==4){// DD and double pomeron
+    globalType = kDD;
+  }
+  return globalType;
+}
+
+
+Int_t AliPWG0Helper::GetEventProcessType(AliHeader* aHeader, Bool_t adebug) {
+  //
+  // get the process type of the event.
+  //
+
+
+  // Check for simple headers first
+
   AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(aHeader->GenEventHeader());
+  if (pythiaGenHeader) {
+    return GetPythiaEventProcessType(pythiaGenHeader,adebug);
+  }
 
-  if (!pythiaGenHeader) {
+  AliGenDPMjetEventHeader* dpmJetGenHeader = dynamic_cast<AliGenDPMjetEventHeader*>(aHeader->GenEventHeader());
+  if (dpmJetGenHeader) {
+    return GetDPMjetEventProcessType(dpmJetGenHeader,adebug);
+  }
+  
 
-    AliGenCocktailEventHeader* genCocktailHeader = dynamic_cast<AliGenCocktailEventHeader*>(aHeader->GenEventHeader());
-    if (!genCocktailHeader) {
-      printf("AliPWG0Helper::GetProcessType : Unknown header type (not Pythia or Cocktail). \n");
-      return -1;
-    }
+  // check for cocktail
 
-    TList* headerList = genCocktailHeader->GetHeaders();
-    if (!headerList) {
-      return -1;
-    }
+  AliGenCocktailEventHeader* genCocktailHeader = dynamic_cast<AliGenCocktailEventHeader*>(aHeader->GenEventHeader());
+  if (!genCocktailHeader) {
+    printf("AliPWG0Helper::GetProcessType : Unknown header type (not Pythia or Cocktail). \n");
+    return kInvalidProcess;
+  }
+
+  TList* headerList = genCocktailHeader->GetHeaders();
+  if (!headerList) {
+    return kInvalidProcess;
+  }
+
+  for (Int_t i=0; i<headerList->GetEntries(); i++) {
 
-    for (Int_t i=0; i<headerList->GetEntries(); i++) {
-      pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(headerList->At(i));
-      if (pythiaGenHeader)
-        break;
+    pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(headerList->At(i));
+    if (pythiaGenHeader) {
+      return GetPythiaEventProcessType(pythiaGenHeader,adebug);
     }
 
-    if (!pythiaGenHeader) {
-      printf("AliPWG0Helper::GetProcessType : Could not find Pythia header. \n");
-      return -1;
+    dpmJetGenHeader = dynamic_cast<AliGenDPMjetEventHeader*>(headerList->At(i));
+    if (dpmJetGenHeader) {
+      return GetDPMjetEventProcessType(dpmJetGenHeader,adebug);
     }
   }
+  return kInvalidProcess;
+}
 
-  if (adebug) {
-    printf("AliPWG0Helper::GetProcessType : Pythia process type found: %d \n",pythiaGenHeader->ProcessType());
-  }
 
-  return pythiaGenHeader->ProcessType();
-}
 
 //____________________________________________________________________
 TParticle* AliPWG0Helper::FindPrimaryMother(AliStack* stack, Int_t label)
index 583e346..c1e3e65 100644 (file)
@@ -15,6 +15,7 @@ class TH1;
 class TH2;
 class TH3;
 class AliHeader;
+class AliGenEventHeader;
 class AliStack;
 class TTree;
 
@@ -23,6 +24,8 @@ class AliPWG0Helper : public TObject
   public:
     enum Trigger { kMB1 = 0, kMB2 }; // definition from ALICE-INT-2005-025
     enum AnalysisMode { kInvalid = -1, kSPD = 0, kTPC, kTPCITS };
+    // in case we want to use bitmaps...
+    enum MCProcessType { kInvalidProcess = -1, kND = 0x1, kDD = 0x2, kSD = 0x4 }; 
 
     static Bool_t IsEventTriggered(const AliESD* aEsd, Trigger trigger = kMB2);
     static Bool_t IsEventTriggered(ULong64_t triggerMask, Trigger trigger = kMB2);
@@ -32,7 +35,10 @@ class AliPWG0Helper : public TObject
 
     static Bool_t IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimaries, Bool_t adebug = kFALSE);
 
-    static Int_t GetPythiaEventProcessType(AliHeader* aHeader, Bool_t adebug = kFALSE);
+    static Int_t GetEventProcessType(AliHeader* aHeader, Bool_t adebug = kFALSE);
+    static Int_t GetPythiaEventProcessType(AliGenEventHeader* aHeader, Bool_t adebug = kFALSE);
+    static Int_t GetDPMjetEventProcessType(AliGenEventHeader* aHeader, Bool_t adebug = kFALSE);
+
     static TParticle* FindPrimaryMother(AliStack* stack, Int_t label);
     static Int_t FindPrimaryMotherLabel(AliStack* stack, Int_t label);
 
index a07ac82..c5b8a8d 100644 (file)
@@ -244,21 +244,21 @@ Bool_t AliMultiplicityMCSelector::Process(Long64_t entry)
 
   if (fSelectProcessType > 0)
   {
-    // getting process information; NB: this only works for Pythia
-    Int_t processtype = AliPWG0Helper::GetPythiaEventProcessType(header);
+    // getting process information
+    Int_t processtype = AliPWG0Helper::GetEventProcessType(header);
 
     Bool_t processEvent = kFALSE;
 
     // non diffractive
-    if (fSelectProcessType == 1 && processtype !=92 && processtype !=93 && processtype != 94)
+    if (fSelectProcessType == 1 && processtype == AliPWG0Helper::kND )
       processEvent = kTRUE;
 
     // single diffractive
-    if (fSelectProcessType == 2 && (processtype == 92 || processtype == 93))
+    if (fSelectProcessType == 2 && processtype == AliPWG0Helper::kSD )
       processEvent = kTRUE;
 
     // double diffractive
-    if (fSelectProcessType == 3 && processtype == 94)
+    if (fSelectProcessType == 3 && processtype == AliPWG0Helper::kDD )
       processEvent = kTRUE;
 
     if (!processEvent)
index 0237d6b..daf0a35 100644 (file)
@@ -272,10 +272,10 @@ void AlidNdEtaCorrection::FillMCParticle(Float_t vtx, Float_t eta, Float_t pt, B
 
   fTriggerBiasCorrectionMBToINEL->GetTrackCorrection()->FillGene(vtx, eta, pt);
 
-  if (processType != 92 && processType != 93)
+  if (processType != AliPWG0Helper::kSD )
     fTriggerBiasCorrectionMBToNSD->GetTrackCorrection()->FillGene(vtx, eta, pt);
 
-  if (processType!=92 && processType!=93 && processType!=94)
+  if (processType == AliPWG0Helper::kND )
     fTriggerBiasCorrectionMBToND->GetTrackCorrection()->FillGene(vtx, eta, pt);
 
   if (!trigger)
@@ -309,10 +309,10 @@ void AlidNdEtaCorrection::FillEvent(Float_t vtx, Float_t n, Bool_t trigger, Bool
 
   fTriggerBiasCorrectionMBToINEL->GetEventCorrection()->FillGene(vtx, n);
 
-  if (processType != 92 && processType != 93)
+  if ( processType != AliPWG0Helper::kSD )
     fTriggerBiasCorrectionMBToNSD->GetEventCorrection()->FillGene(vtx, n);
 
-  if (processType!=92 && processType!=93 && processType!=94)
+  if (processType == AliPWG0Helper::kND )
     fTriggerBiasCorrectionMBToND->GetEventCorrection()->FillGene(vtx, n);
 
   if (!trigger)
index 1e45d55..1dcc6db 100644 (file)
@@ -266,12 +266,12 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
     return;
   }
 
-  // get process type; NB: this only works for Pythia
-  Int_t processType = AliPWG0Helper::GetPythiaEventProcessType(header);
-  AliDebug(AliLog::kDebug+1, Form("Found pythia process type %d", processType));
+  // get process type;
+  Int_t processType = AliPWG0Helper::GetEventProcessType(header);
+  AliDebug(AliLog::kDebug+1, Form("Found process type %d", processType));
 
-  if (processType<0)
-    AliDebug(AliLog::kError, Form("Unknown Pythia process type %d.", processType));
+  if (processType == AliPWG0Helper::kInvalidProcess)
+    AliDebug(AliLog::kError, Form("Unknown process type %d.", processType));
 
   // get the MC vertex
   AliGenEventHeader* genHeader = header->GenEventHeader();
@@ -300,7 +300,7 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
   // INEL
   fEventStats->Fill(0.0, biny);
   // NSD
-  if (processType != 92 && processType != 93)
+  if (processType != AliPWG0Helper::kSD )
     fEventStats->Fill(1.0, biny);
   
   // create list of (label, eta, pt) tuples
@@ -429,15 +429,15 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
     if (fdNdEtaCorrectionProcessType[0])
     {
       // non diffractive
-      if (processType!=92 && processType!=93 && processType!=94)
+      if (processType==AliPWG0Helper::kND)
         fdNdEtaCorrectionProcessType[0]->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, eventVertex, processType);
 
       // single diffractive
-      if (processType==92 || processType==93)
+      if (processType==AliPWG0Helper::kSD)
         fdNdEtaCorrectionProcessType[1]->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, eventVertex, processType);
 
       // double diffractive
-      if (processType==94)
+      if (processType==AliPWG0Helper::kDD)
         fdNdEtaCorrectionProcessType[2]->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, eventVertex, processType);
     }
 
@@ -531,15 +531,15 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
       if (fdNdEtaCorrectionProcessType[0])
       {
         // non diffractive
-        if (processType!=92 && processType!=93 && processType!=94)
+        if (processType == AliPWG0Helper::kND)
           fdNdEtaCorrectionProcessType[0]->FillTrackedParticle(vtxMC[2], particle->Eta(), particle->Pt());
 
         // single diffractive
-        if (processType==92 || processType==93)
+        if (processType == AliPWG0Helper::kSD )
           fdNdEtaCorrectionProcessType[1]->FillTrackedParticle(vtxMC[2], particle->Eta(), particle->Pt());
 
         // double diffractive
-        if (processType==94)
+        if (processType == AliPWG0Helper::kDD)
           fdNdEtaCorrectionProcessType[2]->FillTrackedParticle(vtxMC[2], particle->Eta(), particle->Pt());
       }
 
@@ -615,15 +615,15 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
   if (fdNdEtaCorrectionProcessType[0])
   {
     // non diffractive
-    if (processType!=92 && processType!=93 && processType!=94)
+    if (processType == AliPWG0Helper::kND )
       fdNdEtaCorrectionProcessType[0]->FillEvent(vtxMC[2], inputCount, eventTriggered, eventVertex, processType);
 
     // single diffractive
-    if (processType==92 || processType==93)
+    if (processType == AliPWG0Helper::kSD)
       fdNdEtaCorrectionProcessType[1]->FillEvent(vtxMC[2], inputCount, eventTriggered, eventVertex, processType);
 
     // double diffractive
-    if (processType==94)
+    if (processType == AliPWG0Helper::kDD)
       fdNdEtaCorrectionProcessType[2]->FillEvent(vtxMC[2], inputCount, eventTriggered, eventVertex, processType);
   }
 
index 0a52ae7..bed6bb5 100644 (file)
@@ -221,8 +221,8 @@ Bool_t AlidNdEtaSystematicsSelector::Process(Long64_t entry)
     return kFALSE;
   }
   
-  // getting process information NB: this only works for Pythia !!!
-  Int_t processtype = AliPWG0Helper::GetPythiaEventProcessType(header);
+  // getting process information
+  Int_t processtype = AliPWG0Helper::GetEventProcessType(header);
 
   // can only read pythia headers, either directly or from cocktalil header
   AliGenEventHeader* genHeader = (AliGenEventHeader*)(header->GenEventHeader());
@@ -243,20 +243,20 @@ Bool_t AlidNdEtaSystematicsSelector::Process(Long64_t entry)
   Bool_t vertexReconstructed = AliPWG0Helper::IsVertexReconstructed(fESD);
   
   // non diffractive
-  if (processtype!=92 && processtype!=93 && processtype!=94) {
-    // NB: passing the wrong process type here (1), since the process type is defined by the index in the array (here non-diffractive)
+  if (processtype == AliPWG0Helper::kND) {
+    // NB: passing the wrong process type here (1), since the process type is defined by the index in the array (here non-diffractive) // ???? CKB ???
     if (triggerBiasStudy) fdNdEtaCorrectionTriggerBias[0]->FillEvent(vtxMC[2], nGoodTracks, eventTriggered, vertexReconstructed, 1);      
     if (vertexRecoStudy)  fdNdEtaCorrectionVertexReco[0] ->FillEvent(vtxMC[2], nGoodTracks, eventTriggered, vertexReconstructed, 1);
   }
   
   // single diffractive
-  if (processtype==92 || processtype==93) { 
+  if (processtype == AliPWG0Helper::kSD) { 
     if (triggerBiasStudy) fdNdEtaCorrectionTriggerBias[1]->FillEvent(vtxMC[2], nGoodTracks, eventTriggered, vertexReconstructed, 1);     
     if (vertexRecoStudy)  fdNdEtaCorrectionVertexReco[1] ->FillEvent(vtxMC[2], nGoodTracks, eventTriggered, vertexReconstructed, 1);
   }
   
   // double diffractive
-  if (processtype==94) { 
+  if (processtype==AliPWG0Helper::kDD) { 
     if (triggerBiasStudy) fdNdEtaCorrectionTriggerBias[2]->FillEvent(vtxMC[2], nGoodTracks, eventTriggered, vertexReconstructed, 1);     
     if (vertexRecoStudy)  fdNdEtaCorrectionVertexReco[2] ->FillEvent(vtxMC[2], nGoodTracks, eventTriggered, vertexReconstructed, 1);
   }
@@ -321,17 +321,17 @@ Bool_t AlidNdEtaSystematicsSelector::Process(Long64_t entry)
     }
     
     // non diffractive
-    if (processtype!=92 && processtype!=93 && processtype!=94) { 
+    if (processtype==AliPWG0Helper::kND) { 
       if (triggerBiasStudy) fdNdEtaCorrectionTriggerBias[0]->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, vertexReconstructed, 1);
       if (vertexRecoStudy)  fdNdEtaCorrectionVertexReco[0] ->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, vertexReconstructed, 1);
     }
     // single diffractive
-    if (processtype==92 || processtype==93) { 
+    if (processtype==AliPWG0Helper::kSD) { 
       if (triggerBiasStudy) fdNdEtaCorrectionTriggerBias[1]->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, vertexReconstructed, 1);
       if (vertexRecoStudy)  fdNdEtaCorrectionVertexReco[1] ->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, vertexReconstructed, 1);
     }
     // double diffractive
-    if (processtype==94) { 
+    if (processtype==AliPWG0Helper::kDD) { 
       if (triggerBiasStudy) fdNdEtaCorrectionTriggerBias[2]->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, vertexReconstructed, 1);
       if (vertexRecoStudy)  fdNdEtaCorrectionVertexReco[2] ->FillMCParticle(vtxMC[2], eta, pt, eventTriggered, vertexReconstructed, 1);
     }
@@ -373,19 +373,19 @@ Bool_t AlidNdEtaSystematicsSelector::Process(Long64_t entry)
     Float_t pt  = particle->Pt();
     
     // non diffractive
-    if (processtype!=92 && processtype!=93 && processtype!=94) { 
+    if (processtype==AliPWG0Helper::kND) { 
       if (triggerBiasStudy) fdNdEtaCorrectionTriggerBias[0]->FillTrackedParticle(vtxMC[2], eta, pt);
       if (vertexRecoStudy)  fdNdEtaCorrectionVertexReco[0] ->FillTrackedParticle(vtxMC[2], eta, pt);
     }
     
     // single diffractive
-    if (processtype==92 || processtype==93) { 
+    if (processtype==AliPWG0Helper::kSD) { 
       if (triggerBiasStudy) fdNdEtaCorrectionTriggerBias[1]->FillTrackedParticle(vtxMC[2], eta, pt);
       if (vertexRecoStudy)  fdNdEtaCorrectionVertexReco[1] ->FillTrackedParticle(vtxMC[2], eta, pt);
     }
 
     // double diffractive
-    if (processtype==94) { 
+    if (processtype==AliPWG0Helper::kDD) { 
       if (triggerBiasStudy) fdNdEtaCorrectionTriggerBias[2]->FillTrackedParticle(vtxMC[2], eta, pt);
       if (vertexRecoStudy)  fdNdEtaCorrectionVertexReco[2] ->FillTrackedParticle(vtxMC[2], eta, pt);
     }
index 609961a..73204dd 100644 (file)
@@ -445,12 +445,12 @@ void AlidNdEtaTask::Exec(Option_t*)
     TArrayF vtxMC(3);
     genHeader->PrimaryVertex(vtxMC);
 
-    // get process type; NB: this only works for Pythia
-    Int_t processType = AliPWG0Helper::GetPythiaEventProcessType(header);
-    AliDebug(AliLog::kDebug+1, Form("Found pythia process type %d", processType));
+    // get process type
+    Int_t processType = AliPWG0Helper::GetEventProcessType(header);
+    AliDebug(AliLog::kDebug+1, Form("Found process type %d", processType));
 
-    if (processType<0)
-      AliDebug(AliLog::kError, Form("Unknown Pythia process type %d.", processType));
+    if (processType==AliPWG0Helper::kInvalidProcess)
+      AliDebug(AliLog::kError, Form("Unknown process type %d.", processType));
 
     // loop over mc particles
     Int_t nPrim  = stack->GetNprimary();
@@ -479,7 +479,7 @@ void AlidNdEtaTask::Exec(Option_t*)
       fdNdEtaAnalysis->FillTrack(vtxMC[2], eta, pt);
       fVertex->Fill(particle->Vx(), particle->Vy(), particle->Vz());
 
-      if (processType != 92 && processType != 93)
+      if (processType != AliPWG0Helper::kSD )
         fdNdEtaAnalysisNSD->FillTrack(vtxMC[2], eta, pt);
 
       if (eventTriggered)
@@ -494,7 +494,7 @@ void AlidNdEtaTask::Exec(Option_t*)
     }
 
     fdNdEtaAnalysis->FillEvent(vtxMC[2], nAcceptedParticles);
-    if (processType != 92 && processType != 93)
+    if (processType != AliPWG0Helper::kSD )
       fdNdEtaAnalysisNSD->FillEvent(vtxMC[2], nAcceptedParticles);
 
     if (eventTriggered)
index c3bfe5b..be7b363 100644 (file)
@@ -354,20 +354,20 @@ void AliMultiplicityTask::Exec(Option_t*)
     if (fSelectProcessType > 0)
     {
       // getting process information; NB: this only works for Pythia
-      Int_t processtype = AliPWG0Helper::GetPythiaEventProcessType(header);
+      Int_t processtype = AliPWG0Helper::GetEventProcessType(header);
 
       processEvent = kFALSE;
 
       // non diffractive
-      if (fSelectProcessType == 1 && processtype !=92 && processtype !=93 && processtype != 94)
+      if (fSelectProcessType == 1 && processtype == AliPWG0Helper::kND )
         processEvent = kTRUE;
 
       // single diffractive
-      if (fSelectProcessType == 2 && (processtype == 92 || processtype == 93))
+      if (fSelectProcessType == 2 && processtype == AliPWG0Helper::kSD )
         processEvent = kTRUE;
 
       // double diffractive
-      if (fSelectProcessType == 3 && processtype == 94)
+      if (fSelectProcessType == 3 && processtype == AliPWG0Helper::kDD )
         processEvent = kTRUE;
 
       if (!processEvent)