[u/mrichter/AliRoot.git] / PWGUD / UPC / AliAnalysisTaskUpcTree.cxx

/*************************************************************************
* Copyright(c) 1998-2008, 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.                  * 
**************************************************************************/

// Task to create upc tree
// evgeny.kryshen@cern.ch

#include "AliAnalysisTaskUpcTree.h"
#include "AliAnalysisTaskSE.h"
#include "TChain.h"
#include "AliVEvent.h"
#include "AliAODEvent.h"
#include "AliESDEvent.h"
#include "AliVHeader.h"
#include "AliMultiplicity.h"
#include "AliESDEvent.h"
#include "AliESDHeader.h"
#include "AliESDMuonTrack.h"
#include "AliESDtrack.h"
#include "TTree.h"
#include "TList.h"
#include "TFile.h"
#include "TObjString.h"
#include "TH1I.h"
#include "TLorentzVector.h"
#include "AliAnalysisManager.h"
#include "AliInputEventHandler.h"
#include "AliUpcParticle.h"
#include "AliAnalysisFilter.h"
#include "AliESDtrackCuts.h"
#include "AliMuonTrackCuts.h"
#include "AliTriggerIR.h"
ClassImp(AliAnalysisTaskUpcTree)

//-----------------------------------------------------------------------------
AliAnalysisTaskUpcTree::AliAnalysisTaskUpcTree(const char* name) :
  AliAnalysisTaskSE(name),
  fIsMC(0),
  fIsAOD(0),
  fMuonTrackCuts(new AliMuonTrackCuts),
  fTrackFilter(NULL),
  fListOfHistos(NULL),
  fEventStatistics(NULL),
  fTriggersPerRun(NULL),
  fTree(NULL),
  fTPCtracks(NULL),
  fMUONtracks(NULL),
  fChunkFileName(new TObjString()),
  fEventInFile(-1),
  fPeriod(-1),
  fOrbit(-1),
  fBC(-1),
  fL0inputs(0),
  fL1inputs(0),
  fRunNumber(0),
  fNofTracklets(0),
  fBBonlineV0A(kFALSE),
  fBGonlineV0A(kFALSE),
  fBBonlineV0C(kFALSE),
  fBGonlineV0C(kFALSE),
  fV0ADecision(kFALSE),
  fV0CDecision(kFALSE),
  fZNAtdc(kFALSE),
  fZNCtdc(kFALSE),
  fZPAtdc(kFALSE),
  fZPCtdc(kFALSE),
  fZEM1tdc(kFALSE),
  fZEM2tdc(kFALSE),
  fZNAenergy(-1000),
  fZNCenergy(-1000),
  fZPAenergy(-1000),
  fZPCenergy(-1000),
  fZEM1energy(-1000),
  fZEM2energy(-1000),
  fZNAtower0(-1000),
  fZNCtower0(-1000),
  fZPAtower0(-1000),
  fZPCtower0(-1000),
  fVtxX(-1000),
  fVtxY(-1000),
  fVtxZ(-1000),
  fVtxTPC(kFALSE),
  fIR1(),
  fIR2(),
  fFOmap(),
  fFiredChipMap()
{
  fMuonTrackCuts->SetPassName("muon_pass2");
  fMuonTrackCuts->SetAllowDefaultParams(kTRUE);
  fMuonTrackCuts->SetFilterMask(AliMuonTrackCuts::kMuPdca);

  for (Int_t i=0;i<NTRIGGERS;i++) fTriggerFired[i]=0;
  for (Int_t i=0;i<32;i++) {
    fV0AMult[i]=0;
    fV0CMult[i]=0;
    fV0ATime[i]=0;
    fV0CTime[i]=0;
    fBBTriggerV0A[i]=0;
    fBGTriggerV0A[i]=0;
    fBBTriggerV0C[i]=0;
    fBGTriggerV0C[i]=0;
  }
  for (Int_t i=0;i<64;i++) {
    fBBFlag[i]=0;
    fBGFlag[i]=0;
  }
  DefineInput(0,TChain::Class());
  DefineOutput(1,TList::Class());
  DefineOutput(2,TTree::Class());
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
void AliAnalysisTaskUpcTree::NotifyRun(){
  if (fMuonTrackCuts) fMuonTrackCuts->SetRun(fInputHandler); 
  fInputHandler->SetNeedField();
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
void AliAnalysisTaskUpcTree::UserCreateOutputObjects(){
  fListOfHistos = new TList();
  fListOfHistos->SetOwner();
  fEventStatistics = new TH1I("fEventStatistics","",10,0,10);
  fEventStatistics->SetBit(TH1::kCanRebin);
  fListOfHistos->Add(fEventStatistics);

  fTriggersPerRun = new TH2I("fTriggersPerRun",";;Events",2000,195600,197600,NTRIGGERS,-0.5,NTRIGGERS+0.5);
  fListOfHistos->Add(fTriggersPerRun);
  
  TDirectory *owd = gDirectory;
  OpenFile(1);
  fTree = new TTree("events","events");
  owd->cd();
  fTPCtracks = new TClonesArray("AliUpcParticle",100);
  fMUONtracks = new TClonesArray("AliUpcParticle",10);
  fTree->Branch("fTriggerFired",&fTriggerFired,Form("fTriggerFired[%i]/O",NTRIGGERS));
  fTree->Branch("fChunkFileName",&fChunkFileName);
  fTree->Branch("fEventInFile",&fEventInFile);
  fTree->Branch("fPeriod",&fPeriod);
  fTree->Branch("fOrbit",&fOrbit);
  fTree->Branch("fBC",&fBC);
  fTree->Branch("fRunNumber",&fRunNumber);
  fTree->Branch("fNofTracklets",&fNofTracklets);
  fTree->Branch("fV0AMult",&fV0AMult,"fV0AMult[32]/F");
  fTree->Branch("fV0CMult",&fV0CMult,"fV0CMult[32]/F");
  fTree->Branch("fV0ATime",&fV0ATime,"fV0ATime[32]/F");
  fTree->Branch("fV0CTime",&fV0CTime,"fV0CTime[32]/F");
  fTree->Branch("fBBFlag",&fBBFlag,"fBBFlag[64]/O");
  fTree->Branch("fBGFlag",&fBGFlag,"fBGFlag[64]/O");
  fTree->Branch("fBBTriggerV0A",&fBBTriggerV0A,"fBBTriggerV0A[32]/O");
  fTree->Branch("fBGTriggerV0A",&fBGTriggerV0A,"fBGTriggerV0A[32]/O");
  fTree->Branch("fBBTriggerV0C",&fBBTriggerV0C,"fBBTriggerV0C[32]/O");
  fTree->Branch("fBGTriggerV0C",&fBGTriggerV0C,"fBGTriggerV0C[32]/O");
  fTree->Branch("fBBonlineV0A",&fBBonlineV0A);
  fTree->Branch("fBGonlineV0A",&fBGonlineV0A);
  fTree->Branch("fBBonlineV0C",&fBBonlineV0C);
  fTree->Branch("fBGonlineV0C",&fBGonlineV0C);
  fTree->Branch("fV0ADecision",&fV0ADecision);
  fTree->Branch("fV0CDecision",&fV0CDecision);
  fTree->Branch("fZNAtdc",&fZNAtdc);
  fTree->Branch("fZNCtdc",&fZNCtdc);
  fTree->Branch("fZPAtdc",&fZPAtdc);
  fTree->Branch("fZPCtdc",&fZPCtdc);
  fTree->Branch("fZEM1tdc",&fZEM1tdc);
  fTree->Branch("fZEM2tdc",&fZEM2tdc);
  fTree->Branch("fZPAenergy",&fZPAenergy);
  fTree->Branch("fZPCenergy",&fZPCenergy);
  fTree->Branch("fZNAenergy",&fZNAenergy);
  fTree->Branch("fZNCenergy",&fZNCenergy);
  fTree->Branch("fZEM1energy",&fZEM1energy);
  fTree->Branch("fZEM2energy",&fZEM2energy);
  fTree->Branch("fZNAtower0",&fZNAtower0);
  fTree->Branch("fZNCtower0",&fZNCtower0);
  fTree->Branch("fZPAtower0",&fZPAtower0);
  fTree->Branch("fZPCtower0",&fZPCtower0);
  fTree->Branch("fVtxX",&fVtxX);
  fTree->Branch("fVtxY",&fVtxY);
  fTree->Branch("fVtxZ",&fVtxZ);
  fTree->Branch("fVtxTPC",&fVtxTPC);
  fTree->Branch("fTPCtracks",&fTPCtracks);
  fTree->Branch("fMUONtracks",&fMUONtracks);
  fTree->Branch("fNofITSClusters",&fNofITSClusters,"fNofITSClusters[6]/I");
  fTree->Branch("fIR1",&fIR1);
  fTree->Branch("fIR2",&fIR2);
  fTree->Branch("fL0inputs",&fL0inputs);
  fTree->Branch("fL1inputs",&fL1inputs);
  fTree->Branch("fFOmap",&fFOmap);
  fTree->Branch("fFiredChipMap",&fFiredChipMap);

  PostData(1,fListOfHistos);
  PostData(2,fTree);
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
void AliAnalysisTaskUpcTree::UserExec(Option_t *){
  fMUONtracks->Clear();
  fTPCtracks->Clear();
  fEventStatistics->Fill("before cuts",1);
  
  TString trigger = fInputEvent->GetFiredTriggerClasses();

  for (Int_t i=0;i<NTRIGGERS;i++) fTriggerFired[i]=0;
  fTriggerFired[ 0] = 1;
  fTriggerFired[ 1] = trigger.Contains("CCUP7-B");
  fTriggerFired[ 2] = trigger.Contains("CMUP5-B");
  fTriggerFired[ 3] = trigger.Contains("CMUP7-B");
  fTriggerFired[ 4] = trigger.Contains("CMUP9-B");
  fTriggerFired[ 5] = trigger.Contains("CMSL7-B-NOPF-MUON");
  fTriggerFired[ 6] = trigger.Contains("CMSL7-B-NOPF-ALLNOTRD");

  fRunNumber  = fInputEvent->GetRunNumber();
  Bool_t isTrigger=0;
  for (Int_t i=0;i<NTRIGGERS;i++){
    if (!fTriggerFired[i]) continue;
    fTriggersPerRun->Fill(fRunNumber,i);
    if (!i) continue;
    isTrigger=1;
  }
  if (!isTrigger && !fIsMC) { PostData(1,fListOfHistos); return; }
  fEventStatistics->Fill("after trigger check",1);


  if (fNofTracklets>1 && fTriggerFired[5]) { PostData(1,fListOfHistos); return; }
  if (fNofTracklets>1 && fTriggerFired[6]) { PostData(1,fListOfHistos); return; }
  
  fEventStatistics->Fill("after tracklet check",1);

  fPeriod       = fInputEvent->GetPeriodNumber();
  fOrbit        = fInputEvent->GetOrbitNumber();
  fBC           = fInputEvent->GetBunchCrossNumber();
  fL0inputs     = fInputEvent->GetHeader()->GetL0TriggerInputs();
  fL1inputs     = fInputEvent->GetHeader()->GetL1TriggerInputs();
  fIR1          = fInputEvent->GetHeader()->GetIRInt1InteractionMap();
  fIR2          = fInputEvent->GetHeader()->GetIRInt2InteractionMap();
  fNofTracklets = fInputEvent->GetMultiplicity()->GetNumberOfTracklets();
  
  for (Int_t i=0;i<6;i++) fNofITSClusters[i] = fInputEvent->GetNumberOfITSClusters(i);
  
  AliVVZERO* vzero = fInputEvent->GetVZEROData();
  for (Int_t i=0; i<32; i++){
    fV0AMult[i] = vzero->GetMultiplicityV0A(i);
    fV0CMult[i] = vzero->GetMultiplicityV0C(i);
    fV0ATime[i] = vzero->GetV0ATime();
    fV0CTime[i] = vzero->GetV0CTime();
    fBBTriggerV0A[i] = vzero->BBTriggerV0A(i);
    fBGTriggerV0A[i] = vzero->BGTriggerV0A(i);
    fBBTriggerV0C[i] = vzero->BBTriggerV0C(i);
    fBGTriggerV0C[i] = vzero->BGTriggerV0C(i);
  }

  fBBonlineV0A = kFALSE;
  fBGonlineV0A = kFALSE;
  fBBonlineV0C = kFALSE;
  fBGonlineV0C = kFALSE;
  for (Int_t i=0; i<64; i++){
    fBBFlag[i] = vzero->GetBBFlag(i);
    fBGFlag[i] = vzero->GetBGFlag(i);
    if (fBBFlag[i] && i>=32) fBBonlineV0A = kTRUE;
    if (fBGFlag[i] && i>=32) fBGonlineV0A = kTRUE;
    if (fBBFlag[i] && i <32) fBBonlineV0C = kTRUE;
    if (fBGFlag[i] && i <32) fBGonlineV0C = kTRUE;
  }
  
  fV0ADecision = vzero->GetV0ADecision();
  fV0CDecision = vzero->GetV0CDecision();

  // ZDC data
  AliVZDC* zdc = fInputEvent->GetZDCData();
  fZNAenergy  = zdc->GetZNAEnergy();
  fZNCenergy  = zdc->GetZNCEnergy();
  fZPAenergy  = zdc->GetZPAEnergy();
  fZPCenergy  = zdc->GetZPCEnergy();
  fZEM1energy = zdc->GetZEM1Energy();
  fZEM2energy = zdc->GetZEM2Energy();
  fZNAtower0  = zdc->GetZNATowerEnergy()[0];
  fZNCtower0  = zdc->GetZNCTowerEnergy()[0];
  fZPAtower0  = zdc->GetZPATowerEnergy()[0];
  fZPCtower0  = zdc->GetZPCTowerEnergy()[0];
  // ZDC timing
  fZEM1tdc = kFALSE;
  fZEM2tdc = kFALSE;
  fZNCtdc  = kFALSE;
  fZPCtdc  = kFALSE;
  fZNAtdc  = kFALSE;
  fZPAtdc  = kFALSE;
  if (!fIsAOD) {
    AliESDZDC* esdzdc = (AliESDZDC*) zdc;
    for(Int_t i=0;i<4;i++) {
      if (esdzdc->GetZDCTDCData( 8,i)) fZEM1tdc = kTRUE;
      if (esdzdc->GetZDCTDCData( 9,i)) fZEM2tdc = kTRUE;
      if (esdzdc->GetZDCTDCData(10,i)) fZNCtdc  = kTRUE;
      if (esdzdc->GetZDCTDCData(11,i)) fZPCtdc  = kTRUE;
      if (esdzdc->GetZDCTDCData(12,i)) fZNAtdc  = kTRUE;
      if (esdzdc->GetZDCTDCData(13,i)) fZPAtdc  = kTRUE;
    }
  }

  const AliVVertex* vertex  = fInputEvent->GetPrimaryVertex();
  fVtxX   = vertex->GetX();
  fVtxY   = vertex->GetY();
  fVtxZ   = vertex->GetZ();
  fVtxTPC = TString(vertex->GetName()).CompareTo("PrimaryVertex") && TString(vertex->GetName()).CompareTo("SPDVertex");
  
  AliESDEvent* esd = !fIsAOD ? (AliESDEvent*) fInputEvent : 0;
//  AliAODEvent* aod =  fIsAOD ? (AliAODEvent*) fInputEvent : 0;

  if (!esd) return; // AOD not yet implemented
  
  fEventInFile = esd->GetHeader()->GetEventNumberInFile();
  fChunkFileName->SetString(((TTree*) GetInputData(0))->GetCurrentFile()->GetName());
  
  fFOmap = esd->GetMultiplicity()->GetFastOrFiredChips();
  fFiredChipMap = esd->GetMultiplicity()->GetFiredChipMap();
  
  for (Int_t itr=0;itr<esd->GetNumberOfTracks();itr++){
    AliESDtrack* track = (AliESDtrack*) esd->GetTrack(itr);
    Float_t pt   = track->Pt();
    Float_t eta  = track->Eta();
    Float_t phi  = track->Phi();
    Short_t charge = track->Charge();
    UInt_t mask = 0;//track->GetFilterMap();
    
    if (!fTrackFilter) AliFatal("Track filter undefined");
    mask |= fTrackFilter->IsSelected(track);

    if (!mask) continue;
    UInt_t itsClusterMap      = track->GetITSClusterMap();
    Bool_t itsRefit           = track->GetStatus() & AliVTrack::kITSrefit;
    Bool_t tpcRefit           = track->GetStatus() & AliVTrack::kTPCrefit;
    Bool_t kink               = track->GetKinkIndex(0)>0;
    mask |= itsRefit      << 20;
    mask |= tpcRefit      << 21;
    mask |= kink          << 22;
    mask |= itsClusterMap << 23;
    
    AliUpcParticle* part = new ((*fTPCtracks)[fTPCtracks->GetEntriesFast()]) AliUpcParticle(pt,eta,phi,charge,mask,10);
    Float_t dedx              = track->GetTPCsignal();
    Float_t nCrossedRaws      = track->GetTPCCrossedRows();
    Float_t nFindableClusters = track->GetTPCNclsF();
    Float_t nSharedClusters   = track->GetTPCnclsS();
    Float_t nClusters         = track->GetTPCncls();
    Float_t chi2tpc           = track->GetTPCchi2();
    Float_t chi2its           = track->GetITSchi2();
    Float_t chi2golden        = 0;//vertex ? track->GetChi2TPCConstrainedVsGlobal(vertex) : 0;
    Float_t bxy,bz; 
    track->GetImpactParameters(bxy,bz);
    part->SetAt(dedx,0);
    part->SetAt(nCrossedRaws,1);
    part->SetAt(nFindableClusters,2);
    part->SetAt(nSharedClusters,3);
    part->SetAt(nClusters,4);
    part->SetAt(chi2tpc,5);
    part->SetAt(chi2its,6);
    part->SetAt(chi2golden,7);
    part->SetAt(bxy,8);
    part->SetAt(bz,9);
  }
  
  for (Int_t itr=0;itr<esd->GetNumberOfMuonTracks();itr++){
    AliESDMuonTrack* track = esd->GetMuonTrack(itr);
    if (!track->ContainTrackerData()) continue;
    Float_t pt     = track->Pt();
    Float_t eta    = track->Eta();
    Float_t phi    = track->Phi();
    Short_t charge = track->Charge();
    UInt_t mask    = fMuonTrackCuts->IsSelected(track);
    Float_t dca    = track->GetDCA();
    Float_t chi2   = track->GetChi2();
    Float_t ndf    = track->GetNDF();
    Float_t rabs   = track->GetRAtAbsorberEnd();
    Float_t match  = track->GetMatchTrigger();
    AliUpcParticle* part = new ((*fMUONtracks)[fMUONtracks->GetEntriesFast()]) AliUpcParticle(pt,eta,phi,charge,mask,5);
    part->SetAt(dca,0);
    part->SetAt(chi2,1);
    part->SetAt(ndf,2);
    part->SetAt(rabs,3);
    part->SetAt(match,4);
  }
  
  fTree->Fill();
  PostData(1,fListOfHistos);
  PostData(2,fTree);
}
//-----------------------------------------------------------------------------
Commit	Line	Data
cb89681c	1	/*************************************************************************
	2	* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	// Task to create upc tree
	17	// evgeny.kryshen@cern.ch
	18
	19	#include "AliAnalysisTaskUpcTree.h"
	20	#include "AliAnalysisTaskSE.h"
	21	#include "TChain.h"
	22	#include "AliVEvent.h"
	23	#include "AliAODEvent.h"
	24	#include "AliESDEvent.h"
	25	#include "AliVHeader.h"
	26	#include "AliMultiplicity.h"
	27	#include "AliESDEvent.h"
	28	#include "AliESDHeader.h"
	29	#include "AliESDMuonTrack.h"
	30	#include "AliESDtrack.h"
	31	#include "TTree.h"
	32	#include "TList.h"
	33	#include "TFile.h"
	34	#include "TObjString.h"
	35	#include "TH1I.h"
	36	#include "TLorentzVector.h"
	37	#include "AliAnalysisManager.h"
	38	#include "AliInputEventHandler.h"
	39	#include "AliUpcParticle.h"
	40	#include "AliAnalysisFilter.h"
	41	#include "AliESDtrackCuts.h"
	42	#include "AliMuonTrackCuts.h"
	43	#include "AliTriggerIR.h"
	44	ClassImp(AliAnalysisTaskUpcTree)
	45
	46	//-----------------------------------------------------------------------------
	47	AliAnalysisTaskUpcTree::AliAnalysisTaskUpcTree(const char* name) :
	48	AliAnalysisTaskSE(name),
	49	fIsMC(0),
	50	fIsAOD(0),
	51	fMuonTrackCuts(new AliMuonTrackCuts),
	52	fTrackFilter(NULL),
	53	fListOfHistos(NULL),
	54	fEventStatistics(NULL),
	55	fTriggersPerRun(NULL),
	56	fTree(NULL),
	57	fTPCtracks(NULL),
	58	fMUONtracks(NULL),
	59	fChunkFileName(new TObjString()),
	60	fEventInFile(-1),
	61	fPeriod(-1),
	62	fOrbit(-1),
	63	fBC(-1),
	64	fL0inputs(0),
65	fL1inputs(0),
66	fRunNumber(0),
67	fNofTracklets(0),
68	fBBonlineV0A(kFALSE),
69	fBGonlineV0A(kFALSE),
70	fBBonlineV0C(kFALSE),
71	fBGonlineV0C(kFALSE),
72	fV0ADecision(kFALSE),
73	fV0CDecision(kFALSE),
74	fZNAtdc(kFALSE),
75	fZNCtdc(kFALSE),
76	fZPAtdc(kFALSE),
77	fZPCtdc(kFALSE),
78	fZEM1tdc(kFALSE),
79	fZEM2tdc(kFALSE),
80	fZNAenergy(-1000),
81	fZNCenergy(-1000),
82	fZPAenergy(-1000),
83	fZPCenergy(-1000),
84	fZEM1energy(-1000),
85	fZEM2energy(-1000),
86	fZNAtower0(-1000),
87	fZNCtower0(-1000),
88	fZPAtower0(-1000),
89	fZPCtower0(-1000),
90	fVtxX(-1000),
91	fVtxY(-1000),
92	fVtxZ(-1000),
93	fVtxTPC(kFALSE),
94	fIR1(),
95	fIR2(),
96	fFOmap(),
97	fFiredChipMap()
98	{
99	fMuonTrackCuts->SetPassName("muon_pass2");
100	fMuonTrackCuts->SetAllowDefaultParams(kTRUE);
101	fMuonTrackCuts->SetFilterMask(AliMuonTrackCuts::kMuPdca);
102
103	for (Int_t i=0;i<NTRIGGERS;i++) fTriggerFired[i]=0;
104	for (Int_t i=0;i<32;i++) {
105	fV0AMult[i]=0;
106	fV0CMult[i]=0;
107	fV0ATime[i]=0;
108	fV0CTime[i]=0;
109	fBBTriggerV0A[i]=0;
110	fBGTriggerV0A[i]=0;
111	fBBTriggerV0C[i]=0;
112	fBGTriggerV0C[i]=0;
113	}
114	for (Int_t i=0;i<64;i++) {
115	fBBFlag[i]=0;
116	fBGFlag[i]=0;
117	}
118	DefineInput(0,TChain::Class());
119	DefineOutput(1,TList::Class());
120	DefineOutput(2,TTree::Class());
121	}
122	//-----------------------------------------------------------------------------
123
124
125	//-----------------------------------------------------------------------------
126	void AliAnalysisTaskUpcTree::NotifyRun(){
127	if (fMuonTrackCuts) fMuonTrackCuts->SetRun(fInputHandler);
128	fInputHandler->SetNeedField();
129	}
130	//-----------------------------------------------------------------------------
131
132
133	//-----------------------------------------------------------------------------
134	void AliAnalysisTaskUpcTree::UserCreateOutputObjects(){
135	fListOfHistos = new TList();
136	fListOfHistos->SetOwner();
137	fEventStatistics = new TH1I("fEventStatistics","",10,0,10);
138	fEventStatistics->SetBit(TH1::kCanRebin);
139	fListOfHistos->Add(fEventStatistics);
140
141	fTriggersPerRun = new TH2I("fTriggersPerRun",";;Events",2000,195600,197600,NTRIGGERS,-0.5,NTRIGGERS+0.5);
142	fListOfHistos->Add(fTriggersPerRun);
143
144	TDirectory *owd = gDirectory;
145	OpenFile(1);
146	fTree = new TTree("events","events");
147	owd->cd();
148	fTPCtracks = new TClonesArray("AliUpcParticle",100);
149	fMUONtracks = new TClonesArray("AliUpcParticle",10);
150	fTree->Branch("fTriggerFired",&fTriggerFired,Form("fTriggerFired[%i]/O",NTRIGGERS));
151	fTree->Branch("fChunkFileName",&fChunkFileName);
152	fTree->Branch("fEventInFile",&fEventInFile);
153	fTree->Branch("fPeriod",&fPeriod);
154	fTree->Branch("fOrbit",&fOrbit);
155	fTree->Branch("fBC",&fBC);
156	fTree->Branch("fRunNumber",&fRunNumber);
157	fTree->Branch("fNofTracklets",&fNofTracklets);
158	fTree->Branch("fV0AMult",&fV0AMult,"fV0AMult[32]/F");
159	fTree->Branch("fV0CMult",&fV0CMult,"fV0CMult[32]/F");
160	fTree->Branch("fV0ATime",&fV0ATime,"fV0ATime[32]/F");
161	fTree->Branch("fV0CTime",&fV0CTime,"fV0CTime[32]/F");
162	fTree->Branch("fBBFlag",&fBBFlag,"fBBFlag[64]/O");
163	fTree->Branch("fBGFlag",&fBGFlag,"fBGFlag[64]/O");
164	fTree->Branch("fBBTriggerV0A",&fBBTriggerV0A,"fBBTriggerV0A[32]/O");
165	fTree->Branch("fBGTriggerV0A",&fBGTriggerV0A,"fBGTriggerV0A[32]/O");
166	fTree->Branch("fBBTriggerV0C",&fBBTriggerV0C,"fBBTriggerV0C[32]/O");
167	fTree->Branch("fBGTriggerV0C",&fBGTriggerV0C,"fBGTriggerV0C[32]/O");
168	fTree->Branch("fBBonlineV0A",&fBBonlineV0A);
169	fTree->Branch("fBGonlineV0A",&fBGonlineV0A);
170	fTree->Branch("fBBonlineV0C",&fBBonlineV0C);
171	fTree->Branch("fBGonlineV0C",&fBGonlineV0C);
172	fTree->Branch("fV0ADecision",&fV0ADecision);
173	fTree->Branch("fV0CDecision",&fV0CDecision);
174	fTree->Branch("fZNAtdc",&fZNAtdc);
175	fTree->Branch("fZNCtdc",&fZNCtdc);
176	fTree->Branch("fZPAtdc",&fZPAtdc);
177	fTree->Branch("fZPCtdc",&fZPCtdc);
178	fTree->Branch("fZEM1tdc",&fZEM1tdc);
179	fTree->Branch("fZEM2tdc",&fZEM2tdc);
180	fTree->Branch("fZPAenergy",&fZPAenergy);
181	fTree->Branch("fZPCenergy",&fZPCenergy);
182	fTree->Branch("fZNAenergy",&fZNAenergy);
183	fTree->Branch("fZNCenergy",&fZNCenergy);
184	fTree->Branch("fZEM1energy",&fZEM1energy);
185	fTree->Branch("fZEM2energy",&fZEM2energy);
186	fTree->Branch("fZNAtower0",&fZNAtower0);
187	fTree->Branch("fZNCtower0",&fZNCtower0);
188	fTree->Branch("fZPAtower0",&fZPAtower0);
189	fTree->Branch("fZPCtower0",&fZPCtower0);
190	fTree->Branch("fVtxX",&fVtxX);
191	fTree->Branch("fVtxY",&fVtxY);
192	fTree->Branch("fVtxZ",&fVtxZ);
193	fTree->Branch("fVtxTPC",&fVtxTPC);
194	fTree->Branch("fTPCtracks",&fTPCtracks);
195	fTree->Branch("fMUONtracks",&fMUONtracks);
196	fTree->Branch("fNofITSClusters",&fNofITSClusters,"fNofITSClusters[6]/I");
197	fTree->Branch("fIR1",&fIR1);
198	fTree->Branch("fIR2",&fIR2);
199	fTree->Branch("fL0inputs",&fL0inputs);
200	fTree->Branch("fL1inputs",&fL1inputs);
201	fTree->Branch("fFOmap",&fFOmap);
202	fTree->Branch("fFiredChipMap",&fFiredChipMap);
203
204	PostData(1,fListOfHistos);
205	PostData(2,fTree);
206	}
207	//-----------------------------------------------------------------------------
208
209
210	//-----------------------------------------------------------------------------
211	void AliAnalysisTaskUpcTree::UserExec(Option_t *){
212	fMUONtracks->Clear();
213	fTPCtracks->Clear();
214	fEventStatistics->Fill("before cuts",1);
cb89681c	215
ea411d1a	216	TString trigger = fInputEvent->GetFiredTriggerClasses();
cb89681c	217
	218	for (Int_t i=0;i<NTRIGGERS;i++) fTriggerFired[i]=0;
	219	fTriggerFired[ 0] = 1;
	220	fTriggerFired[ 1] = trigger.Contains("CCUP7-B");
	221	fTriggerFired[ 2] = trigger.Contains("CMUP5-B");
	222	fTriggerFired[ 3] = trigger.Contains("CMUP7-B");
	223	fTriggerFired[ 4] = trigger.Contains("CMUP9-B");
	224	fTriggerFired[ 5] = trigger.Contains("CMSL7-B-NOPF-MUON");
	225	fTriggerFired[ 6] = trigger.Contains("CMSL7-B-NOPF-ALLNOTRD");
	226
ea411d1a	227	fRunNumber = fInputEvent->GetRunNumber();
cb89681c	228	Bool_t isTrigger=0;
	229	for (Int_t i=0;i<NTRIGGERS;i++){
	230	if (!fTriggerFired[i]) continue;
	231	fTriggersPerRun->Fill(fRunNumber,i);
	232	if (!i) continue;
	233	isTrigger=1;
	234	}
	235	if (!isTrigger && !fIsMC) { PostData(1,fListOfHistos); return; }
	236	fEventStatistics->Fill("after trigger check",1);
	237
cb89681c	238
	239	if (fNofTracklets>1 && fTriggerFired[5]) { PostData(1,fListOfHistos); return; }
	240	if (fNofTracklets>1 && fTriggerFired[6]) { PostData(1,fListOfHistos); return; }
	241
	242	fEventStatistics->Fill("after tracklet check",1);
	243
ea411d1a	244	fPeriod = fInputEvent->GetPeriodNumber();
	245	fOrbit = fInputEvent->GetOrbitNumber();
	246	fBC = fInputEvent->GetBunchCrossNumber();
	247	fL0inputs = fInputEvent->GetHeader()->GetL0TriggerInputs();
	248	fL1inputs = fInputEvent->GetHeader()->GetL1TriggerInputs();
	249	fIR1 = fInputEvent->GetHeader()->GetIRInt1InteractionMap();
	250	fIR2 = fInputEvent->GetHeader()->GetIRInt2InteractionMap();
	251	fNofTracklets = fInputEvent->GetMultiplicity()->GetNumberOfTracklets();
cb89681c	252
ea411d1a	253	for (Int_t i=0;i<6;i++) fNofITSClusters[i] = fInputEvent->GetNumberOfITSClusters(i);
cb89681c	254
ea411d1a	255	AliVVZERO* vzero = fInputEvent->GetVZEROData();
cb89681c	256	for (Int_t i=0; i<32; i++){
	257	fV0AMult[i] = vzero->GetMultiplicityV0A(i);
	258	fV0CMult[i] = vzero->GetMultiplicityV0C(i);
	259	fV0ATime[i] = vzero->GetV0ATime();
	260	fV0CTime[i] = vzero->GetV0CTime();
	261	fBBTriggerV0A[i] = vzero->BBTriggerV0A(i);
	262	fBGTriggerV0A[i] = vzero->BGTriggerV0A(i);
	263	fBBTriggerV0C[i] = vzero->BBTriggerV0C(i);
	264	fBGTriggerV0C[i] = vzero->BGTriggerV0C(i);
	265	}
	266
	267	fBBonlineV0A = kFALSE;
	268	fBGonlineV0A = kFALSE;
	269	fBBonlineV0C = kFALSE;
	270	fBGonlineV0C = kFALSE;
	271	for (Int_t i=0; i<64; i++){
	272	fBBFlag[i] = vzero->GetBBFlag(i);
	273	fBGFlag[i] = vzero->GetBGFlag(i);
	274	if (fBBFlag[i] && i>=32) fBBonlineV0A = kTRUE;
	275	if (fBGFlag[i] && i>=32) fBGonlineV0A = kTRUE;
	276	if (fBBFlag[i] && i <32) fBBonlineV0C = kTRUE;
	277	if (fBGFlag[i] && i <32) fBGonlineV0C = kTRUE;
	278	}
	279
	280	fV0ADecision = vzero->GetV0ADecision();
	281	fV0CDecision = vzero->GetV0CDecision();
	282
	283	// ZDC data
ea411d1a	284	AliVZDC* zdc = fInputEvent->GetZDCData();
cb89681c	285	fZNAenergy = zdc->GetZNAEnergy();
	286	fZNCenergy = zdc->GetZNCEnergy();
	287	fZPAenergy = zdc->GetZPAEnergy();
	288	fZPCenergy = zdc->GetZPCEnergy();
	289	fZEM1energy = zdc->GetZEM1Energy();
	290	fZEM2energy = zdc->GetZEM2Energy();
	291	fZNAtower0 = zdc->GetZNATowerEnergy()[0];
	292	fZNCtower0 = zdc->GetZNCTowerEnergy()[0];
	293	fZPAtower0 = zdc->GetZPATowerEnergy()[0];
	294	fZPCtower0 = zdc->GetZPCTowerEnergy()[0];
	295	// ZDC timing
	296	fZEM1tdc = kFALSE;
	297	fZEM2tdc = kFALSE;
	298	fZNCtdc = kFALSE;
	299	fZPCtdc = kFALSE;
	300	fZNAtdc = kFALSE;
	301	fZPAtdc = kFALSE;
	302	if (!fIsAOD) {
	303	AliESDZDC* esdzdc = (AliESDZDC*) zdc;
	304	for(Int_t i=0;i<4;i++) {
	305	if (esdzdc->GetZDCTDCData( 8,i)) fZEM1tdc = kTRUE;
	306	if (esdzdc->GetZDCTDCData( 9,i)) fZEM2tdc = kTRUE;
	307	if (esdzdc->GetZDCTDCData(10,i)) fZNCtdc = kTRUE;
	308	if (esdzdc->GetZDCTDCData(11,i)) fZPCtdc = kTRUE;
	309	if (esdzdc->GetZDCTDCData(12,i)) fZNAtdc = kTRUE;
	310	if (esdzdc->GetZDCTDCData(13,i)) fZPAtdc = kTRUE;
	311	}
	312	}
ea411d1a	313
	314	const AliVVertex* vertex = fInputEvent->GetPrimaryVertex();
	315	fVtxX = vertex->GetX();
	316	fVtxY = vertex->GetY();
	317	fVtxZ = vertex->GetZ();
	318	fVtxTPC = TString(vertex->GetName()).CompareTo("PrimaryVertex") && TString(vertex->GetName()).CompareTo("SPDVertex");
cb89681c	319
ea411d1a	320	AliESDEvent* esd = !fIsAOD ? (AliESDEvent*) fInputEvent : 0;
	321	// AliAODEvent* aod = fIsAOD ? (AliAODEvent*) fInputEvent : 0;
	322
cb89681c	323	if (!esd) return; // AOD not yet implemented
	324
	325	fEventInFile = esd->GetHeader()->GetEventNumberInFile();
	326	fChunkFileName->SetString(((TTree*) GetInputData(0))->GetCurrentFile()->GetName());
	327
cb89681c	328	fFOmap = esd->GetMultiplicity()->GetFastOrFiredChips();
	329	fFiredChipMap = esd->GetMultiplicity()->GetFiredChipMap();
	330
ea411d1a	331	for (Int_t itr=0;itr<esd->GetNumberOfTracks();itr++){
cb89681c	332	AliESDtrack* track = (AliESDtrack*) esd->GetTrack(itr);
	333	Float_t pt = track->Pt();
	334	Float_t eta = track->Eta();
	335	Float_t phi = track->Phi();
	336	Short_t charge = track->Charge();
	337	UInt_t mask = 0;//track->GetFilterMap();
	338
	339	if (!fTrackFilter) AliFatal("Track filter undefined");
	340	mask \|= fTrackFilter->IsSelected(track);
	341
	342	if (!mask) continue;
	343	UInt_t itsClusterMap = track->GetITSClusterMap();
	344	Bool_t itsRefit = track->GetStatus() & AliVTrack::kITSrefit;
	345	Bool_t tpcRefit = track->GetStatus() & AliVTrack::kTPCrefit;
	346	Bool_t kink = track->GetKinkIndex(0)>0;
	347	mask \|= itsRefit << 20;
	348	mask \|= tpcRefit << 21;
	349	mask \|= kink << 22;
	350	mask \|= itsClusterMap << 23;
	351
	352	AliUpcParticle* part = new ((*fTPCtracks)[fTPCtracks->GetEntriesFast()]) AliUpcParticle(pt,eta,phi,charge,mask,10);
	353	Float_t dedx = track->GetTPCsignal();
	354	Float_t nCrossedRaws = track->GetTPCCrossedRows();
	355	Float_t nFindableClusters = track->GetTPCNclsF();
	356	Float_t nSharedClusters = track->GetTPCnclsS();
	357	Float_t nClusters = track->GetTPCncls();
	358	Float_t chi2tpc = track->GetTPCchi2();
	359	Float_t chi2its = track->GetITSchi2();
	360	Float_t chi2golden = 0;//vertex ? track->GetChi2TPCConstrainedVsGlobal(vertex) : 0;
	361	Float_t bxy,bz;
	362	track->GetImpactParameters(bxy,bz);
	363	part->SetAt(dedx,0);
	364	part->SetAt(nCrossedRaws,1);
	365	part->SetAt(nFindableClusters,2);
	366	part->SetAt(nSharedClusters,3);
	367	part->SetAt(nClusters,4);
	368	part->SetAt(chi2tpc,5);
	369	part->SetAt(chi2its,6);
	370	part->SetAt(chi2golden,7);
	371	part->SetAt(bxy,8);
	372	part->SetAt(bz,9);
	373	}
	374
	375	for (Int_t itr=0;itr<esd->GetNumberOfMuonTracks();itr++){
	376	AliESDMuonTrack* track = esd->GetMuonTrack(itr);
	377	if (!track->ContainTrackerData()) continue;
	378	Float_t pt = track->Pt();
	379	Float_t eta = track->Eta();
	380	Float_t phi = track->Phi();
	381	Short_t charge = track->Charge();
	382	UInt_t mask = fMuonTrackCuts->IsSelected(track);
	383	Float_t dca = track->GetDCA();
	384	Float_t chi2 = track->GetChi2();
	385	Float_t ndf = track->GetNDF();
	386	Float_t rabs = track->GetRAtAbsorberEnd();
	387	Float_t match = track->GetMatchTrigger();
	388	AliUpcParticle* part = new ((*fMUONtracks)[fMUONtracks->GetEntriesFast()]) AliUpcParticle(pt,eta,phi,charge,mask,5);
	389	part->SetAt(dca,0);
	390	part->SetAt(chi2,1);
	391	part->SetAt(ndf,2);
	392	part->SetAt(rabs,3);
	393	part->SetAt(match,4);
	394	}
	395
396	fTree->Fill();
397	PostData(1,fListOfHistos);
398	PostData(2,fTree);
399	}
400	//-----------------------------------------------------------------------------
401