First attempt to use AliAnalisysTask (Marian)
authormarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Mar 2008 15:26:18 +0000 (15:26 +0000)
committermarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Mar 2008 15:26:18 +0000 (15:26 +0000)
PWG1/AliGenInfoMaker.cxx
PWG1/AliGenInfoMaker.h
PWG1/AliGenV0Info.cxx
PWG1/AliGenV0Info.h
PWG1/AliMCInfo.cxx
PWG1/AliMCInfo.h
PWG1/AliRecInfoMaker.cxx
PWG1/PWG1LinkDef.h
PWG1/PWG1README.txt
PWG1/libPWG1.pkg

index 3f43c91..884e433 100644 (file)
@@ -22,6 +22,10 @@ Origin: marian.ivanov@cern.ch
 Generate complex MC information - used for Comparison later on
 How to use it?
 
+
+---Usage outside of the analysis framework
+
+gSystem->Load("libANALYSIS.so")
 gSystem->Load("libPWG1.so")
 AliGenInfoMaker *t = new AliGenInfoMaker("galice.root","genTracks.root",0,0)
 t->Exec();
@@ -36,29 +40,21 @@ t->Exec();
 #include "Rtypes.h"
 #include "TFile.h"
 #include "TTree.h"
-//#include "TChain.h"
-//#include "TCut.h"
-//#include "TString.h"
 #include "TStopwatch.h"
 #include "TParticle.h"
-//#include "TSystem.h"
-//#include "TCanvas.h"
-//#include "TGeometry.h"
-//#include "TPolyLine3D.h"
 
 //ALIROOT includes
+#include "AliMCEvent.h"
+#include "AliMCEventHandler.h"
+
 #include "AliRun.h"
 #include "AliStack.h"
 #include "AliSimDigits.h"
 #include "AliTPCParam.h"
 #include "AliTPC.h"
 #include "AliTPCLoader.h"
-//#include "AliDetector.h"
 #include "AliTrackReference.h"
 #include "AliTPCParamSR.h"
-#include "AliTracker.h"
-//#include "AliMagF.h"
-//#include "AliHelix.h"
 #include "AliTrackPointArray.h"
 
 #endif
@@ -78,7 +74,10 @@ ClassImp(AliGenInfoMaker)
 
   
 ////////////////////////////////////////////////////////////////////////
-AliGenInfoMaker::AliGenInfoMaker():
+AliGenInfoMaker::AliGenInfoMaker(): 
+  fGenTracksArray(0),          //clones array with filtered particles
+  fGenKinkArray(0),            //clones array with filtered Kinks
+  fGenV0Array(0),              //clones array with filtered V0s
   fDebug(0),                   //! debug flag  
   fEventNr(0),                 //! current event number
   fLabel(0),                   //! track label
@@ -88,7 +87,6 @@ AliGenInfoMaker::AliGenInfoMaker():
   fTreeGenTracks(0),           //! output tree with generated tracks
   fTreeKinks(0),               //!  output tree with Kinks
   fTreeV0(0),                  //!  output tree with V0
-  fTreeHitLines(0),            //! tree with hit lines
   fFileGenTracks(0),           //! output file with stored fTreeGenTracks
   fLoader(0),                  //! pointer to the run loader
   fTreeD(0),                   //! current tree with digits
@@ -97,16 +95,23 @@ AliGenInfoMaker::AliGenInfoMaker():
   fGenInfo(0),                 //! array with pointers to gen info
   fNInfos(0),                  //! number of tracks with infos
   fParamTPC(0),                //! AliTPCParam
-  fTPCPtCut(0.03),            
-  fITSPtCut(0.1),  
-  fTRDPtCut(0.1), 
-  fTOFPtCut(0.1)
-{   
+  fTPCPtCut(0.1),              //  TPC pt cut            
+  fITSPtCut(0.1),              //  ITS pt cut
+  fTRDPtCut(0.1),              //  TRD pt cut
+  fTOFPtCut(0.1)               //  TOF pt cut
+{    
+  sprintf(fFnRes,"%s","genTracks.root");
 }
 
+
+
+
 ////////////////////////////////////////////////////////////////////////
 AliGenInfoMaker::AliGenInfoMaker(const char * fnGalice, const char* fnRes,
                                 Int_t nEvents, Int_t firstEvent):
+  fGenTracksArray(0),          //clones array with filtered particles
+  fGenKinkArray(0),            //clones array with filtered Kinks
+  fGenV0Array(0),              //clones array with filtered V0s
   fDebug(0),                   //! debug flag  
   fEventNr(0),                 //! current event number
   fLabel(0),                   //! track label
@@ -116,7 +121,6 @@ AliGenInfoMaker::AliGenInfoMaker(const char * fnGalice, const char* fnRes,
   fTreeGenTracks(0),           //! output tree with generated tracks
   fTreeKinks(0),               //!  output tree with Kinks
   fTreeV0(0),                  //!  output tree with V0
-  fTreeHitLines(0),            //! tree with hit lines
   fFileGenTracks(0),           //! output file with stored fTreeGenTracks
   fLoader(0),                  //! pointer to the run loader
   fTreeD(0),                   //! current tree with digits
@@ -125,11 +129,10 @@ AliGenInfoMaker::AliGenInfoMaker(const char * fnGalice, const char* fnRes,
   fGenInfo(0),                 //! array with pointers to gen info
   fNInfos(0),                  //! number of tracks with infos
   fParamTPC(0),                //! AliTPCParam 
-  fTPCPtCut(0.03),  
+  fTPCPtCut(0.1),  
   fITSPtCut(0.1),  
   fTRDPtCut(0.1), 
   fTOFPtCut(0.1)
-
 {
   //
   // 
@@ -139,6 +142,8 @@ AliGenInfoMaker::AliGenInfoMaker(const char * fnGalice, const char* fnRes,
   fNEvents = nEvents;
   sprintf(fFnRes,"%s",fnRes);
   //
+  //
+  //
   fLoader = AliRunLoader::Open(fnGalice);
   if (gAlice){
     delete gAlice->GetRunLoader();
@@ -154,7 +159,7 @@ AliGenInfoMaker::AliGenInfoMaker(const char * fnGalice, const char* fnRes,
     fNEvents=nall;
     fFirstEventNr=0;
   }    
-
+  
   if (nall<=0){
     cerr<<"no events available"<<endl;
     fEventNr = 0;
@@ -164,8 +169,23 @@ AliGenInfoMaker::AliGenInfoMaker(const char * fnGalice, const char* fnRes,
     fEventNr = nall-firstEvent;
     cerr<<"restricted number of events availaible"<<endl;
   }
-  AliMagF * magf = gAlice->Field();
-  AliTracker::SetFieldMap(magf,0);
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////
+AliGenInfoMaker::~AliGenInfoMaker()
+{
+  //
+  // Destructor
+  //
+  
+  if (fLoader){
+    fLoader->UnloadgAlice();
+    gAlice = 0;
+    delete fLoader;
+  }
 }
 
 
@@ -184,20 +204,70 @@ AliMCInfo * AliGenInfoMaker::MakeInfo(UInt_t i)
     return 0;  
 }
 
-////////////////////////////////////////////////////////////////////////
-AliGenInfoMaker::~AliGenInfoMaker()
-{
+
+Int_t  AliGenInfoMaker::ProcessEvent(AliMCEventHandler* mcinfo){
   //
-  // Destructor
+  // Process MC info from the task
   //
-  
-  if (fLoader){
-    fLoader->UnloadgAlice();
-    gAlice = 0;
-    delete fLoader;
+  if (!fParamTPC) {
+    SetIO();
+    fParamTPC = GetTPCParam();
   }
+  fStack  = mcinfo->MCEvent()->Stack();
+  fTreeTR = mcinfo->TreeTR();
+  fTreeD  = 0;
+  // array with preprocessedprocessed information
+  fGenTracksArray = new TObjArray;
+  fGenKinkArray   = new TObjArray;
+  fGenV0Array     = new TObjArray;
+  //
+  ProcessEvent();
+  fEventNr++;
+  return 0;
 }
 
+
+
+Int_t AliGenInfoMaker::ProcessEvent(){
+  //
+  // Process Event 
+  //
+  fNParticles = fStack->GetNtrack();
+  //
+  fGenInfo = new AliMCInfo*[fNParticles];
+  for (UInt_t i = 0; i<fNParticles; i++) {
+    fGenInfo[i]=0; 
+  }
+  //
+  cout<<"Start to process event "<<fEventNr<<endl;
+  cout<<"\tfNParticles = "<<fNParticles<<endl;
+  if (fDebug>2) cout<<"\n\n\n\tStart loop over TreeTR"<<endl;
+  if (TreeTRLoop()>0) return 1;
+  //
+  if (fDebug>2) cout<<"\n\n\n\tStart loop over TreeD"<<endl;
+  if (TreeDLoop()>0) return 1;
+  //
+  if (fDebug>2) cout<<"\n\n\n\tStart loop over TreeK"<<endl;
+  if (TreeKLoop()>0) return 1;
+  if (fDebug>2) cout<<"\tEnd loop over TreeK"<<endl;
+  //
+  //  if (BuildKinkInfo()>0) return 1;
+  if (BuildV0Info()>0) return 1;
+  if (fDebug>2) cout<<"\tEnd loop over TreeK"<<endl;
+  //
+  for (UInt_t i = 0; i<fNParticles; i++) {
+    if (fGenInfo[i]) delete fGenInfo[i]; 
+  }
+  delete []fGenInfo;
+  return 0;
+}
+
+
+
+
+
+
+
 Int_t  AliGenInfoMaker::SetIO()
 {
   //
@@ -205,7 +275,6 @@ Int_t  AliGenInfoMaker::SetIO()
   //
   CreateTreeGenTracks();
   if (!fTreeGenTracks) return 1;
-  //  AliTracker::SetFieldFactor(); 
  
   fParamTPC = GetTPCParam();
   //
@@ -256,19 +325,6 @@ Int_t AliGenInfoMaker::CloseIO()
 
 
 ////////////////////////////////////////////////////////////////////////
-Int_t AliGenInfoMaker::Exec(Int_t nEvents, Int_t firstEventNr)
-{
-  //
-  // Execute action for 
-  // nEvents
-  // firstEventNr - first event number
-  //
-  fNEvents = nEvents;
-  fFirstEventNr = firstEventNr;
-  return Exec();
-}
-
-////////////////////////////////////////////////////////////////////////
 Int_t AliGenInfoMaker::Exec()  
 {
   //
@@ -280,51 +336,26 @@ Int_t AliGenInfoMaker::Exec()
   Int_t status =SetIO();
   if (status>0) return status;
   //
-
   for (fEventNr = fFirstEventNr; fEventNr < fFirstEventNr+fNEvents;
        fEventNr++) {
     SetIO(fEventNr);
-    fNParticles = fStack->GetNtrack();
-    //
-    fGenInfo = new AliMCInfo*[fNParticles];
-    for (UInt_t i = 0; i<fNParticles; i++) {
-      fGenInfo[i]=0; 
-    }
-    //
-    cout<<"Start to process event "<<fEventNr<<endl;
-    cout<<"\tfNParticles = "<<fNParticles<<endl;
-    if (fDebug>2) cout<<"\n\n\n\tStart loop over TreeTR"<<endl;
-    if (TreeTRLoop()>0) return 1;
-    //
-    if (fDebug>2) cout<<"\n\n\n\tStart loop over TreeD"<<endl;
-    if (TreeDLoop()>0) return 1;
-    //
-    if (fDebug>2) cout<<"\n\n\n\tStart loop over TreeK"<<endl;
-    if (TreeKLoop()>0) return 1;
-    if (fDebug>2) cout<<"\tEnd loop over TreeK"<<endl;
-    //
-    if (BuildKinkInfo()>0) return 1;
-    if (BuildV0Info()>0) return 1;
-    //if (BuildHitLines()>0) return 1;
-    if (fDebug>2) cout<<"\tEnd loop over TreeK"<<endl;
-    //
-    for (UInt_t i = 0; i<fNParticles; i++) {
-      if (fGenInfo[i]) delete fGenInfo[i]; 
-    }
-    delete []fGenInfo;
+    ProcessEvent();
     CloseIOEvent();
   }
   //
   CloseIO();
   CloseOutputFile();
-
   cerr<<"Exec finished"<<endl;
-
   timer.Stop();
   timer.Print();
   return 0;
 }
 
+
+
+
+
+
 ////////////////////////////////////////////////////////////////////////
 void AliGenInfoMaker::CreateTreeGenTracks() 
 {
@@ -352,21 +383,14 @@ void AliGenInfoMaker::CreateTreeGenTracks()
   delete v0info;
   //
   //
-  AliTrackPointArray * points0 = new AliTrackPointArray;  
-  AliTrackPointArray * points1 = new AliTrackPointArray;  
-  AliTrackPointArray * points2 = new AliTrackPointArray;  
-  fTreeHitLines = new TTree("HitLines","HitLines");
-  fTreeHitLines->Branch("TPC.","AliTrackPointArray",&points0,32000,10);
-  fTreeHitLines->Branch("TRD.","AliTrackPointArray",&points1,32000,10);
-  fTreeHitLines->Branch("ITS.","AliTrackPointArray",&points2,32000,10);
-  Int_t label=0;
-  fTreeHitLines->Branch("Label",&label,"label/I");
   //
   fTreeGenTracks->AutoSave();
   fTreeKinks->AutoSave();
   fTreeV0->AutoSave();
-  fTreeHitLines->AutoSave();
 }
+
+
+
 ////////////////////////////////////////////////////////////////////////
 void AliGenInfoMaker::CloseOutputFile() 
 {
@@ -410,12 +434,12 @@ Int_t AliGenInfoMaker::TreeKLoop()
   // not all generators give primary vertex position. Take the vertex
   // of the particle 0 as primary vertex.
   TDatabasePDG  pdg; //get pdg table  
-  //thank you very much root for this
-  TBranch * br = fTreeGenTracks->GetBranch("MC");
+
   TParticle *particle = stack->ParticleFromTreeK(0);
   fVPrim[0] = particle->Vx();
   fVPrim[1] = particle->Vy();
   fVPrim[2] = particle->Vz();
+  Int_t accepted =0;
   for (UInt_t iParticle = 0; iParticle < fNParticles; iParticle++) {
     // load only particles with TR
     AliMCInfo * info = GetInfo(iParticle);
@@ -436,11 +460,26 @@ Int_t AliGenInfoMaker::TreeKLoop()
     ppdg = pdg.GetParticle(ipdg);         
     info->fEventNr = fEventNr;
     info->Update();
+    if (fGenTracksArray){
+      fGenTracksArray->AddLast(info->Clone());
+    }
+    accepted++;
+  }
+  //
+  // write the results to the tree - if specified
+  //
+  TBranch * br = fTreeGenTracks->GetBranch("MC");
+  for (UInt_t iParticle = 0; iParticle < fNParticles; iParticle++) {
+    // load only particles with TR
+    AliMCInfo * info = GetInfo(iParticle);
+    if (!info) continue;
     //////////////////////////////////////////////////////////////////////    
     br->SetAddress(&info);    
     fTreeGenTracks->Fill();    
   }
   fTreeGenTracks->AutoSave();
+  //
+  //
   if (fDebug > 2) cerr<<"end of TreeKLoop"<<endl;
   return 0;
 }
@@ -474,7 +513,6 @@ Int_t  AliGenInfoMaker::BuildKinkInfo()
     AliMCInfo * info = GetInfo(iParticle);
     if (!info) continue;
     if (info->fCharge==0) continue;  
-    if (info->fTRdecay.P()<0.13) continue;  //momenta cut 
     if (info->fTRdecay.R()>500)  continue;  //R cut - decay outside barrel
     TParticle & particle = info->fParticle;
     Int_t first = particle.GetDaughter(0);
@@ -501,17 +539,8 @@ Int_t  AliGenInfoMaker::BuildKinkInfo()
       br->SetAddress(&kinkinfo);    
       fTreeKinks->Fill();
     }
-    /*
-    if (dinfo){
-      kinkinfo->fMCm = (*info);
-      kinkinfo->GetPlus() = (*dinfo);
-      kinkinfo->Update();
-      br->SetAddress(&kinkinfo);    
-      fTreeKinks->Fill();
-    }
-    */
   }
-  fTreeGenTracks->AutoSave();
+  fTreeKinks->AutoSave();
   if (fDebug > 2) cerr<<"end of Kink Loop"<<endl;
   return 0;
 }
@@ -530,10 +559,7 @@ Int_t  AliGenInfoMaker::BuildV0Info()
     cout<<"There are "<<fNParticles<<" primary and secondary particles in event "
        <<fEventNr<<endl;
   }  
-  //  Int_t  ipdg = 0;
-  //TParticlePDG *ppdg = 0;
-  // not all generators give primary vertex position. Take the vertex
-  // of the particle 0 as primary vertex.
+  //
   TDatabasePDG  pdg; //get pdg table  
   //thank you very much root for this
   TBranch * br = fTreeV0->GetBranch("MC");
@@ -541,32 +567,26 @@ Int_t  AliGenInfoMaker::BuildV0Info()
   AliGenV0Info * v0info = new AliGenV0Info;
   //
   //
-  for (UInt_t iParticle = 0; iParticle < fNParticles; iParticle++) {
-    // load only particles with TR
-    AliMCInfo * info = GetInfo(iParticle);
-    if (!info) continue;
-    if (info->fCharge==0) continue;  
-    //
-    //
-    TParticle & particle = info->fParticle;
-    Int_t mother = particle.GetMother(0);
-    if (mother <=0) continue;
+  for (UInt_t iParticle = 0; iParticle < fNParticles; iParticle++) {    
+    TParticle * mParticle = fStack->Particle(iParticle);
+    if (!mParticle) continue;
+    if (mParticle->GetPDG()==0) continue;
+    if (mParticle->GetPDG()->Charge()!=0) continue;  //only neutral particle
     //
-    TParticle * motherparticle = stack->Particle(mother);
-    if (!motherparticle) continue;
+    Int_t first = mParticle->GetDaughter(0);
+    Int_t last  = mParticle->GetDaughter(1);
+    if (first-last==0) continue;
     //
-    Int_t last = motherparticle->GetDaughter(1);
-    if (last==(int)iParticle) continue;
-    AliMCInfo * info2 =  info;
-    AliMCInfo * dinfo =  GetInfo(last);
-    if (!dinfo) continue;
-    if (!dinfo->fParticle.GetPDG()) continue;
-    if (!info2->fParticle.GetPDG()) continue;
-    if (dinfo){
-      v0info->SetInfoP(*info);
-      v0info->SetInfoM(*dinfo);
-      v0info->SetMother(*motherparticle);
+    AliMCInfo * info0 = GetInfo(first);
+    AliMCInfo * info1 = GetInfo(first+1);
+    if (info0 && info1){
+      if (info0->GetPdg()==0) continue;
+      if (info1->GetPdg()==0) continue;
+      v0info->SetInfoP(*info0);
+      v0info->SetInfoM(*info1);
+      v0info->SetMother(*mParticle);
       v0info->Update(fVPrim);
+      if (fGenV0Array) fGenV0Array->AddLast(v0info);
       br->SetAddress(&v0info);    
       fTreeV0->Fill();
     }
@@ -579,87 +599,6 @@ Int_t  AliGenInfoMaker::BuildV0Info()
 
 
 
-////////////////////////////////////////////////////////////////////////
-Int_t AliGenInfoMaker::BuildHitLines()
-{
-
-//
-// open the file with treeK
-// loop over all entries there and save information about some tracks
-//
-
-  AliStack * stack = fStack;
-  if (!stack) {cerr<<"Stack was not found!\n"; return 1;}
-  
-  if (fDebug > 0) {
-    cout<<"There are "<<fNParticles<<" primary and secondary particles in event "
-       <<fEventNr<<endl;
-  }  
-//   Int_t  ipdg = 0;
-//   // TParticlePDG *ppdg = 0;
-//   // not all generators give primary vertex position. Take the vertex
-//   // of the particle 0 as primary vertex.
-//   TDatabasePDG  pdg; //get pdg table  
-//   //thank you very much root for this
-//   AliTrackPointArray *tpcp = new AliTrackPointArray;
-//   AliTrackPointArray *trdp = new AliTrackPointArray;
-//   AliTrackPointArray *itsp = new AliTrackPointArray;
-//   Int_t label =0;
-//   //
-//   TBranch * brtpc = fTreeHitLines->GetBranch("TPC.");
-//   TBranch * brtrd = fTreeHitLines->GetBranch("TRD.");  
-//   TBranch * brits = fTreeHitLines->GetBranch("ITS.");
-//   TBranch * brlabel = fTreeHitLines->GetBranch("Label");
-//   brlabel->SetAddress(&label);
-//   brtpc->SetAddress(&tpcp);
-//   brtrd->SetAddress(&trdp);
-//   brits->SetAddress(&itsp);
-//   //
-//   AliDetector *dtpc = gAlice->GetDetector("TPC");
-//   AliDetector *dtrd = gAlice->GetDetector("TRD");
-//   AliDetector *dits = gAlice->GetDetector("ITS");
-//   for (UInt_t iParticle = 0; iParticle < fNParticles; iParticle++) {
-//     // load only particles with TR
-//     AliMCInfo * info = GetInfo(iParticle);
-//     if (!info) continue;
-//     Int_t primpart = info->fPrimPart;
-//     ipdg = info->fParticle.GetPdgCode();
-//     label = iParticle;
-//     //
-//     gAlice->ResetHits();
-//     tpcp->Reset();
-//     itsp->Reset();
-//     trdp->Reset();
-//     tpcp->fLabel1 = ipdg;
-//     trdp->fLabel1 = ipdg;
-//     itsp->fLabel1 = ipdg;
-//     if (dtpc->TreeH()->GetEvent(primpart)){
-//       dtpc->LoadPoints(primpart);
-//       tpcp->Reset(dtpc,iParticle);
-//     }
-//     if (dtrd->TreeH()->GetEvent(primpart)){
-//       dtrd->LoadPoints(primpart);
-//       trdp->Reset(dtrd,iParticle);
-//     }
-//     if (dits->TreeH()->GetEvent(primpart)){
-//       dits->LoadPoints(primpart);
-//       itsp->Reset(dits,iParticle);
-//     }    
-//     //    
-//     fTreeHitLines->Fill();
-//     dtpc->ResetPoints();
-//     dtrd->ResetPoints();
-//     dits->ResetPoints();
-//   }
-//   delete tpcp;
-//   delete trdp;
-//   delete itsp;
-//   fTreeHitLines->AutoSave();
-//   if (fDebug > 2) cerr<<"end of TreeKLoop"<<endl;
-  return 0;
-}
-
 
 ////////////////////////////////////////////////////////////////////////
 Int_t AliGenInfoMaker::TreeDLoop()
@@ -668,7 +607,7 @@ Int_t AliGenInfoMaker::TreeDLoop()
   // open the file with treeD
   // loop over all entries there and save information about some tracks
   //
-  
+  if (!fTreeD) return 0;
   Int_t nInnerSector = fParamTPC->GetNInnerSector();
   Int_t rowShift = 0;
   Int_t zero=fParamTPC->GetZeroSup()+6;  
@@ -723,144 +662,10 @@ Int_t AliGenInfoMaker::TreeDLoop()
 }
 
 
-////////////////////////////////////////////////////////////////////////
-Int_t AliGenInfoMaker::TreeTRLoop()
-{
-  //
-  // loop over TrackReferences and store the first one for each track
-  //  
-  TTree * treeTR = fTreeTR;
-  Int_t nPrimaries = (Int_t) treeTR->GetEntries();
-  if (fDebug > 1) cout<<"There are "<<nPrimaries<<" entries in TreeTR"<<endl;
-  //
-  //
-  //track references for TPC
-  TClonesArray* tpcArrayTR = new TClonesArray("AliTrackReference");
-  TClonesArray* itsArrayTR = new TClonesArray("AliTrackReference");
-  TClonesArray* trdArrayTR = new TClonesArray("AliTrackReference");
-  TClonesArray* tofArrayTR = new TClonesArray("AliTrackReference");
-  TClonesArray* runArrayTR = new TClonesArray("AliTrackReference");
-  //
-  if (treeTR->GetBranch("TPC"))    treeTR->GetBranch("TPC")->SetAddress(&tpcArrayTR);
-  if (treeTR->GetBranch("ITS"))    treeTR->GetBranch("ITS")->SetAddress(&itsArrayTR);
-  if (treeTR->GetBranch("TRD"))    treeTR->GetBranch("TRD")->SetAddress(&trdArrayTR);
-  if (treeTR->GetBranch("TOF"))    treeTR->GetBranch("TOF")->SetAddress(&tofArrayTR);
-  if (treeTR->GetBranch("AliRun")) treeTR->GetBranch("AliRun")->SetAddress(&runArrayTR);
-  //
-  //
-  //
-  for (Int_t iPrimPart = 0; iPrimPart<nPrimaries; iPrimPart++) {
-    treeTR->GetEntry(iPrimPart);
-    //
-    // Loop over TPC references
-    //
-    for (Int_t iTrackRef = 0; iTrackRef < tpcArrayTR->GetEntriesFast(); iTrackRef++) {
-      AliTrackReference *trackRef = (AliTrackReference*)tpcArrayTR->At(iTrackRef);            
-      //
-      if (trackRef->TestBit(BIT(2))){  
-       //if decay 
-       if (trackRef->P()<fTPCPtCut) continue;
-       Int_t label = trackRef->GetTrack(); 
-       AliMCInfo * info = GetInfo(label);
-       if (!info) info = MakeInfo(label);
-       info->fTRdecay = *trackRef;      
-      }
-      //
-      if (trackRef->P()<fTPCPtCut) continue;
-      Int_t label = trackRef->GetTrack();      
-      AliMCInfo * info = GetInfo(label);
-      if (!info) info = MakeInfo(label);
-      if (!info) continue;
-      info->fPrimPart =  iPrimPart;
-      TClonesArray & arr = *(info->fTPCReferences);
-      new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);     
-    }
-    //
-    // Loop over ITS references
-    //
-    for (Int_t iTrackRef = 0; iTrackRef < itsArrayTR->GetEntriesFast(); iTrackRef++) {
-      AliTrackReference *trackRef = (AliTrackReference*)itsArrayTR->At(iTrackRef);            
-      // 
-      //
-      if (trackRef->P()<fTPCPtCut) continue;
-      Int_t label = trackRef->GetTrack();      
-      AliMCInfo * info = GetInfo(label);
-      if ( (!info) && trackRef->Pt()<fITSPtCut) continue;
-      if (!info) info = MakeInfo(label);
-      if (!info) continue;
-      info->fPrimPart =  iPrimPart;
-      TClonesArray & arr = *(info->fITSReferences);
-      new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);     
-    }
-    //
-    // Loop over TRD references
-    //
-    for (Int_t iTrackRef = 0; iTrackRef < trdArrayTR->GetEntriesFast(); iTrackRef++) {
-      AliTrackReference *trackRef = (AliTrackReference*)trdArrayTR->At(iTrackRef);            
-      //
-      if (trackRef->P()<fTRDPtCut) continue;
-      Int_t label = trackRef->GetTrack();      
-      AliMCInfo * info = GetInfo(label);
-      if ( (!info) && trackRef->Pt()<fTRDPtCut) continue;
-      if (!info) info = MakeInfo(label);
-      if (!info) continue;
-      info->fPrimPart =  iPrimPart;
-      TClonesArray & arr = *(info->fTRDReferences);
-      new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);     
-    }
-    //
-    // Loop over TOF references
-    //
-    for (Int_t iTrackRef = 0; iTrackRef < tofArrayTR->GetEntriesFast(); iTrackRef++) {
-      AliTrackReference *trackRef = (AliTrackReference*)tofArrayTR->At(iTrackRef);            
-      Int_t label = trackRef->GetTrack();      
-      AliMCInfo * info = GetInfo(label);
-      if (!info){
-       if (trackRef->Pt()<fTPCPtCut) continue;
-       if ( (!info) && trackRef->Pt()<fTOFPtCut) continue;
-      }
-      if (!info) info = MakeInfo(label);
-      if (!info) continue;
-      info->fPrimPart =  iPrimPart;
-      TClonesArray & arr = *(info->fTOFReferences);
-      new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);     
-    }
-    //
-    //
-    // get dacay position
-    //
-    for (Int_t iTrackRef = 0; iTrackRef < runArrayTR->GetEntriesFast(); iTrackRef++) {
-      AliTrackReference *trackRef = (AliTrackReference*)runArrayTR->At(iTrackRef);      
-      //
-      Int_t label = trackRef->GetTrack();
-      AliMCInfo * info = GetInfo(label);
-      if (!info) continue;
-      if (!trackRef->TestBit(BIT(2))) continue;  //if not decay
-      //      if (TMath::Abs(trackRef.X());
-      info->fTRdecay = *trackRef;      
-    }
-  }
-  //
-  tpcArrayTR->Delete();
-  delete  tpcArrayTR;
-  trdArrayTR->Delete();
-  delete  trdArrayTR;
-  tofArrayTR->Delete();
-  delete  tofArrayTR;
-  itsArrayTR->Delete();
-  delete  itsArrayTR;
-  runArrayTR->Delete();
-  delete  runArrayTR;
-  //
-  return TreeTRLoopNew();
-}
-
-
-
 
 
 ////////////////////////////////////////////////////////////////////////
-Int_t AliGenInfoMaker::TreeTRLoopNew()
+Int_t AliGenInfoMaker::TreeTRLoop()
 {
   //
   // loop over TrackReferences and store the first one for each track
@@ -880,11 +685,14 @@ Int_t AliGenInfoMaker::TreeTRLoopNew()
   for (Int_t ipart = 0; ipart<fStack->GetNtrack(); ipart++) {
     TParticle * part = fStack->Particle(ipart);
     if (!part) continue;
+    if (part->GetPDG()==0) continue;
+    if (part->GetPDG()->Charge()==0) continue;
+    
     if (part->Pt()<fITSPtCut) continue;
     if (part->R()>250.) continue;
     if (TMath::Abs(part->Vz())>250.) continue;
-    if (TMath::Abs(part->Pz()/part->Pt())>2.5) continue; 
-    MakeInfo(ipart);
+    if (TMath::Abs(part->Pz()/part->Pt())>2.5) continue;     
+    AliMCInfo * info = MakeInfo(ipart); 
   }
   //
   //
@@ -898,6 +706,8 @@ Int_t AliGenInfoMaker::TreeTRLoopNew()
       AliTrackReference *trackRef = (AliTrackReference*)runArrayTR->At(iTrackRef);      
       //
       Int_t label = trackRef->GetTrack();
+      AliMCInfo * cinfo = GetInfo(label);
+      if (cinfo) cinfo->CalcTPCrows(runArrayTR);
       //
       // TPC
       //
@@ -906,7 +716,9 @@ Int_t AliGenInfoMaker::TreeTRLoopNew()
        Int_t label = trackRef->GetTrack();      
        AliMCInfo * info = GetInfo(label);
        if (!info && trackRef->Pt()<fTPCPtCut) continue;
-       if (!info) info = MakeInfo(label);
+       if (!info) {
+         info = MakeInfo(label);
+       }
        if (!info) continue;
        info->fPrimPart =  iPrimPart;
        TClonesArray & arr = *(info->fTPCReferences);
@@ -961,10 +773,8 @@ Int_t AliGenInfoMaker::TreeTRLoopNew()
        //
        AliMCInfo * info = GetInfo(label);
        if (!info) continue;
-       //if (!trackRef->TestBit(BIT(2))) continue;  //if not decay
        info->fTRdecay = *trackRef;             
       }
-      
     }
   }
   //
index 94657b7..af54192 100644 (file)
@@ -6,27 +6,24 @@
 
 
 //////////////////////////////////////////////////////////////////////////////
-//                          Class AliGenInfo                               //
+//                          Class AliGenInfoMaker                           //
 //   collect together MC info for comparison purposes - effieciency studies and so on//                                                                 //
 //   marian.ivanov@cern.ch                                                  //
 //////////////////////////////////////////////////////////////////////////////
 
 
 
-////////////////////////////////////////////////////////////////////////
-//
-// Start of implementation of the class AliTPCdigitRow
-//
-////////////////////////////////////////////////////////////////////////
 
 #include <TParticle.h>
+#include "AliAnalysisTask.h"
 #include "AliTrackReference.h"
 
 class TFile;
 class AliRunLoader;
 class AliStack;
 class AliTPCParam;
-
+class AliMCEventHandler;
+class AliMCInfo;
 
 ////////////////////////////////////////////////////////////////////////
 // 
@@ -34,24 +31,29 @@ class AliTPCParam;
 //
 ////////////////////////////////////////////////////////////////////////
 
-class AliGenInfoMaker {
+class AliGenInfoMaker : public TObject {
 
 public:
   AliGenInfoMaker();
-  AliGenInfoMaker(const char * fnGalice, const char* fnRes    ="genTracks.root",
-                  Int_t nEvents=1, Int_t firstEvent=0);
   virtual ~AliGenInfoMaker();
-  Int_t Exec();
-  Int_t Exec(Int_t nEvents, Int_t firstEventNr);
+  // 
+  //
+  AliGenInfoMaker(const char * fnGalice, const char* fnRes,
+                  Int_t nEvents=1, Int_t firstEvent=0);
+  //event by event function - used in the analysis task
+  Int_t ProcessEvent(AliMCEventHandler* mcinfo);
+
+  Int_t ProcessEvent();   // process event
+  Int_t TreeKLoop();      // process kinamatics
+  Int_t TreeTRLoop();     // process track refereces
+  Int_t TreeDLoop();      // process digits tree
+  Int_t BuildKinkInfo();  // build information about MC kinks
+  Int_t BuildV0Info();    // build information about MC kinks
+  //
+  //
+  Int_t Exec();  
   void CreateTreeGenTracks();
   void CloseOutputFile();
-  Int_t TreeKLoop();
-  Int_t TreeTRLoop();
-  Int_t TreeTRLoopNew(); 
-  Int_t TreeDLoop();
-  Int_t BuildKinkInfo();  // build information about MC kinks
-  Int_t BuildV0Info();  // build information about MC kinks
-  Int_t BuildHitLines();  // build information about MC kinks
   void SetFirstEventNr(Int_t i) {fFirstEventNr = i;}
   void SetNEvents(Int_t i) {fNEvents = i;}
   void SetDebug(Int_t level) {fDebug = level;}
@@ -59,14 +61,19 @@ public:
   Int_t CloseIOEvent();
   Int_t CloseIO();
   Int_t SetIO();
+
+protected:
+  AliMCInfo * MakeInfo(UInt_t i);
+  AliMCInfo * GetInfo(UInt_t i) const {return (i<fNParticles)? fGenInfo[i]:0;}
   Float_t TR2LocalX(AliTrackReference *trackRef,
                    AliTPCParam *paramTPC) const;
-  AliMCInfo * GetInfo(UInt_t i) const {return (i<fNParticles)? fGenInfo[i]:0;}
-  AliMCInfo * MakeInfo(UInt_t i);
-
-private:
   AliTPCParam * GetTPCParam();
   Float_t TPCBetheBloch(Float_t bg);
+  //
+  TObjArray *fGenTracksArray;  //clones array with filtered particles
+  TObjArray *fGenKinkArray;    //clones array with filtered Kinks
+  TObjArray *fGenV0Array;      //clones array with filtered V0s
+  //
   Int_t  fDebug;                   //! debug flag  
   Int_t  fEventNr;                 //! current event number
   Int_t  fLabel;                   //! track label
@@ -76,7 +83,6 @@ private:
   TTree *fTreeGenTracks;          //! output tree with generated tracks
   TTree *fTreeKinks;             //!  output tree with Kinks
   TTree *fTreeV0;                //!  output tree with V0
-  TTree *fTreeHitLines;          //! tree with hit lines
   char   fFnRes[1000];             //! output file name with stored tracks
   TFile *fFileGenTracks;          //! output file with stored fTreeGenTracks
   //
@@ -89,8 +95,7 @@ private:
   Int_t   fNInfos;                  //! number of tracks with infos
   //
   AliTPCParam* fParamTPC;         //! AliTPCParam
-  Float_t  fVPrim[3];             //! primary vertex position
-                                  // the fVDist[3] contains size of the 3-vector
+  Float_t  fVPrim[3];             //! primary vertex position                                  // the fVDist[3] contains size of the 3-vector
   // cuts
   //
   Double_t fTPCPtCut; // do not store particles with generated pT less than this
index d962174..eabf3e6 100644 (file)
@@ -121,29 +121,33 @@ void AliGenV0Info::Update(Float_t vertex[3])
   //
   //
   Double_t x1[3],p1[3];
-  TParticle& pdaughter = fMCd.GetParticle();
-  x1[0] = pdaughter.Vx();      
-  x1[1] = pdaughter.Vy();
-  x1[2] = pdaughter.Vz();
-  p1[0] = pdaughter.Px();
-  p1[1] = pdaughter.Py();
-  p1[2] = pdaughter.Pz();
-  Double_t sign = (pdaughter.GetPDG()->Charge()>0)? -1:1;
+  TParticle& part0 = fMCd.GetParticle();
+  x1[0] = part0.Vx();      
+  x1[1] = part0.Vy();
+  x1[2] = part0.Vz();
+  p1[0] = part0.Px();
+  p1[1] = part0.Py();
+  p1[2] = part0.Pz();
+  if (part0.GetPDG()==0) return;
+
+  Double_t sign = (part0.GetPDG()->Charge()>0)? -1:1;
   AliHelix dhelix1(x1,p1,sign);
   //
   //
   Double_t x2[3],p2[3];            
   //
-  TParticle& pmother = fMCm.GetParticle();
-  x2[0] = pmother.Vx();      
-  x2[1] = pmother.Vy();      
-  x2[2] = pmother.Vz();      
-  p2[0] = pmother.Px();
-  p2[1] = pmother.Py();
-  p2[2] = pmother.Pz();
+  TParticle& part1 = fMCm.GetParticle();
+  if (part1.GetPDG()==0) return;
+  x2[0] = part1.Vx();      
+  x2[1] = part1.Vy();      
+  x2[2] = part1.Vz();      
+  p2[0] = part1.Px();
+  p2[1] = part1.Py();
+  p2[2] = part1.Pz();
   //
   //
-  sign = (pmother.GetPDG()->Charge()>0) ? -1:1;
+  if (part1.GetPDG()==0) return;
+  sign = (part1.GetPDG()->Charge()>0) ? -1:1;
   AliHelix mhelix(x2,p2,sign);
   
   //
index a85ebf9..0d68ec8 100644 (file)
 
 
 
-////////////////////////////////////////////////////////////////////////
-//
-// Start of implementation of the class AliTPCdigitRow
-//
-////////////////////////////////////////////////////////////////////////
-
 #include <TParticle.h>
 #include "AliMCInfo.h"
 
@@ -42,20 +36,6 @@ public:
   const Double_t*  GetMCPdr() const {return fMCPdr;}
   const Double_t*  GetMCPd()  const {return fMCPd;}
   const Double_t*  GetMCX()  const {return fMCX;}
-  //  const Double_t    fMCXr;
-  //
-//   Double_t     fMCPm[3];    
-//   Double_t     fMCAngle[3]; 
-//   Double_t     fMCRr;       
-//   Double_t     fMCR;       
-//   Int_t        fPdg[2];   
-//   Int_t        fLab[2];   
-//   //
-//   Double_t       fInvMass;  
-//   Float_t        fPointAngleFi;
-//   Float_t        fPointAngleTh;
-//   Float_t        fPointAngle;  
-
   void SetInfoP(AliMCInfo &plus) {fMCd=plus;}
   void SetInfoM(AliMCInfo &minus){fMCm=minus;}
   void SetMother(TParticle&mother){fMotherP=mother;}
index d8971ae..1f055ce 100644 (file)
@@ -75,6 +75,7 @@ AliMCInfo::AliMCInfo():
   fRowsWithDigitsInn(0),
   fRowsWithDigits(0),
   fRowsTrackLength(0),
+  fTPCtrackLength(-1),
   fPrim(0),
   fTPCRow(), 
   fNTPCRef(0),                    // tpc references counter
@@ -114,6 +115,7 @@ AliMCInfo::AliMCInfo(const AliMCInfo& info):
   fRowsWithDigitsInn(info.fRowsWithDigitsInn),
   fRowsWithDigits(info.fRowsWithDigits),
   fRowsTrackLength(info.fRowsTrackLength),
+  fTPCtrackLength(info.fTPCtrackLength),
   fPrim(info.fPrim),
   fTPCRow(info.fTPCRow), 
   fNTPCRef(info.fNTPCRef),                    // tpc references counter
@@ -165,29 +167,6 @@ void AliMCInfo::Update()
   //
   //
   fMCtracks =1;
-  if (!fTPCReferences) {
-    fNTPCRef =0;
-    return;
-  }
-  Float_t direction=1;
-  //Float_t rlast=0;
-  fNTPCRef = fTPCReferences->GetEntriesFast();
-  fNITSRef = fITSReferences->GetEntriesFast();
-  fNTRDRef = fTRDReferences->GetEntriesFast();
-  fNTOFRef = fTOFReferences->GetEntriesFast();
-  
-  for (Int_t iref =0;iref<fTPCReferences->GetEntriesFast();iref++){
-    AliTrackReference * ref = (AliTrackReference *) fTPCReferences->At(iref);
-    //Float_t r = (ref->X()*ref->X()+ref->Y()*ref->Y());
-    Float_t newdirection = ref->X()*ref->Px()+ref->Y()*ref->Py(); //inside or outside
-    if (iref==0) direction = newdirection;
-    if ( newdirection*direction<0){
-      //changed direction
-      direction = newdirection;
-      fMCtracks+=1;
-    }
-    //rlast=r;                     
-  }
   //
   // decay info
   fTPCdecay=kFALSE;
@@ -353,3 +332,56 @@ Float_t AliMCInfo::TPCBetheBloch(Float_t bg)
   return ((Float_t)((kp2-aa-bb)*kp1/aa));
 }
 
+
+void AliMCInfo::CalcTPCrows(TClonesArray * runArrayTR){
+  //
+  // Calculates the numebr of the track references for detectors
+  // In case of changing direction - curling tracks - the counter is not increasing
+  //
+  // Rough calculation 
+  // of the first and last point in the TPC  
+  //
+  fNTPCRef = 0;
+  fNITSRef = 0;
+  fNTRDRef = 0;
+  fNTOFRef = 0;  
+  Float_t tpcminRadius=250;
+  Float_t tpcmaxRadius=80;
+  Float_t dir=0;
+  Int_t nover=0;
+  
+  for (Int_t iTrackRef = 0; iTrackRef < runArrayTR->GetEntriesFast(); iTrackRef++) {
+    //
+    AliTrackReference *ref = (AliTrackReference*)runArrayTR->At(iTrackRef);  
+    Float_t newdirection = (ref->X()*ref->Px()+ref->Y()*ref->Py()>0)? 1.:-1.; //inside or outside
+    if (dir*newdirection<0.5) {
+      nover++;
+      dir = newdirection;
+    }
+    //
+    if (ref->DetectorId()== AliTrackReference::kTRD){
+      tpcmaxRadius =250;
+      fNTRDRef++;
+    }
+    if (ref->DetectorId()== AliTrackReference::kITS){
+      fNITSRef++;
+      tpcminRadius =90;
+    }
+    if (ref->DetectorId()== AliTrackReference::kITS){
+      fNTOFRef++;
+      tpcmaxRadius =250;
+    }
+    //
+    if (ref->DetectorId()== AliTrackReference::kTPC){
+      fNTPCRef++;
+      if (ref->R()>tpcmaxRadius) tpcmaxRadius = ref->R();
+      if (ref->R()<tpcminRadius) tpcminRadius = ref->R();
+    }
+    if (ref->DetectorId()== AliTrackReference::kDisappeared){
+      if (TMath::Abs(ref->Z())<250 && TMath::Abs(ref->R()<250))
+       tpcmaxRadius = ref->R();
+    }
+  }
+  fTPCtrackLength = tpcmaxRadius-tpcminRadius;
+  fMCtracks=nover;
+}
index 0e7ef40..27c2f7d 100644 (file)
@@ -93,6 +93,7 @@ public:
   const TClonesArray * GetTRDReferences() const { return fTRDReferences;}  
   const TClonesArray * GetITSReferences() const { return fITSReferences;}  
   const TClonesArray * GetTOFReferences() const { return fTOFReferences;}  
+  void CalcTPCrows(TClonesArray *arrayTR);
 private:
   AliTrackReference  fTrackRef;      // track reference saved in the output tree
   AliTrackReference  fTrackRefOut;   // decay track reference saved in the output tree
@@ -109,9 +110,15 @@ private:
   Float_t fDecayCoord[3];            // position of particle decay
   Double_t fVDist[4];                //distance of the particle vertex from primary vertex
   Bool_t fTPCdecay;                  //indicates decay in TPC
+  //
+  // TPC row information using digits
   Int_t fRowsWithDigitsInn;          // number of rows with digits in the inner sectors
   Int_t fRowsWithDigits;             // number of rows with digits in the outer sectors
   Int_t fRowsTrackLength;            // last - first row with digit
+  //
+  // TPC track refernce information
+  Float_t fTPCtrackLength;           // distance between first and last track reference
+  //
   Float_t fPrim;                     // theoretical dedx in tpc according particle momenta and mass
   AliTPCdigitRow fTPCRow;                  // information about digits row pattern
   Int_t fNTPCRef;                    // tpc references counter
index e08d028..609c515 100644 (file)
@@ -141,6 +141,7 @@ TProfile prof("prof","prof",10,0.5,5);
 #include "TTree.h"
 #include "TStopwatch.h"
 #include "TVector3.h"
+#include "TGeoManager.h"
 //#include "Getline.h"
 //
 //ALIROOT includes
@@ -274,6 +275,8 @@ AliRecInfoMaker::AliRecInfoMaker(const char* fnGenTracks,
   }
   AliMagF * magf = gAlice->Field();
   AliTracker::SetFieldMap(magf,0);
+  TGeoManager::Import("geometry.root");
+
 
 }
 
@@ -422,7 +425,7 @@ Int_t AliRecInfoMaker::Exec()
 
     if (fDebug>2) cout<<"\tStart loop over tree genTracks"<<endl;
     if (TreeGenLoop(eventNr)>0) return 1;
-    BuildKinkInfo0(eventNr);
+    //BuildKinkInfo0(eventNr);
     //BuildV0Info(eventNr); // no V0 info for a moment
     fRecArray->Delete();
 
@@ -700,7 +703,8 @@ Int_t AliRecInfoMaker::TreeGenLoop(Int_t eventNr)
     fTreeGenTracks->GetEntry(entry);
     entry++;
     if (eventNr < fMCInfo->fEventNr) continue;
-    if (eventNr > fMCInfo->fEventNr) continue;;
+    if (eventNr > fMCInfo->fEventNr) continue;
+    if (fMCInfo->GetCharge()==0) continue;
     //
     fNextTreeGenEntryToRead = entry-1;
     if (fDebug > 2 && fMCInfo->fLabel < 10) {
index 9a5de5f..dc30eda 100644 (file)
@@ -18,5 +18,6 @@
 //
 #pragma link C++ class AliRecInfoMaker+;
 #pragma link C++ class AliComparisonDraw+;
+#pragma link C++ class AliGenInfoTask+;
 
 #endif
index 5a90c38..aaa9fdb 100644 (file)
@@ -12,7 +12,7 @@ t->Exec();
 
 1. Build the reconstructed info tree
 
-
+gSystem->Load("libANALYSIS.so");
 gSystem->Load("libPWG1.so");
 //
 AliRecInfoMaker *t2 = new AliRecInfoMaker("genTracks.root","cmpESDTracks.root","galice.root",0,0);
@@ -21,14 +21,17 @@ t2->Exec();
 
 
 2. Make a chain of the information tree
+gSystem->Load("libANALYSIS.so");
 
 gSystem->Load("libPWG1.so");
 
 //GSI example
 .x ~/rootlogon.C
-.L /u/miranov/macroxrdproof64/AliXRDPROOFtoolkit.cxx+
+ gSystem->AddIncludePath("-I$ALICE_ROOT/TPC/macros")
+  gROOT->LoadMacro("$ALICE_ROOT/TPC/macros/AliXRDPROOFtoolkit.cxx+")
+
  AliXRDPROOFtoolkit tool;
- TChain * chain = tool.MakeChain("pp.txt","ESDcmpTracks",0,1000)
+ TChain * chain = tool.MakeChain("cmp.txt","ESDcmpTracks",0,1000)
  chain->Lookup();
  .L $ALICE_ROOT/PWG1/AliComparisonSelector.cxx+
 
index eddd91a..d92cd49 100644 (file)
@@ -8,10 +8,11 @@ SRCS:=        AliTreeDraw.cxx \
        AliESDRecV0Info.cxx \
        AliESDRecKinkInfo.cxx \
        AliRecInfoMaker.cxx \
-       AliComparisonDraw.cxx
+       AliComparisonDraw.cxx \
+       AliGenInfoTask.cxx
  
 HDRS:= $(SRCS:.cxx=.h)
 
 DHDR:= PWG1LinkDef.h
 
-EINCLUDE:= STEER TPC ITS TRD
+EINCLUDE:= STEER TPC ITS TRD ANALYSIS