Filter task for kinematics (Ernesto Lopez)

diff --git a/ANALYSIS/AliAnalysisTaskKineFilter.cxx b/ANALYSIS/AliAnalysisTaskKineFilter.cxx
new file mode 100644 (file)
index 0000000..3ab0fd5
--- /dev/null
+++ b/ANALYSIS/AliAnalysisTaskKineFilter.cxx
@@ -0,0 +1,631 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+//
+//  Analysis task for Kinematic filtering
+//  Fill AOD tracks from Kinematic stack
+//
+//  Code taken from macro CreateAODfromKineTree.C by  Markus Oldenburg
+//  
+ 
+#include <TChain.h>
+#include <TFile.h>
+
+#include "AliAnalysisTaskKineFilter.h"
+#include "AliAnalysisManager.h"
+#include "AliAnalysisFilter.h"
+#include "AliHeader.h"
+#include "AliStack.h"
+#include "TParticle.h"
+#include "AliMCEvent.h"
+#include "AliAODEvent.h"
+#include "AliAODHeader.h"
+#include "AliAODVertex.h"
+#include "AliAODTrack.h"
+
+#include "AliLog.h"
+
+ClassImp(AliAnalysisTaskKineFilter)
+
+////////////////////////////////////////////////////////////////////////
+
+//____________________________________________________________________
+AliAnalysisTaskKineFilter::AliAnalysisTaskKineFilter():
+    fTrackFilter(0x0)
+{
+  // Default constructor
+}
+
+//____________________________________________________________________
+AliAnalysisTaskKineFilter::AliAnalysisTaskKineFilter(const char* name):
+    AliAnalysisTaskSE(name),
+    fTrackFilter(0x0)
+{
+  // Default constructor
+    DefineInput (0, TChain::Class());
+    DefineOutput(0, TTree::Class());
+}
+
+//____________________________________________________________________
+AliAnalysisTaskKineFilter::AliAnalysisTaskKineFilter(const AliAnalysisTaskKineFilter& obj):
+    AliAnalysisTaskSE(obj),
+    fTrackFilter(0)
+{
+// Copy constructor
+    fTrackFilter = obj.fTrackFilter;
+}
+
+//____________________________________________________________________
+AliAnalysisTaskKineFilter& AliAnalysisTaskKineFilter::operator=(const AliAnalysisTaskKineFilter& other)
+{
+// Assignment
+    AliAnalysisTaskSE::operator=(other);
+    fTrackFilter = other.fTrackFilter;
+    return *this;
+}
+
+//____________________________________________________________________
+void AliAnalysisTaskKineFilter::UserCreateOutputObjects()
+{
+// Create the output container
+
+    OutputTree()->GetUserInfo()->Add(fTrackFilter);
+}
+
+
+//____________________________________________________________________
+void AliAnalysisTaskKineFilter::Exec(Option_t */*option*/)
+{
+// Execute analysis for current event
+//
+
+// Fill AOD tracks from Kinematic stack
+    
+  // get AliAOD Event 
+  AliAODEvent* aod = AODEvent();
+//  aod->CreateStdContent();
+
+  AliStack* stack = MCEvent()->Stack();
+  Int_t nTracks = stack->GetNtrack();
+  Int_t nPrims = stack->GetNprimary();
+
+  AliAODVertex *primary = NULL; 
+  Int_t nPos = 0;
+  Int_t nNeg = 0;
+  Int_t jVertices = 0;
+  Int_t jTracks = 0; 
+  Float_t p[3];
+  Float_t x[3];
+ 
+  // Access to the header
+  AliAODHeader *header = aod->GetHeader();
+
+  Double_t emEnergy[2] = {-999., -999.};
+
+  // fill the header
+  *header = AliAODHeader(MCEvent()->Header()->GetRun(),
+                         0, // bunchX number         
+                         0, // orbit number
+                         0, // period number
+                         nTracks,
+                         nPos,
+                         nNeg,
+                         -999, // mag. field
+                         -999., // muon mag. field
+                         -999., // centrality
+                         -999., // ZDCN1Energy
+                         -999., // ZDCP1Energy
+                         -999., // ZDCN2Energy
+                         -999., // ZDCP2Energy
+                         emEnergy, // emEnergy
+                         0, // TriggerMask
+                         0, // TriggerCluster
+                         0, // EventType
+                         ""); // title
+  
+  // Access to the AOD container of vertices
+  TClonesArray &vertices = *(aod->GetVertices());
+
+  // Access to the AOD container of tracks
+  TClonesArray &tracks = *(aod->GetTracks());
+ 
+  aod->ResetStd(nTracks, 1);
+
+  // track loop
+  for (Int_t iTrack = 0; iTrack < nPrims; ++iTrack) {
+                                                              
+    TParticle *part = stack->Particle(iTrack);
+    
+    if (iTrack == 0) {
+      // add primary vertex
+      x[0] = part->Vx(); x[1] = part->Vy(); x[2] = part->Vz();
+      primary = new(vertices[jVertices++])
+                   AliAODVertex(x, NULL, -999., NULL, AliAODVertex::kPrimary);  
+    }
+    
+    // only final particles
+    if( part->GetStatusCode() !=1 ) continue;  
+    
+    //
+    // Track selection
+    UInt_t selectInfo = 0;
+    if (fTrackFilter) {
+       selectInfo = fTrackFilter->IsSelected(part);
+       if (!selectInfo) continue;
+    }
+    
+    x[0] = part->Vx(); x[1] = part->Vy(); x[2] = part->Vz();
+    p[0] = part->Px(); p[1] = part->Py(); p[2] = part->Pz();
+
+    // add primary tracks
+    primary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID,
+                                                            0, // Label
+                                                            p,
+                                                            kTRUE,
+                                                            x,
+                                                            kFALSE,
+                                                            NULL, 
+                                                            (Short_t)-99,
+                                                            0, // no ITSClusterMap
+                                                            NULL,
+                                                            primary,
+                                                            kFALSE,  // no fit performed
+                                                            kFALSE, // no fit preformed
+                                                            AliAODTrack::kPrimary,
+                                                            selectInfo));
+                                                            
+    AliAODTrack* currTrack = (AliAODTrack*)tracks.Last();
+    SetChargeAndPID(part->GetPdgCode(), currTrack);
+    if (currTrack->Charge() != -99) {
+      if (currTrack->Charge() > 0) {
+        nPos++;
+      } else if (currTrack->Charge() < 0) {
+        nNeg++;
+      }            
+    }
+    LoopOverSecondaries(part, jTracks, jVertices, nPos, nNeg);
+    
+  } // end of track loop
+    
+  header->SetRefMultiplicityPos(nPos);
+  header->SetRefMultiplicityNeg(nNeg);
+    
+    
+  if( fDebug > 1 ) 
+     AliInfo(Form("primaries: %d secondaries: %d (pos: %d neg: %d), vertices: %d", 
+                   nPrims, tracks.GetEntriesFast()-nPrims, nPos, nNeg, vertices.GetEntriesFast() ) );
+  return;
+}
+
+
+//____________________________________________________________________
+Int_t AliAnalysisTaskKineFilter::LoopOverSecondaries(TParticle *mother, Int_t &jTracks, Int_t &jVertices, Int_t &nPos, Int_t &nNeg ) 
+{
+  
+  if (mother->GetNDaughters() > 0) {
+    
+    AliStack* stack = MCEvent()->Stack();
+    
+    TClonesArray &vertices = *(AODEvent()->GetVertices());
+    TClonesArray &tracks = *(AODEvent()->GetTracks());
+    Float_t p[3];
+    Float_t x[3];  
+    AliAODVertex* secondary = NULL;
+
+    for (Int_t iDaughter = mother->GetFirstDaughter(); iDaughter <= mother->GetLastDaughter(); iDaughter++) {
+      TParticle *part = stack->Particle(iDaughter);
+      // only final particles
+      if( part->GetStatusCode() !=1 ) continue;  
+      
+      p[0] = part->Px(); 
+      p[1] = part->Py(); 
+      p[2] = part->Pz();
+      x[0] = part->Vx(); 
+      x[1] = part->Vy(); 
+      x[2] = part->Vz();
+
+      if (iDaughter == mother->GetFirstDaughter()) {
+        // add secondary vertex
+        secondary = new(vertices[jVertices++])
+                       AliAODVertex(x, NULL, -999., tracks.Last(), AliAODVertex::kUndef);
+        
+        SetVertexType(part, secondary);
+      }
+      
+      UInt_t selectInfo = 0; 
+      //
+      // Track selection
+      if (fTrackFilter) {
+        selectInfo = fTrackFilter->IsSelected(part);
+        if (!selectInfo) continue;
+      }
+        
+      // add secondary tracks
+      secondary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID
+                                                                0, // label
+                                                                p,
+                                                                kTRUE,
+                                                                x,
+                                                                kFALSE,
+                                                                NULL, 
+                                                                (Short_t)-99,
+                                                                0, // no cluster map available
+                                                                NULL,
+                                                                secondary,
+                                                                kFALSE, // no fit performed
+                                                                kFALSE, // no fit performed
+                                                                AliAODTrack::kSecondary,
+                                                                selectInfo));
+
+      AliAODTrack* currTrack = (AliAODTrack*)tracks.Last();
+      SetChargeAndPID(part->GetPdgCode(), currTrack);
+      if (currTrack->Charge() != -99) {
+        if (currTrack->Charge() > 0) {
+          nPos++;
+        } else if (currTrack->Charge() < 0) {
+          nNeg++;
+        }            
+      }
+
+      LoopOverSecondaries(part, jTracks, jVertices, nPos, nNeg);
+    }
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+//____________________________________________________________________
+void AliAnalysisTaskKineFilter::SetChargeAndPID(Int_t pdgCode, AliAODTrack *track) {
+
+  Float_t PID[10] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};
+
+  switch (pdgCode) {
+
+  case 22: // gamma
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 11: // e- 
+    track->SetCharge(-1);
+    PID[AliAODTrack::kElectron] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case -11: // e+
+    track->SetCharge(+1);
+    PID[AliAODTrack::kElectron] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case 13: // mu- 
+    track->SetCharge(-1);
+    PID[AliAODTrack::kMuon] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case -13: // mu+
+    track->SetCharge(+1);
+    PID[AliAODTrack::kMuon] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case 111: // pi0
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case 211: // pi+
+    track->SetCharge(+1);
+    PID[AliAODTrack::kPion] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case -211: // pi-
+    track->SetCharge(-1);
+    PID[AliAODTrack::kPion] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case 130: // K0L
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case 321: // K+
+    track->SetCharge(+1);
+    PID[AliAODTrack::kKaon] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case -321: // K- 
+    track->SetCharge(-1);
+    PID[AliAODTrack::kKaon] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case 2112: // n
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case 2212: // p
+    track->SetCharge(+1);
+    PID[AliAODTrack::kProton] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case -2212: // anti-p
+    track->SetCharge(-1);
+    PID[AliAODTrack::kProton] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 310: // K0S
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case 311: // K0
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case -311: // anti-K0
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+    
+  case 221: // eta
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 3122: // lambda
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 3222: // Sigma+
+    track->SetCharge(+1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 3212: // Sigma0
+    track->SetCharge(-1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 3112: // Sigma-
+    track->SetCharge(-1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 3322: // Xi0
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 3312: // Xi-
+    track->SetCharge(-1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 3334: // Omega-
+    track->SetCharge(-1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case -2112: // n-bar
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case -3122: // anti-Lambda
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case -3222: // anti-Sigma-
+    track->SetCharge(-1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case -3212: // anti-Sigma0
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case -3112: // anti-Sigma+
+    track->SetCharge(+1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case -3322: // anti-Xi0
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case -3312: // anti-Xi+
+    track->SetCharge(+1);
+    break;
+
+  case -3334: // anti-Omega+
+    track->SetCharge(+1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 411: // D+
+    track->SetCharge(+1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case -411: // D- 
+    track->SetCharge(-1);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case 421: // D0
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  case -421: // anti-D0
+    track->SetCharge(0);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+    break;
+
+  default : // unknown
+    track->SetCharge(-99);
+    PID[AliAODTrack::kUnknown] = 1.;
+    track->SetPID(PID);
+ }
+
+  return;
+}
+
+//____________________________________________________________________
+void AliAnalysisTaskKineFilter::SetVertexType(TParticle *part, AliAODVertex *vertex) 
+{
+  // this whole thing doesn't make much sense. but anyhow...
+  AliStack* stack = MCEvent()->Stack();
+  TParticle *mother = stack->Particle(part->GetFirstMother());
+  Int_t pdgMother = mother->GetPdgCode();
+  Int_t pdgPart = part->GetPdgCode();
+  
+  // kinks
+  if (mother->GetNDaughters() == 2) {
+    Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
+    Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
+
+    if (!(pdgMother == 22 || pdgMother == 111 || pdgMother == 130 || 
+          TMath::Abs(pdgMother) == 2112 || pdgMother == 310 || pdgMother == 221 || 
+          TMath::Abs(pdgMother) == 3122 || TMath::Abs(pdgMother) == 3322 || 
+          pdgMother == -3212 || TMath::Abs(pdgMother) == 421 || 
+          TMath::Abs(pdgMother) == 311) // not neutral
+        && (((firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || 
+              TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || 
+              firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || 
+              TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || 
+              TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // neutral
+             && !(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || 
+                  TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || 
+                  lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || 
+                  TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || 
+                  TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311)) // not neutral
+            || !((firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || 
+                  TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || 
+                  firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || 
+                  TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || 
+                  TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
+                 && (lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || 
+                     TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || 
+                     lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || 
+                     TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || 
+                     TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311)))) { // neutral
+      
+      vertex->SetType(AliAODVertex::kKink);
+  //    jKinks++;
+    }
+  }
+
+  // V0
+  else if (mother->GetNDaughters() == 2) {
+    Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
+    Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
+
+    if ((pdgMother == 22 || pdgMother == 111 || pdgMother == 130 || 
+         TMath::Abs(pdgMother) == 2112 || pdgMother == 310 || 
+         pdgMother == 221 || TMath::Abs(pdgMother) == 3122 || 
+         TMath::Abs(pdgMother) == 3322 || pdgMother == -3212 || 
+         TMath::Abs(pdgMother) == 421 || TMath::Abs(pdgMother) == 311) // neutral
+        && !(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || 
+             TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || 
+             lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || 
+             TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || 
+             TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
+        && !(firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || 
+             TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || 
+             firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || 
+             TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || 
+             TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311)) { // not neutral
+      
+      vertex->SetType(AliAODVertex::kV0);
+  //    jV0s++;
+    }
+  }
+
+  // Cascade
+  else if (mother->GetNDaughters() == 2) {
+    Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
+    Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
+    
+    if ((TMath::Abs(pdgMother) == 3334 || TMath::Abs(pdgMother) == 3312 || TMath::Abs(pdgMother) == 3322) &&
+        (TMath::Abs(pdgPart) == 3122 || TMath::Abs(pdgPart) == 211 || TMath::Abs(pdgPart) == 321)
+        && ((!(firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 || 
+               TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 || 
+               firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 || 
+               TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 || 
+               TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral   
+             && TMath::Abs(lastPdgCode) == 3122) // labmda or anti-lambda
+            || ((!(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 || 
+                   TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 || 
+                   lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 || 
+                   TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 || 
+                   TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
+                 && TMath::Abs(firstPdgCode) == 3122)))) { // lambda or anti-lambda
+      vertex->SetType(AliAODVertex::kCascade);
+  //    jCascades++;
+    }
+  }
+
+  // Multi
+  else if (mother->GetNDaughters() > 2) {
+
+    vertex->SetType(AliAODVertex::kMulti);
+  //  jMultis++;
+  }
+
+  else {
+    vertex->SetType(AliAODVertex::kUndef);
+  }
+}

diff --git a/ANALYSIS/AliAnalysisTaskKineFilter.h b/ANALYSIS/AliAnalysisTaskKineFilter.h
new file mode 100644 (file)
index 0000000..246f419
--- /dev/null
+++ b/ANALYSIS/AliAnalysisTaskKineFilter.h
@@ -0,0 +1,49 @@
+#ifndef ALIANALYSISTASKKINEFILTER_H
+#define ALIANALYSISTASKKINEFILTER_H
+ 
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//
+//  Analysis task for Kinematic filtering
+//  Fill AOD tracks from Kinematic stack
+//
+
+#include <TList.h> 
+#include "AliAnalysisTaskSE.h"
+
+class AliMCEvent;
+class TChain;
+class AliAODEvent;
+class AliAnalysisFilter;
+class TParticle;
+class AliAODTrack;  
+class AliAODVertex;
+
+class AliAnalysisTaskKineFilter : public AliAnalysisTaskSE
+{
+ public:
+                                  AliAnalysisTaskKineFilter();
+                                  AliAnalysisTaskKineFilter( const char* name );
+                                  AliAnalysisTaskKineFilter(const AliAnalysisTaskKineFilter& obj);
+    virtual                      ~AliAnalysisTaskKineFilter() {;}
+     AliAnalysisTaskKineFilter&   operator=(const AliAnalysisTaskKineFilter& other);
+    
+    // Implementation of interface methods
+    virtual                void   UserCreateOutputObjects();
+    virtual                void   Exec( Option_t *option );
+    
+    // Setters
+    virtual                void   SetTrackFilter(AliAnalysisFilter* trackF) {fTrackFilter = trackF;}
+    
+ private:
+                          Int_t   LoopOverSecondaries(TParticle *mother, Int_t& jTracks, Int_t& jVertices, Int_t& nPos, Int_t& nNeg );
+                           void   SetChargeAndPID(Int_t pdgCode, AliAODTrack *track);
+                           void   SetVertexType(TParticle *part, AliAODVertex *vertex);
+                         
+              AliAnalysisFilter*  fTrackFilter; //  Track Filter
+                    
+    ClassDef( AliAnalysisTaskKineFilter, 1 ); // Analysis task for Kinematic filtering
+};
+ 
+#endif

diff --git a/ANALYSIS/AliKineTrackCuts.cxx b/ANALYSIS/AliKineTrackCuts.cxx
new file mode 100644 (file)
index 0000000..6112621
--- /dev/null
+++ b/ANALYSIS/AliKineTrackCuts.cxx
@@ -0,0 +1,100 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+#include <TObject.h>
+#include <TMath.h>
+#include <TParticle.h>
+
+#include "AliKineTrackCuts.h"
+
+//
+//  Class for simple Kinematic cuts on
+//  particles (tracks) from Kinematic stack (TParticle)
+//  MC Simulation
+//
+
+
+//____________________________________________________________________
+ClassImp(AliKineTrackCuts)
+
+//____________________________________________________________________
+AliKineTrackCuts::AliKineTrackCuts(const Char_t* name, const Char_t* title) : 
+  AliAnalysisCuts(name,title),
+  fPMin(0),
+  fPMax(0),
+  fPtMin(0),
+  fPtMax(0),
+  fPxMin(0),
+  fPxMax(0),
+  fPyMin(0),
+  fPyMax(0),
+  fPzMin(0),
+  fPzMax(0),
+  fEtaMin(0),
+  fEtaMax(0),
+  fRapMin(0),
+  fRapMax(0)
+{
+  //
+  // constructor
+  //
+  // setting default cuts
+  SetPRange();
+  SetPtRange();
+  SetPxRange();
+  SetPyRange();
+  SetPzRange();
+  SetEtaRange();
+  SetRapRange();
+}
+
+
+
+//____________________________________________________________________
+Bool_t  AliKineTrackCuts::IsSelected(TObject* obj)
+{
+
+  TParticle * part = (TParticle *)obj;
+  
+  // getting the kinematic variables of the track
+  Float_t momentum = part->P();
+  Float_t pt       = part->Pt();
+  Float_t energy   = part->Energy();
+
+  //y-eta related calculations
+  Float_t eta = part->Eta();
+  Float_t y   = -100.;
+  if((energy != TMath::Abs(part->Pz()))&&(momentum != 0))
+    y = 0.5*TMath::Log((energy + part->Pz())/(energy - part->Pz()));
+
+  if((momentum < fPMin) || (momentum > fPMax)) return kFALSE;
+  if((pt < fPtMin) || (pt > fPtMax)) return kFALSE;
+  if((part->Px() < fPxMin) || (part->Px() > fPxMax)) return kFALSE;
+  if((part->Py() < fPyMin) || (part->Py() > fPyMax)) return kFALSE;
+  if((part->Pz() < fPzMin) || (part->Pz() > fPzMax)) return kFALSE;
+  if((eta < fEtaMin) || (eta > fEtaMax)) return kFALSE;
+  if((y < fRapMin) || (y > fRapMax)) return kFALSE;
+
+  return kTRUE;
+}
+
+
+
+
+
+
+
+
+

diff --git a/ANALYSIS/AliKineTrackCuts.h b/ANALYSIS/AliKineTrackCuts.h
new file mode 100644 (file)
index 0000000..9d49379
--- /dev/null
+++ b/ANALYSIS/AliKineTrackCuts.h
@@ -0,0 +1,45 @@
+#ifndef ALIKINETRACKCUTS_H
+#define ALIKINETRACKCUTS_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+#include "AliAnalysisCuts.h"
+
+class  TObject;
+
+class AliKineTrackCuts : public AliAnalysisCuts
+{
+
+public:
+                      AliKineTrackCuts(const Char_t* name = "AliKineTrackCuts", const Char_t* title = "");
+  virtual            ~AliKineTrackCuts(){;}
+  
+            Bool_t    IsSelected(TObject* obj);
+            
+  // track kinematic cut setters
+              void    SetPRange(Float_t r1=0, Float_t r2=1e10)       {fPMin=r1;   fPMax=r2;}
+              void    SetPtRange(Float_t r1=0, Float_t r2=1e10)      {fPtMin=r1;  fPtMax=r2;}
+              void    SetPxRange(Float_t r1=-1e10, Float_t r2=1e10)  {fPxMin=r1;  fPxMax=r2;}
+              void    SetPyRange(Float_t r1=-1e10, Float_t r2=1e10)  {fPyMin=r1;  fPyMax=r2;}
+              void    SetPzRange(Float_t r1=-1e10, Float_t r2=1e10)  {fPzMin=r1;  fPzMax=r2;}
+              void    SetEtaRange(Float_t r1=-1e10, Float_t r2=1e10) {fEtaMin=r1; fEtaMax=r2;}
+              void    SetRapRange(Float_t r1=-1e10, Float_t r2=1e10) {fRapMin=r1; fRapMax=r2;}
+                  
+protected:        
+                  
+  // kinematics cuts
+           Float_t   fPMin,   fPMax;             // definition of the range of the P
+           Float_t   fPtMin,  fPtMax;            // definition of the range of the Pt
+           Float_t   fPxMin,  fPxMax;            // definition of the range of the Px
+           Float_t   fPyMin,  fPyMax;            // definition of the range of the Py
+           Float_t   fPzMin,  fPzMax;            // definition of the range of the Pz
+           Float_t   fEtaMin, fEtaMax;           // definition of the range of the eta
+           Float_t   fRapMin, fRapMax;           // definition of the range of the y
+  
+  
+  ClassDef(AliKineTrackCuts, 1)
+};
+
+
+#endif

diff --git a/ANALYSIS/runKineProof.C b/ANALYSIS/runKineProof.C
new file mode 100644 (file)
index 0000000..9a9c874
--- /dev/null
+++ b/ANALYSIS/runKineProof.C
@@ -0,0 +1,112 @@
+{
+    gSystem->Load("libPhysics.so");
+    // Connecting to the PROOF cluster
+    TProof::Open("elopez@lxb6046");
+
+    // Clear packages if changing ROOT version on CAF or local
+    //gProof->ClearPackages();
+    
+    // Enable the needed packages
+    gProof->UploadPackage("STEERBase");
+    gProof->EnablePackage("STEERBase");
+    gProof->UploadPackage("ESD");
+    gProof->EnablePackage("ESD");
+    gProof->UploadPackage("AOD");
+    gProof->EnablePackage("AOD");
+    gProof->UploadPackage("ANALYSIS");
+    gProof->EnablePackage("ANALYSIS");
+    gProof->UploadPackage("ANALYSISalice");
+    gProof->EnablePackage("ANALYSISalice");
+    gProof->UploadPackage("JETAN");
+    gProof->EnablePackage("JETAN");
+       
+    // Create the analysis manager
+    mgr = new AliAnalysisManager("Analysis UE test");
+
+    // Create, add task
+    gProof->Load("AliKineTrackCuts.cxx+");
+    AliKineTrackCuts* trackCuts = new AliKineTrackCuts("AliKineTrackCuts", "Eta");
+    trackCuts->SetEtaRange(-1., 1.);
+    
+    AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter");
+    trackFilter->AddCuts(trackCuts);
+    
+    gProof->Load("AliAnalysisTaskKineFilter.cxx+");
+    AliAnalysisTaskKineFilter *kinefilter = new AliAnalysisTaskKineFilter("Kine Filter");
+    kinefilter->SetTrackFilter(trackFilter);
+    mgr->AddTask(kinefilter);
+    
+    // Create chain of input files
+    gROOT->LoadMacro("CreateESDChain.C");
+    chain = CreateChain( "TE", "KINE82XX_30K.txt", 200);
+ 
+ 
+ 
+    /////////////////////////////////////////////////////////////////////////////////// 
+    // Create the analysis manager
+    //
+    // Input 
+    // MC Truth
+    AliMCEventHandler* mcHandler = new AliMCEventHandler();
+    mcHandler->SetReadTR(kFALSE);
+    
+    // Output
+    AliAODHandler* aodHandler = new AliAODHandler();
+    aodHandler->SetOutputFileName( "aodKine.root" );
+
+    AliAnalysisManager *mgr  = new AliAnalysisManager("Jet Manager", "Jet Manager");
+//    mgr->SetInputEventHandler  (inpHandler);
+    mgr->SetMCtruthEventHandler(mcHandler);
+    mgr->SetOutputEventHandler (aodHandler);
+    mgr->SetDebugLevel(10);
+    
+    /////////////////////////////////////////////////////////////////////////////////// 
+    
+    //
+    // Set of cuts
+    // 
+    AliKineTrackCuts* trackCuts = new AliKineTrackCuts("AliKineTrackCuts", "Eta");
+    trackCuts->SetEtaRange(-1., 1.);
+ //   trackCuts->SetPtRange(0.5);
+              
+    AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter");
+    trackFilter->AddCuts(trackCuts);
+    
+    
+    AliAnalysisTaskKineFilter* kinefilter = new AliAnalysisTaskKineFilter("Kine Filter");
+    kinefilter->SetTrackFilter(trackFilter);
+    kinefilter->SetDebugLevel(10);
+    mgr->AddTask(kinefilter);
+    
+    //    Analysis Task for Jet
+    //  AliAnalysisTaskJets need ConfigJetAnalysis.C macro !!!!
+    AliAnalysisTaskJets *jetana = new AliAnalysisTaskJets("JetAnalysis");
+    jetana->SetDebugLevel(10);
+    mgr->AddTask(jetana);
+
+    //
+    // Create containers for input/output                  
+    AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain",TChain::Class(), 
+                                                             AliAnalysisManager::kInputContainer);
+
+    AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("tree", TTree::Class(),
+                                                              AliAnalysisManager::kOutputContainer, "default");
+    AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("histos", TList::Class(),
+                                                              AliAnalysisManager::kOutputContainer, "histos.root");
+
+    mgr->ConnectInput  (kinefilter,  0, cinput1  );
+    mgr->ConnectOutput (kinefilter,  0, coutput1 );
+
+    mgr->ConnectInput  (jetana,     0, cinput1  );
+    mgr->ConnectOutput (jetana,     0, coutput1 );
+    mgr->ConnectOutput (jetana,     1, coutput2 );
+
+
+    //
+    // Run the analysis
+    //    
+    if( mgr->InitAnalysis() ) {
+      mgr->PrintStatus();
+      mgr->StartAnalysis("proof", chain );
+    }
+}