Updates for real data analysis, trigger decisions

diff --git a/PWG4/JetTasks/AliAnalysisHelperJetTasks.cxx b/PWG4/JetTasks/AliAnalysisHelperJetTasks.cxx
index 8cfd1c088e23dade1642f9a85194755a472ffd2d..9edb14e344312b89271c7c0aaf93ed167b3277f7 100644 (file)
--- a/PWG4/JetTasks/AliAnalysisHelperJetTasks.cxx
+++ b/PWG4/JetTasks/AliAnalysisHelperJetTasks.cxx
@@ -635,8 +635,47 @@ Bool_t AliAnalysisHelperJetTasks::IsTriggerFired(const AliVEvent* aEv, Trigger t
 Bool_t AliAnalysisHelperJetTasks::IsTriggerBitFired(const AliVEvent* aEv, Trigger trigger)
 {
   // checks if an event is fired using the trigger bits
-
-  return IsTriggerBitFired(aEv->GetTriggerMask(), trigger);
+  // here we do a dirty hack to take also into account the
+  // missing trigger bits and Bunch crossing paatern for real data 
+
+  Bool_t bitFired = IsTriggerBitFired(aEv->GetTriggerMask(), trigger);
+  Bool_t isStringFired = false;
+
+  if(aEv->InheritsFrom("AliESDEvent")){
+    const AliESDEvent *esd = (AliESDEvent*)(aEv);
+    switch (trigger)
+      {
+      case kAcceptAll:
+       {
+         isStringFired = kTRUE;
+         break;
+       }
+      case kMB1:
+       {
+         if(esd->GetFiredTriggerClasses().Contains("CINT1B"))isStringFired = true;;
+         break;
+       }
+      case kMB2:
+       {
+         break;
+       }
+      case kMB3:
+       {
+         break;
+       }
+      case kSPDGFO:
+       {
+         if(esd->GetFiredTriggerClasses().Contains("CSMBB"))isStringFired = true;;       
+         break;
+       }
+      default:
+       {
+         Printf("IsEventTriggered: ERROR: Trigger type %d not implemented in this method", (Int_t) trigger);
+         break;
+       }
+      }
+  }
+  return bitFired||isStringFired;
 }
 
 Bool_t AliAnalysisHelperJetTasks::IsTriggerBitFired(ULong64_t triggerMask, Trigger trigger)

diff --git a/PWG4/JetTasks/AliAnalysisHelperJetTasks.h b/PWG4/JetTasks/AliAnalysisHelperJetTasks.h
index b47d33fdfa3d76a73ed2085660573533bcaa02f4..b4d4b9ef62eb163b7f57c586c3ea42a178328703 100644 (file)
--- a/PWG4/JetTasks/AliAnalysisHelperJetTasks.h
+++ b/PWG4/JetTasks/AliAnalysisHelperJetTasks.h
@@ -31,7 +31,7 @@ class AliAnalysisHelperJetTasks : public TObject {
   static Bool_t GetEventShapes(TVector3 &n01, TVector3 * pTrack, Int_t nTracks, Double_t * eventShapes);
   enum {kMaxJets = 6}; //  needed for array size not to fragemnt memory on the heap by many new/delete 
 
-  enum Trigger {kAcceptAll = 0,kMB1,kMB2,kMB3, kSPDGFO,kTrigger}; // 
+  enum Trigger {kAcceptAll = 0,kMB1,kMB2,kMB3,kSPDGFO,kTrigger}; // 
 
   static Bool_t Selected(Bool_t bSet = kFALSE,Bool_t bNew = kTRUE); // static function to store the state of selection from service task
   

diff --git a/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.cxx b/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.cxx
index 60b003571696cc852102834cfa67d71d0928bdb2..ae98cd5c0816d6fa00b7957f6d0bfb31b8ce0722 100644 (file)
--- a/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.cxx
+++ b/PWG4/JetTasks/AliAnalysisTaskJetSpectrum2.cxx
@@ -299,7 +299,7 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/)
   //
   // Execute analysis for current event
   //
- 
+  AliESDEvent *fESD = 0;
   if(fUseAODInput){    
     fAOD = dynamic_cast<AliAODEvent*>(InputEvent());
     if(!fAOD){
@@ -315,6 +315,11 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/)
       Printf("%s:%d AODEvent not found in the Output",(char*)__FILE__,__LINE__);
       return;
     }
+    if(fDebug>0){
+      fESD = dynamic_cast<AliESDEvent*> (InputEvent());
+    }
+
+
   }
   
 
@@ -537,6 +542,8 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/)
     }
   }// loop over generated jets
 
+  
+  
 
   // loop over reconstructed jets
   for(int ir = 0;ir < nRecJets;++ir){
@@ -548,6 +555,24 @@ void AliAnalysisTaskJetSpectrum2::UserExec(Option_t */*option*/)
     container[1] = etaRec;
     container[2] = phiRec;
 
+    if(ptRec>20.&&fDebug>0){
+      // need to cast to int, otherwise the printf overwrites
+      Printf("Jet found in Event %d with p_T, %E",(int)Entry(),ptRec);
+      fAOD->GetHeader()->Print();
+      for(int it = 0;it < fAOD->GetNumberOfTracks();++it){
+       AliAODTrack *tr = fAOD->GetTrack(it);
+       if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask)))continue;
+       tr->Print();
+       tr->Dump();
+       if(fESD){
+         AliESDtrack *esdTr = (AliESDtrack*)fESD->GetTrack(tr->GetID());
+         esdTr->Print("");
+         esdTr->Dump();
+       }
+      }
+    }
+  
+
     fhnJetContainer[kStep0+kMaxStep]->Fill(container,eventW);
     if (fDebug > 10)Printf("%s:%d",(char*)__FILE__,__LINE__);
     if(TMath::Abs(etaRec)<fRecEtaWindow){

diff --git a/PWG4/JetTasks/AliAnalysisTaskThreeJets.cxx b/PWG4/JetTasks/AliAnalysisTaskThreeJets.cxx
index 2cb485c875db1c2403311f0771d3c8c600b4bfdd..bac248488879d2b9c78a1ae2dccb23b05349a53e 100644 (file)
--- a/PWG4/JetTasks/AliAnalysisTaskThreeJets.cxx
+++ b/PWG4/JetTasks/AliAnalysisTaskThreeJets.cxx
@@ -58,6 +58,7 @@ ClassImp(AliAnalysisTaskThreeJets)
   AliAnalysisTaskThreeJets::AliAnalysisTaskThreeJets() : AliAnalysisTaskSE(),
                                                   
                                                         fAOD(0x0),
+                                                        fUseMC(0x0),
                                                 
                                                         fBranchRec(""),
                                                         fBranchGen(""),
@@ -135,6 +136,7 @@ AliAnalysisTaskThreeJets::AliAnalysisTaskThreeJets(const char * name):
   AliAnalysisTaskSE(name),
   
   fAOD(0x0),
+  fUseMC(0x0),
   
   fBranchRec(""),
   fBranchGen(""),
@@ -482,10 +484,7 @@ void AliAnalysisTaskThreeJets::UserExec(Option_t * )
   
 //   AliAODJet genJetsPythia[kMaxJets];
 //   Int_t nPythiaGenJets = 0;
-  
-  AliAODJet genJets[kMaxJets];
-  Int_t nGenJets = 0;
-  
+
   AliAODJet recJets[kMaxJets];
   Int_t nRecJets = 0;
   
@@ -506,28 +505,31 @@ void AliAnalysisTaskThreeJets::UserExec(Option_t * )
      if(!tmp)continue;
      recJets[ir] = *tmp;
     }
- 
+   
+  AliAODJet genJets[kMaxJets];
+  Int_t nGenJets = 0;
+  if(fUseMC){
   // If we set a second branch for the input jets fetch this
   TClonesArray * aodGenJets = dynamic_cast<TClonesArray*>(fAOD->FindListObject(fBranchGen.Data()));
-  
-  if(!aodGenJets)
-    {
-      printf("NO MC jets Found\n");
-      return;
-    }
-  
-  //   //Generated jets
-  nGenJets = aodGenJets->GetEntries();
-  nGenJets = TMath::Min(nGenJets, kMaxJets);
-  
-  for(Int_t ig =0 ; ig < nGenJets; ++ig)
-    {
-      AliAODJet * tmp = dynamic_cast<AliAODJet*>(aodGenJets->At(ig));
-      if(!tmp)continue;
-      genJets[ig] = * tmp;
-    }
-  
-//   AliGenPythiaEventHeader*  pythiaGenHeader = AliAnalysisHelperJetTasks::GetPythiaEventHeader(mcEvent);
+    
+    if(!aodGenJets)
+      {
+       printf("NO MC jets Found\n");
+       return;
+      }
+    
+    //   //Generated jets
+    nGenJets = aodGenJets->GetEntries();
+    nGenJets = TMath::Min(nGenJets, kMaxJets);
+
+    for(Int_t ig =0 ; ig < nGenJets; ++ig)
+      {
+       AliAODJet * tmp = dynamic_cast<AliAODJet*>(aodGenJets->At(ig));
+       if(!tmp)continue;
+       genJets[ig] = * tmp;
+      }
+  }
+  //   AliGenPythiaEventHeader*  pythiaGenHeader = AliAnalysisHelperJetTasks::GetPythiaEventHeader(mcEvent);
 //   if(!pythiaGenHeader){
 //     Printf("!!!NO GEN HEADER AVALABLE!!!");
 //     return;
@@ -591,272 +593,281 @@ void AliAnalysisTaskThreeJets::UserExec(Option_t * )
  
  
 //________histos for MC___________________________________________________________________________________________________________
-
   Int_t nGenSel = 0;
-  Int_t counter = 0;
-  Int_t tag = 0;
-
-  AliAODJet selJets[kMaxJets];
+  if(fUseMC){
+    Int_t counter = 0;
+    Int_t tag = 0;
+    
+    AliAODJet selJets[kMaxJets];
+    
+    for(Int_t i = 0; i < nGenJets; i++)
+      {
+       if(nGenJets == 1)
+         {
+           selJets[nGenSel] = genJets[i];
+           nGenSel++;
+         }
+       else
+         {
+           counter = 0;
+           tag = 0;
+           for(Int_t j = 0; j < nGenJets; j++)
+             {
+               if(i!=j)
+                 {
+                   Double_t dRij = genJets[i].DeltaR(&genJets[j]);
+                   counter++;
+                   if(dRij > 2*fR) tag++;
+                 }
+             }
+           if(counter!=0)
+             {
+               if(tag/counter == 1)
+                 {
+                   selJets[nGenSel] = genJets[i];
+                   nGenSel++;
+                 }
+             }
+         }
+      }
 
-  for(Int_t i = 0; i < nGenJets; i++)
-    {
-      if(nGenJets == 1)
+    if(nGenSel == 0) return;
+    
+    for (Int_t gj = 0; gj < nGenSel; gj++)
+      {
+       eGen[gj] = selJets[gj].E();
+      }
+    
+    TMath::Sort(nGenSel, eGen, idxGen);
+    for (Int_t ig = 0; ig < nGenSel; ig++)
+      {
+       jetGen[ig] = selJets[idxGen[ig]];
+      }
+    
+    fhXSec->Fill(jetGen[0].Pt(), fXsection);
+    //  AliStack * stack = mcEvent->Stack();
+    
+    Int_t nMCtracks = 0;
+    Double_t eTracksMC[kTracks];
+    Double_t pTracksMC[kTracks];
+    Int_t idxTracksMC[kTracks];
+    TLorentzVector jetTracksMC[kTracks];
+    TLorentzVector jetTracksSortMC[kTracks];
+    TVector3 pTrackMC[kTracks];
+    TLorentzVector vTrackMCAll[kTracks];
+    Double_t pTrackMCAll[kTracks];
+    TLorentzVector vTrackMC[kTracks];
+    TVector3 pTrackMCBoost[kTracks];
+    Double_t eventShapes[4];
+    
+    Int_t nAccTr = 0;
+    Int_t nInJet[kMaxJets];
+    TLorentzVector inJetPartV[kMaxJets][kTracks];
+    Int_t nAllTracksMC = 0;
+    TVector3 n01MC;
+
+    TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
+    if(!tca){
+      if(fDebug)Printf("NO Ref Tracks\n");
+      tca = 0;
+    }
+    else{
+      nMCtracks = tca->GetEntries();
+      for(Int_t iTrack = 0; iTrack < nMCtracks; iTrack++)
        {
-         selJets[nGenSel] = genJets[i];
-         nGenSel++;
+         //      TParticle * part = (TParticle*)stack->Particle(iTrack);
+         AliAODMCParticle *part = dynamic_cast<AliAODMCParticle*>(tca->At(iTrack));
+         if (!part) continue;
+         if(!part->IsPhysicalPrimary())continue;      
+         Double_t fEta = part->Eta();
+         if(TMath::Abs(fEta) > .9) continue;
+         vTrackMCAll[nAllTracksMC].SetPxPyPzE(part->Px(), part->Py(), part->Pz(), part->E());
+         pTrackMCAll[nAllTracksMC] = part->Pt();
+         nAllTracksMC++;
        }
-      else
+      if(nAllTracksMC == 0) return;
+      for(Int_t iJet = 0; iJet < nGenSel; iJet++)
        {
-         counter = 0;
-         tag = 0;
-         for(Int_t j = 0; j < nGenJets; j++)
+         Int_t nJetTracks = 0;
+         for(Int_t i = 0; i < nAllTracksMC; i++)
            {
-             if(i!=j)
+             Double_t dPhi = (jetGen[iJet].Phi()-vTrackMCAll[i].Phi());
+             if(dPhi > TMath::Pi()) dPhi = dPhi - 2.*TMath::Pi();
+             if(dPhi < (-1.*TMath::Pi())) dPhi = dPhi + 2.*TMath::Pi();
+             Double_t dEta = (jetGen[iJet].Eta()-vTrackMCAll[i].Eta());
+             Double_t deltaR = TMath::Sqrt(dPhi*dPhi+dEta*dEta);
+             if(deltaR < fR && vTrackMCAll[i].Pt() > 1.5)
                {
-                 Double_t dRij = genJets[i].DeltaR(&genJets[j]);
-                 counter++;
-                 if(dRij > 2*fR) tag++;
+                 jetTracksMC[nAccTr] = vTrackMCAll[i];
+                 eTracksMC[nAccTr] = vTrackMCAll[i].E();
+                 pTracksMC[nAccTr] = vTrackMCAll[i].Pt();
+                 inJetPartV[iJet][nJetTracks].SetPxPyPzE(vTrackMCAll[i].Px(), vTrackMCAll[i].Py(), vTrackMCAll[i].Pz(),vTrackMCAll[i].E());
+                 nAccTr++;
+                 nJetTracks++;
                }
            }
-         if(counter!=0)
+         nInJet[iJet] = nJetTracks;
+       }
+      
+      if(nAccTr == 0) return;
+      if(fDebug)Printf("*********** Number of Jets : %d ***************\n", nGenSel);  
+      Double_t pTav[kMaxJets];
+      for(Int_t i = 0; i < nGenSel; i++)
+       {
+         Double_t pTsum = 0;
+         if(fDebug)Printf("*********** Number of particles in Jet %d = %d *******************\n", i+3, nInJet[i]);
+         for(Int_t iT = 0; iT < nInJet[i]; iT++)
            {
-             if(tag/counter == 1)
-               {
-                 selJets[nGenSel] = genJets[i];
-                 nGenSel++;
-               }
+             Double_t pt = inJetPartV[i][iT].Pt();
+             pTsum += pt;
            }
+         pTav[i] = pTsum/nInJet[i]; 
        }
-    }
-
-  if(nGenSel == 0) return;
-
-  for (Int_t gj = 0; gj < nGenSel; gj++)
-    {
-      eGen[gj] = selJets[gj].E();
-    }
-  
-  TMath::Sort(nGenSel, eGen, idxGen);
-  for (Int_t ig = 0; ig < nGenSel; ig++)
-    {
-      jetGen[ig] = selJets[idxGen[ig]];
-    }
-
-  fhXSec->Fill(jetGen[0].Pt(), fXsection);
-
-//  AliStack * stack = mcEvent->Stack();
-
-  TClonesArray *tca = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
-  if(!tca) return;
-  Int_t nMCtracks = tca->GetEntries();
-  Double_t * eTracksMC = new Double_t[kTracks];
-  Double_t pTracksMC[kTracks];
-  Int_t * idxTracksMC = new Int_t[kTracks];
-  TLorentzVector jetTracksMC[kTracks];
-  TLorentzVector jetTracksSortMC[kTracks];
-  TVector3 pTrackMC[kTracks];
-  TLorentzVector vTrackMCAll[kTracks];
-  Double_t pTrackMCAll[kTracks];
-  TLorentzVector vTrackMC[kTracks];
-  TVector3 pTrackMCBoost[kTracks];
-  Double_t eventShapes[4];
-
-  Int_t nAccTr = 0;
-  Int_t nInJet[kMaxJets];
-  TLorentzVector inJetPartV[kMaxJets][kTracks];
-  Int_t nAllTracksMC = 0;
-
-  for(Int_t iTrack = 0; iTrack < nMCtracks; iTrack++)
-    {
-      //      TParticle * part = (TParticle*)stack->Particle(iTrack);
-      AliAODMCParticle *part = dynamic_cast<AliAODMCParticle*>(tca->At(iTrack));
-      if (!part) continue;
-      if(!part->IsPhysicalPrimary())continue;      
-      Double_t fEta = part->Eta();
-      if(TMath::Abs(fEta) > .9) continue;
-      vTrackMCAll[nAllTracksMC].SetPxPyPzE(part->Px(), part->Py(), part->Pz(), part->E());
-      pTrackMCAll[nAllTracksMC] = part->Pt();
-      nAllTracksMC++;
-    }
-  if(nAllTracksMC == 0) return;
-  for(Int_t iJet = 0; iJet < nGenSel; iJet++)
-    {
-      Int_t nJetTracks = 0;
+      
+      TMath::Sort(nAllTracksMC, pTrackMCAll, idxTracksMC);
       for(Int_t i = 0; i < nAllTracksMC; i++)
        {
-         Double_t dPhi = (jetGen[iJet].Phi()-vTrackMCAll[i].Phi());
-         if(dPhi > TMath::Pi()) dPhi = dPhi - 2.*TMath::Pi();
-         if(dPhi < (-1.*TMath::Pi())) dPhi = dPhi + 2.*TMath::Pi();
-         Double_t dEta = (jetGen[iJet].Eta()-vTrackMCAll[i].Eta());
-         Double_t deltaR = TMath::Sqrt(dPhi*dPhi+dEta*dEta);
-         if(deltaR < fR && vTrackMCAll[i].Pt() > 1.5)
+         jetTracksSortMC[i] = vTrackMCAll[idxTracksMC[i]];
+         pTrackMC[i].SetXYZ(jetTracksSortMC[i].Px(), jetTracksSortMC[i].Py(), jetTracksSortMC[i].Pz());
+         vTrackMC[i].SetPxPyPzE(jetTracksSortMC[i].Px(), jetTracksSortMC[i].Py(), jetTracksSortMC[i].Pz(), jetTracksSortMC[i].E());
+       }
+      
+      n01MC = pTrackMC[0].Unit();
+      n01MC.SetZ(0.);
+      
+      //Thrust calculation, iterative method
+      if(nGenSel > 1)
+       { 
+         //       if(fGlobVar == 1)
+         //    {
+         if(fDebug)Printf("**************Shapes for MC*************");
+         AliAnalysisHelperJetTasks::GetEventShapes(n01MC, pTrackMC, nAllTracksMC, eventShapes);
+         //    }
+         if(eventShapes[0] < 2/TMath::Pi()){
+           Double_t eventShapesTest[4];
+           TVector3 n01Test;
+           Int_t rnd_max = nAllTracksMC;
+           Int_t k = (rand()%rnd_max)+3;
+           while(TMath::Abs(pTrackMC[k].X()) < 10e-5 && TMath::Abs(pTrackMC[k].Y()) < 10e-5){
+             k--;
+           }
+           n01Test = pTrackMC[k].Unit();
+           n01Test.SetZ(0.);
+           AliAnalysisHelperJetTasks::GetEventShapes(n01Test, pTrackMC, nAllTracksMC, eventShapesTest);
+           eventShapes[0] = TMath::Max(eventShapes[0], eventShapesTest[0]);
+           if(TMath::Abs(eventShapes[0]-eventShapesTest[0]) < 10e-7) n01MC = n01Test;
+         }
+       
+         Double_t s = eventShapes[1];
+         Double_t a = eventShapes[2];
+         Double_t c = eventShapes[3];
+         
+         switch(nGenSel)
            {
-             jetTracksMC[nAccTr] = vTrackMCAll[i];
-             eTracksMC[nAccTr] = vTrackMCAll[i].E();
-             pTracksMC[nAccTr] = vTrackMCAll[i].Pt();
-             inJetPartV[iJet][nJetTracks].SetPxPyPzE(vTrackMCAll[i].Px(), vTrackMCAll[i].Py(), vTrackMCAll[i].Pz(),vTrackMCAll[i].E());
-             nAccTr++;
-             nJetTracks++;
+           case 2:
+             {
+               fhAGen2->Fill(a);
+               fhSGen2->Fill(s);
+               fhCGen2->Fill(c);
+             }
+             break;
+           case 3:
+             {
+               fhAGen3->Fill(a);
+               fhSGen3->Fill(s);
+               fhCGen3->Fill(c);
+             }
+             break;
+           }
+         Double_t thrust01MC = eventShapes[0];
+         
+         switch(nGenSel)
+           {
+           case 2:
+             fhThrustGen2->Fill(thrust01MC, fXsection);
+             break;
+           case 3:
+             fhThrustGen3->Fill(thrust01MC, fXsection);
+             break;
            }
        }
-      nInJet[iJet] = nJetTracks;
-    }
-
-  if(nAccTr == 0) return;
-  if(fDebug)Printf("*********** Number of Jets : %d ***************\n", nGenSel);  
-  Double_t pTav[kMaxJets];
-  for(Int_t i = 0; i < nGenSel; i++)
-    {
-      Double_t pTsum = 0;
-      if(fDebug)Printf("*********** Number of particles in Jet %d = %d *******************\n", i+3, nInJet[i]);
-      for(Int_t iT = 0; iT < nInJet[i]; iT++)
-       {
-         Double_t pt = inJetPartV[i][iT].Pt();
-         pTsum += pt;
-       }
-      pTav[i] = pTsum/nInJet[i]; 
     }
   
-  TMath::Sort(nAllTracksMC, pTrackMCAll, idxTracksMC);
-  for(Int_t i = 0; i < nAllTracksMC; i++)
-    {
-      jetTracksSortMC[i] = vTrackMCAll[idxTracksMC[i]];
-      pTrackMC[i].SetXYZ(jetTracksSortMC[i].Px(), jetTracksSortMC[i].Py(), jetTracksSortMC[i].Pz());
-      vTrackMC[i].SetPxPyPzE(jetTracksSortMC[i].Px(), jetTracksSortMC[i].Py(), jetTracksSortMC[i].Pz(), jetTracksSortMC[i].E());
-    }
-
-  TVector3 n01MC = pTrackMC[0].Unit();
-  n01MC.SetZ(0.);
-
-  //Thrust calculation, iterative method
-  if(nGenSel > 1)
-    { 
-//       if(fGlobVar == 1)
-//     {
-      if(fDebug)Printf("**************Shapes for MC*************");
-      AliAnalysisHelperJetTasks::GetEventShapes(n01MC, pTrackMC, nAllTracksMC, eventShapes);
-//     }
-      if(eventShapes[0] < 2/TMath::Pi()){
-       Double_t eventShapesTest[4];
-       TVector3 n01Test;
-       Int_t rnd_max = nAllTracksMC;
-       Int_t k = (rand()%rnd_max)+3;
-       while(TMath::Abs(pTrackMC[k].X()) < 10e-5 && TMath::Abs(pTrackMC[k].Y()) < 10e-5){
-         k--;
-       }
-       n01Test = pTrackMC[k].Unit();
-       n01Test.SetZ(0.);
-       AliAnalysisHelperJetTasks::GetEventShapes(n01Test, pTrackMC, nAllTracksMC, eventShapesTest);
-       eventShapes[0] = TMath::Max(eventShapes[0], eventShapesTest[0]);
-       if(TMath::Abs(eventShapes[0]-eventShapesTest[0]) < 10e-7) n01MC = n01Test;
+    
+    //rest frame MC jets
+    for (Int_t i = 0; i < nGenSel; ++i)
+      {
+       vGen[i].SetPxPyPzE(jetGen[i].Px(), jetGen[i].Py(), jetGen[i].Pz(), jetGen[i].E());
+       pGen[i].SetXYZ(vGen[i].Px(), vGen[i].Py(), vGen[i].Pz());
+       vsumGen += vGen[i];
       }
-
-      Double_t s = eventShapes[1];
-      Double_t a = eventShapes[2];
-      Double_t c = eventShapes[3];
-
-      switch(nGenSel)
+    if(tca){
+      if(eventShapes[0] > 0.8 && nGenSel > 1)
        {
-       case 2:
-         {
-           fhAGen2->Fill(a);
-           fhSGen2->Fill(s);
-           fhCGen2->Fill(c);
-         }
-         break;
-       case 3:
-         {
-           fhAGen3->Fill(a);
-           fhSGen3->Fill(s);
-           fhCGen3->Fill(c);
-         }
-         break;
+         for(Int_t i = 0; i < nGenSel; i++)
+           fhdPhiThrustGen->Fill(n01MC.DeltaPhi(pGen[i]), jetGen[i].E());
        }
-      Double_t thrust01MC = eventShapes[0];
-      
-      switch(nGenSel)
+ 
+      if(eventShapes[0] <= 0.8 && nGenSel > 1)   
        {
-       case 2:
-         fhThrustGen2->Fill(thrust01MC, fXsection);
-         break;
-       case 3:
-         fhThrustGen3->Fill(thrust01MC, fXsection);
-         break;
+         for(Int_t i = 0; i < nGenSel; i++)
+           fhdPhiThrustGenALL->Fill(n01MC.DeltaPhi(pGen[i]), jetGen[i].E());
        }
     }
-  
-  
-  //rest frame MC jets
-  for (Int_t i = 0; i < nGenSel; ++i)
-    {
-      vGen[i].SetPxPyPzE(jetGen[i].Px(), jetGen[i].Py(), jetGen[i].Pz(), jetGen[i].E());
-      pGen[i].SetXYZ(vGen[i].Px(), vGen[i].Py(), vGen[i].Pz());
-      vsumGen += vGen[i];
-    }
-  if(eventShapes[0] > 0.8 && nGenSel > 1)
-    {
-      for(Int_t i = 0; i < nGenSel; i++)
-       fhdPhiThrustGen->Fill(n01MC.DeltaPhi(pGen[i]), jetGen[i].E());
-    }
- 
-  if(eventShapes[0] <= 0.8 && nGenSel > 1)   
-    {
-      for(Int_t i = 0; i < nGenSel; i++)
-       fhdPhiThrustGenALL->Fill(n01MC.DeltaPhi(pGen[i]), jetGen[i].E());
-    }
-      
-  Double_t fPxGen = vsumGen.Px();
-  Double_t fPyGen = vsumGen.Py();
-  Double_t fPzGen = vsumGen.Pz();
-  Double_t fEGen = vsumGen.E();
-
-  Double_t eRestGen[kMaxJets];
-  for (Int_t j = 0; j < nGenSel; j++)
-    {
-      vGen[j].Boost(-fPxGen/fEGen, -fPyGen/fEGen, -fPzGen/fEGen);
-      eRestGen[j] = vGen[j].E();
-    }
-
-  for (Int_t j = 0; j < nAccTr; j++)
-    {
-      vTrackMC[j].Boost(-fPxGen/fEGen, -fPyGen/fEGen, -fPzGen/fEGen);
-      pTrackMCBoost[j].SetXYZ(vTrackMC[j].Px(),vTrackMC[j].Py(),vTrackMC[j].Pz());
-    }
-      
-  Int_t idxRestGen[kMaxJets];
-  TMath::Sort(nGenSel, eRestGen, idxRestGen);
-  for(Int_t j = 0; j < nGenSel; j++)
-    {
-      vRestGen[j] = vGen[idxRestGen[j]];
-      eSumGen += vRestGen[j].E();
-    }
+    
+    Double_t fPxGen = vsumGen.Px();
+    Double_t fPyGen = vsumGen.Py();
+    Double_t fPzGen = vsumGen.Pz();
+    Double_t fEGen = vsumGen.E();
+    
+    Double_t eRestGen[kMaxJets];
+    for (Int_t j = 0; j < nGenSel; j++)
+      {
+       vGen[j].Boost(-fPxGen/fEGen, -fPyGen/fEGen, -fPzGen/fEGen);
+       eRestGen[j] = vGen[j].E();
+      }
+    
+    for (Int_t j = 0; j < nAccTr; j++)
+      {
+       vTrackMC[j].Boost(-fPxGen/fEGen, -fPyGen/fEGen, -fPzGen/fEGen);
+       pTrackMCBoost[j].SetXYZ(vTrackMC[j].Px(),vTrackMC[j].Py(),vTrackMC[j].Pz());
+      }
+    
+    Int_t idxRestGen[kMaxJets];
+    TMath::Sort(nGenSel, eRestGen, idxRestGen);
+    for(Int_t j = 0; j < nGenSel; j++)
+      {
+       vRestGen[j] = vGen[idxRestGen[j]];
+       eSumGen += vRestGen[j].E();
+      }
 
-  if (nGenSel == 3)
-    {
-      //      if(nInJet[0] < 3 || nInJet[1] < 3 || nInJet[2] < 3) return;
-      //       if(pRestGen[1].DeltaPhi(pRestGen[2]) > 0.95 && pRestGen[1].DeltaPhi(pRestGen[2]) < 1.15)
-      //       {
+    if (nGenSel == 3)
+      {
+       //      if(nInJet[0] < 3 || nInJet[1] < 3 || nInJet[2] < 3) return;
+       //       if(pRestGen[1].DeltaPhi(pRestGen[2]) > 0.95 && pRestGen[1].DeltaPhi(pRestGen[2]) < 1.15)
+       //      {
       
-      for(Int_t i = 0; i < nGenSel; i++)
-       {
-         xGen[i] = 2*vRestGen[i].E()/eSumGen;
+       for(Int_t i = 0; i < nGenSel; i++)
+         {
+           xGen[i] = 2*vRestGen[i].E()/eSumGen;
        }
       
-      if(fDebug)Printf("***************** Values of Dalitz variables are : %f, %f, %f ****************\n", xGen[0], xGen[1], xGen[2]);
-      
-      if(fDebug)Printf("***************** fXSection = %f ******************\n", fXsection);
-      if(eSumGen <= 60)
-       fhX3X4Gen60->Fill(xGen[0], xGen[1], fXsection);
-      
-      if(eSumGen > 60 && eSumGen <= 100)
-       fhX3X4Gen60100->Fill(xGen[0], xGen[1], fXsection);
-      
-      if(eSumGen > 100)
-       fhX3X4Gen100->Fill(xGen[0], xGen[1], fXsection);
-         
-      FillTopology(fhX3X4Gen, fhMu34Gen, fhMu45Gen, fhMu35Gen, xGen, pRestGen, fXsection);
-    }
-  
+       if(fDebug)Printf("***************** Values of Dalitz variables are : %f, %f, %f ****************\n", xGen[0], xGen[1], xGen[2]);
+       
+       if(fDebug)Printf("***************** fXSection = %f ******************\n", fXsection);
+       if(eSumGen <= 60)
+         fhX3X4Gen60->Fill(xGen[0], xGen[1], fXsection);
+       
+       if(eSumGen > 60 && eSumGen <= 100)
+         fhX3X4Gen60100->Fill(xGen[0], xGen[1], fXsection);
+       
+       if(eSumGen > 100)
+         fhX3X4Gen100->Fill(xGen[0], xGen[1], fXsection);
+       
+       FillTopology(fhX3X4Gen, fhMu34Gen, fhMu45Gen, fhMu35Gen, xGen, pRestGen, fXsection);
+      }
+  }    
+
 
 
 //_______________________________________________histos for MC_____________________________________________________
@@ -1097,7 +1108,7 @@ void AliAnalysisTaskThreeJets::UserExec(Option_t * )
     {
 //       if(pRest[1].DeltaPhi(pRest[2]) > 0.95 && pRest[1].DeltaPhi(pRest[2]) < 1.15)
 //     {
-         fhInOut->Fill(nGenSel);
+         if(fUseMC) fhInOut->Fill(nGenSel);
 //       for(Int_t j = 0; j < nTracksALL; j++)
 //         {
 //           vTracksAll[j].Boost(-fPx/fE, -fPy/fE, -fPz/fE);

diff --git a/PWG4/JetTasks/AliAnalysisTaskThreeJets.h b/PWG4/JetTasks/AliAnalysisTaskThreeJets.h
index 40077fdb23a13f0adcec3b5398b51473ced52385..01febbd1a349ada397f2b572991d0243e7bf9200 100644 (file)
--- a/PWG4/JetTasks/AliAnalysisTaskThreeJets.h
+++ b/PWG4/JetTasks/AliAnalysisTaskThreeJets.h
@@ -47,6 +47,7 @@ class AliAnalysisTaskThreeJets : public AliAnalysisTaskSE
   virtual void Terminate(Option_t * option);\r
 \r
   virtual void SetAODInput(Bool_t b){fUseAODInput = b;}\r
+  virtual void SetUseMC(Bool_t b){fUseMC = b;}\r
 \r
   virtual void SetBranchGen(const char* c){fBranchGen = c;}\r
   virtual void SetBranchRec(const char* c){fBranchRec = c;}\r
@@ -71,7 +72,8 @@ class AliAnalysisTaskThreeJets : public AliAnalysisTaskSE
   enum {kTracks = 1000};\r
 \r
   AliAODEvent  *fAOD; // where we take the jets from can be input or output AOD\r
-  \r
+  Bool_t       fUseMC; //switch for using MC info  \r
+\r
   TString       fBranchRec;  // AOD branch name for reconstructed\r
   TString       fBranchGen;  // AOD brnach for genereated\r
   \r

diff --git a/PWG4/JetTasks/AliAnalysisTaskUE.cxx b/PWG4/JetTasks/AliAnalysisTaskUE.cxx
index 09cee741fd5c698a00b7019cc315f35756f46e04..8a9f72e4540290b5aea8187844240789261c272a 100644 (file)
--- a/PWG4/JetTasks/AliAnalysisTaskUE.cxx
+++ b/PWG4/JetTasks/AliAnalysisTaskUE.cxx
@@ -78,6 +78,7 @@ ClassImp( AliAnalysisTaskUE)
 //____________________________________________________________________
 AliAnalysisTaskUE:: AliAnalysisTaskUE(const char* name):
 AliAnalysisTask(name, ""),
+fTrigger(0),
 fDebug(0),
 fDeltaAOD(kFALSE),
 fDeltaAODBranch(""),
@@ -232,7 +233,7 @@ void  AliAnalysisTaskUE::CreateOutputObjects()
   //
   //  Histograms
 
-  OpenFile(0);
+  // OpenFile(0);
   CreateHistos();
   //  fListOfHistos->SetOwner(kTRUE);  
 
@@ -243,6 +244,16 @@ void  AliAnalysisTaskUE::CreateOutputObjects()
 //____________________________________________________________________
 void  AliAnalysisTaskUE::Exec(Option_t */*option*/)
 {
+  //Trigger selection
+  AliAnalysisHelperJetTasks::Trigger trig;
+  trig = (const enum AliAnalysisHelperJetTasks::Trigger)fTrigger;
+  if (AliAnalysisHelperJetTasks::IsTriggerFired(fAOD,trig)){
+       if (fDebug > 1) AliInfo(" Trigger Selection: event ACCEPTED ... ");
+  }else{
+       if (fDebug > 1) AliInfo(" Trigger Selection: event REJECTED ... ");
+       return;
+  }
+
   // Execute analysis for current event
   //
   if ( fDebug > 3 ) AliInfo( " Processing event..." );

diff --git a/PWG4/JetTasks/AliAnalysisTaskUE.h b/PWG4/JetTasks/AliAnalysisTaskUE.h
index ae70930f7215766cb60eae2f07ff66c2de929c54..a0adc6d83898c9d4a9340ab2a23d650eea5e2a0e 100644 (file)
--- a/PWG4/JetTasks/AliAnalysisTaskUE.h
+++ b/PWG4/JetTasks/AliAnalysisTaskUE.h
@@ -27,7 +27,10 @@ class  AliAnalysisTaskUE : public AliAnalysisTask
     virtual     void   CreateOutputObjects();
     virtual     void   Exec(Option_t *option);
     virtual     void   Terminate(Option_t *);
-    
+
+    //Select the trigger
+    void SelectTrigger(Int_t trig) { fTrigger = trig; }
+
     //  Setters
     virtual     void   SetDebugLevel( Int_t level )  { fDebug = level; }
     void   SetPtRangeInHist( Int_t bin, Double_t min, Double_t max ) {
@@ -81,6 +84,7 @@ class  AliAnalysisTaskUE : public AliAnalysisTask
     void   QSortTracks(TObjArray &a, Int_t first, Int_t last);
     void   WriteSettings();
     
+    Int_t      fTrigger;         //Trigger flag as defined in AliAnalysisHelperJetTasks.h
     Int_t      fDebug;           //  Debug flag
     Bool_t      fDeltaAOD;        //  Read jets from delta AOD 
     TString     fDeltaAODBranch;  //  Jet branch name from delta AOD

diff --git a/PWG4/JetTasks/AliPWG4HighPtSpectra.cxx b/PWG4/JetTasks/AliPWG4HighPtSpectra.cxx
index dc817e76d80fea37231c01cc65bf3dfd693d80bc..dcb9b5d7f209c6c465fc0bc5d9a649a608006967 100644 (file)
--- a/PWG4/JetTasks/AliPWG4HighPtSpectra.cxx
+++ b/PWG4/JetTasks/AliPWG4HighPtSpectra.cxx
@@ -273,7 +273,7 @@ void AliPWG4HighPtSpectra::CreateOutputObjects() {
   //
   AliDebug(2,Form("CreateOutputObjects","CreateOutputObjects of task %s", GetName()));
 
-  OpenFile(0);
+  //  OpenFile(0);
   fHistList = new TList();
   //slot #1
   //  OpenFile(0);