#include <TBits.h>
#include <TClonesArray.h>
+///////////////////////////////////////////////////////////////////////////////
+// //
+// Class for generating combinatorial backgroung //
+// for the SPD tracklets //
+// //
+// Modes for "insertion", "rotation" and "mixing" are supported //
+// //
+///////////////////////////////////////////////////////////////////////////////
+
+
ClassImp(AliITSMultRecBg)
//_________________________________________________________________
//
}
+//_________________________________________________________________
+AliITSMultRecBg::AliITSMultRecBg(const AliTracker &AliITSMultRecBg)
+: fRecType(kData),
+ fInjLr(0),
+ fInjStave(0),
+ fInjModule(0),
+ fInjModInStave(0),
+ fInjX(0),
+ fInjZ(0),
+ fInjHitsN(0),
+ fInjScale(1),
+ fInjCurrTrial(0),
+ fInjCluster(),
+ fInjBuffer(2*kTrNPar)
+ //
+{
+ // dummy copy c-tor
+ fCreateClustersCopy = kTRUE;
+ for (int i=0;i<2;i++) {
+ fAssociations[i] = 0;
+ fInjSPDOcc[i] = 0;
+ fInjSPDPatt[i] = 0;
+ fInjNTrials[i] = 0;
+ fInjNSuccess[i] = 0;
+ for (int s=4;s--;) fInjModuleClStart[i][s] = fInjModuleClN[i][s] = 0;
+ }
+ //
+}
+
//_________________________________________________________________
AliITSMultRecBg::~AliITSMultRecBg()
{
#ifndef ALIITSMULTRECBG_H
#define ALIITSMULTRECBG_H
+///////////////////////////////////////////////////////////////////////////////
+// //
+// Class for generating combinatorial backgroung //
+// for the SPD tracklets //
+// //
+///////////////////////////////////////////////////////////////////////////////
+
class TH2F;
class TTree;
#include <TArrayF.h>
protected:
virtual void CreateMultiplicityObject();
//
+ AliITSMultRecBg(const AliTracker &AliITSMultRecBg);
// Injection stuff
void GenInjBgSample(TTree* treeRP, Float_t *vtx);
Bool_t PrepareInjBgGenerator(Float_t *vtx);
Int_t SearchInjTracklet(const Float_t *vtx);
Int_t GetPixelBitC(int stave, int chip, int col, int row) const {return row+((col+((chip+stave*20)<<5))<<8);} // row + (col+ (chip + stave*20)*32)*256;
Int_t GetPixelBitL(int stave, int ladder,int col, int row) const {return row+((col+(ladder+(stave<<2))*32*5)<<8);} // row + (col + (ladder + stave*4)*32*5)*256
- void ExtractPixelL(int id, int &stave, int &ladder, int &col, int &row);
+ void ExtractPixelL(int id, int &stave, int &ladder, int &col, int &row) const;
+
+ private:
+ AliITSMultRecBg& operator=(const AliITSMultRecBg& src);
protected:
enum {kInjFakeLabel=-999};
enum {kInjMaxNY=10, kInjMaxNZ=8};
//
- Int_t fRecType;
+ Int_t fRecType; // what to generate: normal reco, injection etc.
//
// method specific members
//
};
-inline void AliITSMultRecBg::ExtractPixelL(int id, int &stave, int &ladder, int &col, int &row)
+inline void AliITSMultRecBg::ExtractPixelL(int id, int &stave, int &ladder, int &col, int &row) const
{
+ // get sensor data
enum {kNRow=256,kNCol=32*5,kNLadd=4};
row = id%kNRow;
id /= kNRow;
#include "AliGenEventHeader.h"
#include "AliGenHijingEventHeader.h"
#include "AliGenDPMjetEventHeader.h"
+#include "AliTriggerAnalysis.h"
ClassImp(AliTaskGlobVar)
-GloVars_t globVars;
-
//________________________________________________________________________
AliTaskGlobVar::AliTaskGlobVar(const char *name)
: AliAnalysisTaskSE(name),
fOutput(0),
fOutTree(0),
fTrackCuts(0),
- fTrackCuts1(0)
+ fTrackCuts1(0),
+ fGlobVars()
{
// Constructor
DefineOutput(1, TList::Class());
if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { //RRR
printf("Deleteing output\n");
delete fOutput;
- fOutput = 0;
}
//
}
//________________________________________________________________________
void AliTaskGlobVar::UserCreateOutputObjects()
{
- //
+ // create ouptut
fOutput = new TList();
fOutput->SetOwner();
//
fOutTree = new TTree("globTree","globTree");
- fOutTree->Branch("g",&globVars,"runID/I:timeStamp/i:zdcNA/F:zdcPA/F:zdcNC/F:zdcPC/F:zem1/F:zem2/F:zvSPD/F:zvTPC/F:chunk/S:flags/S"
+ fOutTree->Branch("g",&fGlobVars,"runID/I:timeStamp/i:zdcNA/F:zdcPA/F:zdcNC/F:zdcPC/F:zem1/F:zem2/F:zvSPD/F:zvTPC/F:chunk/S:flags/S"
":spd1/S:spd2/S:ncontSPDV/S:ncontTPCV/S:nTrTPC/S:nTrTPCITS/S:nTracklets/S:v0A/S:v0C/S:v0Corr/S", 16777216);
if (fUseMC) {
- fOutTree->Branch("gmc",&globVars.mcZV,"mcZV/F:mcdNdEta/S:mcNPart/S:mcNBColl/S", 16777216);
+ fOutTree->Branch("gmc",&fGlobVars.mcZV,"mcZV/F:mcdNdEta/S:mcNPart/S:mcNBColl/S", 16777216);
}
fOutput->Add(fOutTree);
//
// if (vtxESDTPC->GetNContributors()<1) return;
// if (vtxESDTPC->GetNContributors()<(-10.+0.25*multESD->GetNumberOfITSClusters(0))) return;
//
- globVars.runID = esd->GetRunNumber();
+ fGlobVars.runID = esd->GetRunNumber();
TString rid = "";
- rid += globVars.runID;
+ rid += fGlobVars.runID;
TString flname = hand->GetTree()->GetCurrentFile()->GetName();
- globVars.chunk = 0;
+ fGlobVars.chunk = 0;
int id = 0;
while ( (id=flname.Index(rid))>=0 ) flname = flname.Data()+id+rid.Length();
id = flname.First('.');
if (id>=0) {
flname = flname.Data() + id+1;
- globVars.chunk = (Short_t)flname.Atoi();
+ fGlobVars.chunk = (Short_t)flname.Atoi();
}
- // printf("%d %s\n",globVars.chunk,hand->GetTree()->GetCurrentFile()->GetName());
+ // printf("%d %s\n",fGlobVars.chunk,hand->GetTree()->GetCurrentFile()->GetName());
//
- globVars.timeStamp = esd->GetTimeStamp();
- globVars.timeStamp = esd->GetTimeStamp();
- globVars.zvSPD = vtxESD->GetZ();
- globVars.zvTPC = vtxESDTPC->GetZ();
- globVars.ncontSPDV = (Short_t)vtxESD->GetNContributors();
- globVars.ncontTPCV = (Short_t)vtxESDTPC->GetNContributors();
- // globVars.nTrTPC = fTrackCuts ? (Short_t)fTrackCuts->GetReferenceMultiplicity(esd,kTRUE):-1;
- globVars.nTrTPC = fTrackCuts ? (Short_t)fTrackCuts->CountAcceptedTracks(esd):-1;
- globVars.nTrTPCITS = fTrackCuts1 ? (Short_t)fTrackCuts1->CountAcceptedTracks(esd):-1;
- globVars.nTracklets = multESD->GetNumberOfTracklets();
+ fGlobVars.timeStamp = esd->GetTimeStamp();
+ fGlobVars.timeStamp = esd->GetTimeStamp();
+ fGlobVars.zvSPD = vtxESD->GetZ();
+ fGlobVars.zvTPC = vtxESDTPC->GetZ();
+ fGlobVars.ncontSPDV = (Short_t)vtxESD->GetNContributors();
+ fGlobVars.ncontTPCV = (Short_t)vtxESDTPC->GetNContributors();
+ // fGlobVars.nTrTPC = fTrackCuts ? (Short_t)fTrackCuts->GetReferenceMultiplicity(esd,kTRUE):-1;
+ fGlobVars.nTrTPC = fTrackCuts ? (Short_t)fTrackCuts->CountAcceptedTracks(esd):-1;
+ fGlobVars.nTrTPCITS = fTrackCuts1 ? (Short_t)fTrackCuts1->CountAcceptedTracks(esd):-1;
+ fGlobVars.nTracklets = multESD->GetNumberOfTracklets();
//
AliESDVZERO* esdV0 = esd->GetVZEROData();
if (esdV0) {
- globVars.v0A = (Short_t)esdV0->GetMTotV0A();
- globVars.v0C = (Short_t)esdV0->GetMTotV0C();
+ fGlobVars.v0A = (Short_t)esdV0->GetMTotV0A();
+ fGlobVars.v0C = (Short_t)esdV0->GetMTotV0C();
}
- else globVars.v0A = globVars.v0C = 0;
+ else fGlobVars.v0A = fGlobVars.v0C = 0;
//
- globVars.spd1 = (Short_t)multESD->GetNumberOfITSClusters(0);
- globVars.spd2 = (Short_t)multESD->GetNumberOfITSClusters(1);
+ fGlobVars.spd1 = (Short_t)multESD->GetNumberOfITSClusters(0);
+ fGlobVars.spd2 = (Short_t)multESD->GetNumberOfITSClusters(1);
//
float v0Corr,v0CorrR;
v0Corr = GetCorrV0(esd,v0CorrR);
- globVars.v0Corr = (Short_t)v0Corr;
- // globVars.v0CorrResc = (Short_t)v0CorrR;
+ fGlobVars.v0Corr = (Short_t)v0Corr;
+ // fGlobVars.v0CorrResc = (Short_t)v0CorrR;
//---------------------------------------------
AliESDZDC *esdZDC = esd->GetESDZDC();
}
}
}
- globVars.flags = 0;
- if ( tdc[12] ) globVars.flags |= GloVars_t::kTDCNA; // Bool_t zdcNA = tdc[12];
- if ( tdc[10] ) globVars.flags |= GloVars_t::kTDCNC; // Bool_t zdcNC = tdc[10];
- if ( tdc[13] ) globVars.flags |= GloVars_t::kTDCPA; // Bool_t zdcPA = tdc[13];
- if ( tdc[11] ) globVars.flags |= GloVars_t::kTDCPC; // Bool_t zdcPC = tdc[11];
- if ( vtxOK ) globVars.flags |= GloVars_t::kSPDVTXOK;
+ fGlobVars.flags = 0;
+ if ( tdc[12] ) fGlobVars.flags |= GloVars_t::kTDCNA; // Bool_t zdcNA = tdc[12];
+ if ( tdc[10] ) fGlobVars.flags |= GloVars_t::kTDCNC; // Bool_t zdcNC = tdc[10];
+ if ( tdc[13] ) fGlobVars.flags |= GloVars_t::kTDCPA; // Bool_t zdcPA = tdc[13];
+ if ( tdc[11] ) fGlobVars.flags |= GloVars_t::kTDCPC; // Bool_t zdcPC = tdc[11];
+ if ( vtxOK ) fGlobVars.flags |= GloVars_t::kSPDVTXOK;
//
- globVars.zdcNC = (Float_t) (esdZDC->GetZDCN1Energy()) /8.;
- globVars.zdcPC = (Float_t) (esdZDC->GetZDCP1Energy()) /8.;
- globVars.zdcNA = (Float_t) (esdZDC->GetZDCN2Energy()) /8.;
- globVars.zdcPA = (Float_t) (esdZDC->GetZDCP2Energy()) /8.;
- globVars.zem1 = (Float_t) (esdZDC->GetZDCEMEnergy(0)) /8.;
- globVars.zem2 = (Float_t) (esdZDC->GetZDCEMEnergy(1)) /8.;
+ fGlobVars.zdcNC = (Float_t) (esdZDC->GetZDCN1Energy()) /8.;
+ fGlobVars.zdcPC = (Float_t) (esdZDC->GetZDCP1Energy()) /8.;
+ fGlobVars.zdcNA = (Float_t) (esdZDC->GetZDCN2Energy()) /8.;
+ fGlobVars.zdcPA = (Float_t) (esdZDC->GetZDCP2Energy()) /8.;
+ fGlobVars.zem1 = (Float_t) (esdZDC->GetZDCEMEnergy(0)) /8.;
+ fGlobVars.zem2 = (Float_t) (esdZDC->GetZDCEMEnergy(1)) /8.;
//-----------------------------------------------
//
// ---------------------- MC ONLY -------------------------------
AliMCEventHandler* eventHandler = (AliMCEventHandler*)anMan->GetMCtruthEventHandler();
AliStack* stack=0;
AliMCEvent* mcEvent=0;
- globVars.mcdNdEta = 0;
- globVars.mcNPart = 0;
- globVars.mcNBColl = 0;
+ fGlobVars.mcdNdEta = 0;
+ fGlobVars.mcNPart = 0;
+ fGlobVars.mcNBColl = 0;
if (fUseMC && eventHandler && (mcEvent=eventHandler->MCEvent()) && (stack=mcEvent->Stack())) {
int ntr = stack->GetNtrack();
for (int itr=ntr;itr--;) {
if (!part || !part->Charge()) continue;
Float_t eta = part->Eta();
if (TMath::Abs(eta)>0.5) continue;
- globVars.mcdNdEta++;
+ fGlobVars.mcdNdEta++;
}
//
AliGenEventHeader* mcGenH = mcEvent->GenEventHeader();
if (mcGenH->InheritsFrom(AliGenHijingEventHeader::Class())) {
AliGenHijingEventHeader* hHijing = (AliGenHijingEventHeader*)mcGenH;
- globVars.mcNPart = (hHijing->ProjectileParticipants()+hHijing->TargetParticipants())/2.;
- globVars.mcNBColl = hHijing->NN()+hHijing->NNw()+hHijing->NwN()+hHijing->NwNw();
+ fGlobVars.mcNPart = (hHijing->ProjectileParticipants()+hHijing->TargetParticipants())/2.;
+ fGlobVars.mcNBColl = hHijing->NN()+hHijing->NNw()+hHijing->NwN()+hHijing->NwNw();
}
else if (mcGenH->InheritsFrom(AliGenDPMjetEventHeader::Class())) {
AliGenDPMjetEventHeader* hDpmJet = (AliGenDPMjetEventHeader*)mcGenH;
- globVars.mcNPart = (hDpmJet->ProjectileParticipants()+hDpmJet->TargetParticipants())/2.;
- globVars.mcNBColl = hDpmJet->NN()+hDpmJet->NNw()+hDpmJet->NwN()+hDpmJet->NwNw();
+ fGlobVars.mcNPart = (hDpmJet->ProjectileParticipants()+hDpmJet->TargetParticipants())/2.;
+ fGlobVars.mcNBColl = hDpmJet->NN()+hDpmJet->NNw()+hDpmJet->NwN()+hDpmJet->NwNw();
}
else {} // unknown generator
//
TArrayF vtxMC;
mcGenH->PrimaryVertex(vtxMC);
- globVars.mcZV = vtxMC[2];
+ fGlobVars.mcZV = vtxMC[2];
}
//
fOutTree->Fill();
//________________________________________________________________________
void AliTaskGlobVar::Terminate(Option_t *)
{
+ // print itself
Printf("Terminating...");
// AliAnalysisTaskSE::Terminate();
}
-#ifndef ALIGLOBVAR_H
-#define ALIGLOBVAR_H
+#ifndef ALITASKGLOBVAR_H
+#define ALITASKGLOBVAR_H
///////////////////////////////////////////////////////////////////////////
// Analysis task to extract global variables to the tree //
class AliESDEvent;
class TList;
class AliESDtrackCuts;
+class AliTriggerAnalysis;
#include "AliAnalysisTaskSE.h"
-#include "AliTriggerAnalysis.h"
-
-class AliTaskGlobVar : public AliAnalysisTaskSE {
- //
- public:
- AliTaskGlobVar(const char *name = "AliTaskGlobVar");
- virtual ~AliTaskGlobVar();
- virtual void UserCreateOutputObjects();
- virtual void UserExec(Option_t *option);
- virtual void Terminate(Option_t *);
- //
- void SetUseMC(Bool_t mc=kTRUE) {fUseMC = mc;}
- Float_t GetCorrV0(const AliESDEvent* esd, float &v0CorrResc) const;
- Bool_t ZDCTimeTrigger(const AliESDEvent *aEsd) const;
- AliESDtrackCuts* CreatedNdPtTrackCuts(Int_t cutMode, Bool_t fieldOn=kTRUE);
- //
- protected:
- Bool_t fUseMC; // do we use MC info
- TList* fOutput; // output list send on output slot 1
- //
- TTree* fOutTree; // output tree
- AliESDtrackCuts* fTrackCuts; //! optional track cuts
- AliESDtrackCuts* fTrackCuts1; //! optional track cuts
- //
- private:
- AliTaskGlobVar(const AliTaskGlobVar&); // not implemented
- AliTaskGlobVar& operator=(const AliTaskGlobVar&); // not implemented
-
- ClassDef(AliTaskGlobVar, 1);
-};
typedef struct {
Short_t mcNBColl;
} GloVars_t;
+
+class AliTaskGlobVar : public AliAnalysisTaskSE {
+ //
+ public:
+ AliTaskGlobVar(const char *name = "AliTaskGlobVar");
+ virtual ~AliTaskGlobVar();
+ virtual void UserCreateOutputObjects();
+ virtual void UserExec(Option_t *option);
+ virtual void Terminate(Option_t *);
+ //
+ void SetUseMC(Bool_t mc=kTRUE) {fUseMC = mc;}
+ Float_t GetCorrV0(const AliESDEvent* esd, float &v0CorrResc) const;
+ Bool_t ZDCTimeTrigger(const AliESDEvent *aEsd) const;
+ AliESDtrackCuts* CreatedNdPtTrackCuts(Int_t cutMode, Bool_t fieldOn=kTRUE);
+ //
+ protected:
+ Bool_t fUseMC; // do we use MC info
+ TList* fOutput; // output list send on output slot 1
+ //
+ TTree* fOutTree; // output tree
+ AliESDtrackCuts* fTrackCuts; //! optional track cuts
+ AliESDtrackCuts* fTrackCuts1; //! optional track cuts
+ //
+ GloVars_t fGlobVars; // data container
+ private:
+ AliTaskGlobVar(const AliTaskGlobVar&); // not implemented
+ AliTaskGlobVar& operator=(const AliTaskGlobVar&); // not implemented
+
+ ClassDef(AliTaskGlobVar, 1);
+};
+
+
#endif
#include "../ITS/AliITSRecPoint.h"
#include "../ITS/AliITSgeomTGeo.h"
#include "../ITS/AliITSMultReconstructor.h"
-
+#include "../ITS/AliITSsegmentationSPD.h"
#include "AliLog.h"
#include "AliPhysicsSelection.h"
//const Float_t AliTrackletTaskMulti::fgkCentPerc[] = {0,5,10,20,30,40};
//{0,10,20,30,40,50,60,70,80,90,95,101};
-const char* AliTrackletTaskMulti::fgCentSelName[] = {"V0M","FMD","TRK","TKL","CL0","CL1","V0MvsFMD","TKLvsV0M","ZENvsZDC"};
+const char* AliTrackletTaskMulti::fgkCentSelName[] = {"V0M","FMD","TRK","TKL","CL0","CL1","V0MvsFMD","TKLvsV0M","ZENvsZDC"};
const char* AliTrackletTaskMulti::fgkPDGNames[] = {
"#pi^{+}",
fRPTree(0),
fRPTreeMix(0),
fStack(0),
- fMCEvent(0),
+ fMCevent(0),
//
fNPart(0),
fNBColl(0),
// Destructor
// histograms are in the output list and deleted when the output
// list is deleted by the TSelector dtor
- if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { //RRR
+ if (!AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { //RRR
printf("Deleteing output\n");
delete fOutput;
- fOutput = 0;
}
//
delete fMultReco;
//________________________________________________________________________
void AliTrackletTaskMulti::UserCreateOutputObjects()
{
- //
+ // create output
fOutput = new TList();
fOutput->SetOwner();
//
printf("Wrong centrality type %d\n",fUseCentralityVar);
exit(1);
}
- AliInfo(Form("Centrality type selected: %s\n",fgCentSelName[fUseCentralityVar]));
+ AliInfo(Form("Centrality type selected: %s\n",fgkCentSelName[fUseCentralityVar]));
PostData(1, fOutput);
//
}
}
((TH2*)fHistosCustom->UncheckedAt(kHZDCZEMNoSel))->Fill(zemEnergy,zdcEnergy);
//
- Float_t centPercentile = centrality->GetCentralityPercentileUnchecked(fgCentSelName[fUseCentralityVar]);
+ Float_t centPercentile = centrality->GetCentralityPercentileUnchecked(fgkCentSelName[fUseCentralityVar]);
// temporary >>>>>>>>>>>>>>>>>>>>>>>>
if (fUseCentralityVar==kCentZEMvsZDC) {
((TH1*)fHistosCustom->UncheckedAt(kHStatCent))->Fill(centPercentile);
//
AliMCEventHandler* eventHandler = 0;
- fMCEvent = 0;
+ fMCevent = 0;
fStack = 0;
//
if (fUseMC) {
eventHandler = (AliMCEventHandler*)anMan->GetMCtruthEventHandler();
if (!eventHandler) { printf("ERROR: Could not retrieve MC event handler\n"); return; }
- fMCEvent = eventHandler->MCEvent();
- if (!fMCEvent) { printf("ERROR: Could not retrieve MC event\n"); return; }
- fStack = fMCEvent->Stack();
+ fMCevent = eventHandler->MCEvent();
+ if (!fMCevent) { printf("ERROR: Could not retrieve MC event\n"); return; }
+ fStack = fMCevent->Stack();
if (!fStack) { printf("Stack not available\n"); return; }
}
//
fNPart = 0;
fNBColl = 0;
if (fUseMC) {
- mcGenH = fMCEvent->GenEventHeader();
+ mcGenH = fMCevent->GenEventHeader();
if (mcGenH->InheritsFrom(AliGenHijingEventHeader::Class())) {
AliGenHijingEventHeader* hHijing = (AliGenHijingEventHeader*)mcGenH;
fNPart = (hHijing->ProjectileParticipants()+hHijing->TargetParticipants())/2.;
hstat->GetXaxis()->SetBinLabel(kOneUnit,"ScaleMerge");
hstat->GetXaxis()->SetBinLabel(kNWorkers,"Workers");
//
- hstat->GetXaxis()->SetBinLabel(kCentVar, fgCentSelName[fUseCentralityVar]);
+ hstat->GetXaxis()->SetBinLabel(kCentVar, fgkCentSelName[fUseCentralityVar]);
hstat->GetXaxis()->SetBinLabel(kDPhi, "#Delta#varphi");
hstat->GetXaxis()->SetBinLabel(kDTht, "#Delta#theta");
hstat->GetXaxis()->SetBinLabel(kNStd, "N.std");
AliGenHijingEventHeader* pyHeader = 0;
//
if (fUseMC) {
- pyHeader = (AliGenHijingEventHeader*) fMCEvent->GenEventHeader();//header->GenEventHeader();
+ pyHeader = (AliGenHijingEventHeader*) fMCevent->GenEventHeader();//header->GenEventHeader();
pyHeader->PrimaryVertex(vtxMC);
}
//---------------------------------------- CHECK ------------------------------<<<
void AliTrackletTaskMulti::FillMCPrimaries()
{
// fill all MC primaries Zv vs Eta
- if (!fStack || !fMCEvent) return;
+ if (!fStack || !fMCevent) return;
//---------------------------------------- CHECK ------------------------------>>>
TArrayF vtxMC;
AliGenHijingEventHeader* pyHeader = 0;
//
if (fUseMC) {
- pyHeader = (AliGenHijingEventHeader*) fMCEvent->GenEventHeader();//header->GenEventHeader();
+ pyHeader = (AliGenHijingEventHeader*) fMCevent->GenEventHeader();//header->GenEventHeader();
pyHeader->PrimaryVertex(vtxMC);
}
//---------------------------------------- CHECK ------------------------------<<<
int nprim = 0;
for (int itr=ntr;itr--;) {
if (!fStack->IsPhysicalPrimary(itr)) continue;
- AliMCParticle *part = (AliMCParticle*)fMCEvent->GetTrack(itr);
+ AliMCParticle *part = (AliMCParticle*)fMCevent->GetTrack(itr);
if (!part->Charge()) continue;
//
//---------------------------------------- CHECK ------------------------------>>>
class AliMCParticle;
class AliITSMultRecBg;
class AliESDTrackCuts;
+class AliITSsegmentationSPD;
-#include "../ITS/AliITSsegmentationSPD.h"
#include "AliAnalysisTaskSE.h"
#include "AliTriggerAnalysis.h"
#include <TMath.h>
Bool_t fDoRotation; // do rotation
Bool_t fDoMixing; // do mixing
//
- Bool_t fUseMC;
- Bool_t fCheckReconstructables;
+ Bool_t fUseMC; // flag of MC processing
+ Bool_t fCheckReconstructables; // request check
//
TObjArray* fHistosTrData; //! all tracklets in data
TObjArray* fHistosTrInj; //! injected
TTree* fRPTree; //! tree of recpoints
TTree* fRPTreeMix; //! tree of recpoints for mixing
AliStack* fStack; //! MC stack
- AliMCEvent* fMCEvent; //! MC Event
+ AliMCEvent* fMCevent; //! MC Event
Float_t fESDVtx[3]; // ESD vertex
//
Float_t fNPart; // number of participant pairs from MC
//
static const Float_t fgkCentPerc[]; //! centrality in percentiles
//
- static const char* fgCentSelName[]; //!centrality types
+ static const char* fgkCentSelName[]; //!centrality types
static const char* fgkPDGNames[]; //!pdg names
static const Int_t fgkPDGCodes[]; //!pdg codes
//
**************************************************************************/
///////////////////////////////////////////////////////////////////////////
-// Class AliTrackletTaskMulti //
+// Class AliTrackletTaskMultipp //
// Analysis task to produce data and MC histos needed for tracklets //
// dNdEta extraction in multiple bins in one go //
// Author: ruben.shahoyan@cern.ch //
#include "../ITS/AliITSRecPoint.h"
#include "../ITS/AliITSgeomTGeo.h"
#include "../ITS/AliITSMultReconstructor.h"
+#include "../ITS/AliITSsegmentationSPD.h"
#include "AliLog.h"
#include "AliPhysicsSelection.h"
-#include "AliTrackletTaskMulti.h"
+#include "AliTrackletTaskMultipp.h"
#include "AliITSMultRecBg.h"
#include "AliGenEventHeader.h"
#include "AliGenHijingEventHeader.h"
#include "AliGenDPMjetEventHeader.h"
#include "AliESDtrackCuts.h"
-ClassImp(AliTrackletTaskMulti)
+ClassImp(AliTrackletTaskMultipp)
// centrality percentile (inverted: 100% - most central)
-const Float_t AliTrackletTaskMulti::fgkCentPerc[] = {0,100};//{0,5,10,20,30};
-//const Float_t AliTrackletTaskMulti::fgkCentPerc[] = {0,5,10,20,30,40};
+const Float_t AliTrackletTaskMultipp::fgkCentPerc[] = {0,100};//{0,5,10,20,30};
+//const Float_t AliTrackletTaskMultipp::fgkCentPerc[] = {0,5,10,20,30,40};
//{0,10,20,30,40,50,60,70,80,90,95,101};
-const char* AliTrackletTaskMulti::fgCentSelName[] = {"V0M","FMD","TRK","TKL","CL0","CL1","V0MvsFMD","TKLvsV0M","ZENvsZDC"};
+const char* AliTrackletTaskMultipp::fgkCentSelName[] = {"V0M","FMD","TRK","TKL","CL0","CL1","V0MvsFMD","TKLvsV0M","ZENvsZDC"};
-const char* AliTrackletTaskMulti::fgkPDGNames[] = {
+const char* AliTrackletTaskMultipp::fgkPDGNames[] = {
"#pi^{+}",
"p",
"K^{+}",
"Others"
};
-const int AliTrackletTaskMulti::fgkPDGCodes[] = {
+const int AliTrackletTaskMultipp::fgkPDGCodes[] = {
211,
2212,
321,
//________________________________________________________________________
/*//Default constructor
-AliTrackletTaskMulti::AliTrackletTaskMulti(const char *name)
+AliTrackletTaskMultipp::AliTrackletTaskMultipp(const char *name)
: AliAnalysisTaskSE(name),
*/
//________________________________________________________________________
-AliTrackletTaskMulti::AliTrackletTaskMulti(const char *name)
+AliTrackletTaskMultipp::AliTrackletTaskMultipp(const char *name)
: AliAnalysisTaskSE(name),
//
fOutput(0),
fRPTree(0),
fRPTreeMix(0),
fStack(0),
- fMCEvent(0),
+ fMCevent(0),
//
fNPart(0),
fNBColl(0),
}
//________________________________________________________________________
-AliTrackletTaskMulti::~AliTrackletTaskMulti()
+AliTrackletTaskMultipp::~AliTrackletTaskMultipp()
{
// Destructor
// histograms are in the output list and deleted when the output
// list is deleted by the TSelector dtor
- if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { //RRR
+ if (!AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { //RRR
printf("Deleteing output\n");
delete fOutput;
- fOutput = 0;
}
//
delete fMultReco;
}
//________________________________________________________________________
-void AliTrackletTaskMulti::UserCreateOutputObjects()
+void AliTrackletTaskMultipp::UserCreateOutputObjects()
{
- //
+ // create output
fOutput = new TList();
fOutput->SetOwner();
//
printf("Wrong centrality type %d\n",fUseCentralityVar);
exit(1);
}
- AliInfo(Form("Centrality type selected: %s\n",fgCentSelName[fUseCentralityVar]));
+ AliInfo(Form("Centrality type selected: %s\n",fgkCentSelName[fUseCentralityVar]));
PostData(1, fOutput);
//
}
//________________________________________________________________________
-void AliTrackletTaskMulti::UserExec(Option_t *)
+void AliTrackletTaskMultipp::UserExec(Option_t *)
{
// Main loop
//
}
((TH2*)fHistosCustom->UncheckedAt(kHZDCZEMNoSel))->Fill(zemEnergy,zdcEnergy);
//
- Float_t centPercentile = centrality->GetCentralityPercentileUnchecked(fgCentSelName[fUseCentralityVar]);
+ Float_t centPercentile = centrality->GetCentralityPercentileUnchecked(fgkCentSelName[fUseCentralityVar]);
// temporary >>>>>>>>>>>>>>>>>>>>>>>>
if (fUseCentralityVar==kCentZEMvsZDC) {
((TH1*)fHistosCustom->UncheckedAt(kHStatCent))->Fill(centPercentile);
//
AliMCEventHandler* eventHandler = 0;
- fMCEvent = 0;
+ fMCevent = 0;
fStack = 0;
//
if (fUseMC) {
eventHandler = (AliMCEventHandler*)anMan->GetMCtruthEventHandler();
if (!eventHandler) { printf("ERROR: Could not retrieve MC event handler\n"); return; }
- fMCEvent = eventHandler->MCEvent();
- if (!fMCEvent) { printf("ERROR: Could not retrieve MC event\n"); return; }
- fStack = fMCEvent->Stack();
+ fMCevent = eventHandler->MCEvent();
+ if (!fMCevent) { printf("ERROR: Could not retrieve MC event\n"); return; }
+ fStack = fMCevent->Stack();
if (!fStack) { printf("Stack not available\n"); return; }
}
//
fNPart = 0;
fNBColl = 0;
if (fUseMC) {
- mcGenH = fMCEvent->GenEventHeader();
+ mcGenH = fMCevent->GenEventHeader();
if (mcGenH->InheritsFrom(AliGenHijingEventHeader::Class())) {
AliGenHijingEventHeader* hHijing = (AliGenHijingEventHeader*)mcGenH;
fNPart = (hHijing->ProjectileParticipants()+hHijing->TargetParticipants())/2.;
//________________________________________________________________________
-void AliTrackletTaskMulti::Terminate(Option_t *)
+void AliTrackletTaskMultipp::Terminate(Option_t *)
{
+ // finish processing
Printf("Terminating...");
TH1* hstat;
TList *lst = dynamic_cast<TList*>(GetOutputData(1));
//_________________________________________________________________________
-void AliTrackletTaskMulti::InitMultReco()
+void AliTrackletTaskMultipp::InitMultReco()
{
// create mult reconstructor
if (fMultReco) delete fMultReco;
}
//_________________________________________________________________________
-TObjArray* AliTrackletTaskMulti::BookCustomHistos()
+TObjArray* AliTrackletTaskMultipp::BookCustomHistos()
{
// book custom histos, not related to specific tracklet type
TObjArray* histos = new TObjArray();
hstat->GetXaxis()->SetBinLabel(kOneUnit,"ScaleMerge");
hstat->GetXaxis()->SetBinLabel(kNWorkers,"Workers");
//
- hstat->GetXaxis()->SetBinLabel(kCentVar, fgCentSelName[fUseCentralityVar]);
+ hstat->GetXaxis()->SetBinLabel(kCentVar, fgkCentSelName[fUseCentralityVar]);
hstat->GetXaxis()->SetBinLabel(kDPhi, "#Delta#varphi");
hstat->GetXaxis()->SetBinLabel(kDTht, "#Delta#theta");
hstat->GetXaxis()->SetBinLabel(kNStd, "N.std");
}
//_________________________________________________________________________
-TObjArray* AliTrackletTaskMulti::BookHistosSet(const char* pref, UInt_t selHistos)
+TObjArray* AliTrackletTaskMultipp::BookHistosSet(const char* pref, UInt_t selHistos)
{
// book standard set of histos attaching the pref in front of the name/title
//
}
//_________________________________________________________________________
-void AliTrackletTaskMulti::AddHisto(TObjArray* histos, TObject* h, Int_t at)
+void AliTrackletTaskMultipp::AddHisto(TObjArray* histos, TObject* h, Int_t at)
{
// add single histo to the set
if (at>=0) histos->AddAtAndExpand(h,at);
}
//_________________________________________________________________________
-void AliTrackletTaskMulti::FillHistos(Int_t type, const AliMultiplicity* mlt)
+void AliTrackletTaskMultipp::FillHistos(Int_t type, const AliMultiplicity* mlt)
{
// fill histos of given type
if (!mlt) return;
AliGenHijingEventHeader* pyHeader = 0;
//
if (fUseMC) {
- pyHeader = (AliGenHijingEventHeader*) fMCEvent->GenEventHeader();//header->GenEventHeader();
+ pyHeader = (AliGenHijingEventHeader*) fMCevent->GenEventHeader();//header->GenEventHeader();
pyHeader->PrimaryVertex(vtxMC);
}
//---------------------------------------- CHECK ------------------------------<<<
}
//_________________________________________________________________________
-void AliTrackletTaskMulti::FillMCPrimaries()
+void AliTrackletTaskMultipp::FillMCPrimaries()
{
// fill all MC primaries Zv vs Eta
- if (!fStack || !fMCEvent) return;
+ if (!fStack || !fMCevent) return;
//---------------------------------------- CHECK ------------------------------>>>
TArrayF vtxMC;
AliGenHijingEventHeader* pyHeader = 0;
//
if (fUseMC) {
- pyHeader = (AliGenHijingEventHeader*) fMCEvent->GenEventHeader();//header->GenEventHeader();
+ pyHeader = (AliGenHijingEventHeader*) fMCevent->GenEventHeader();//header->GenEventHeader();
pyHeader->PrimaryVertex(vtxMC);
}
//---------------------------------------- CHECK ------------------------------<<<
int nprim = 0;
for (int itr=ntr;itr--;) {
if (!fStack->IsPhysicalPrimary(itr)) continue;
- AliMCParticle *part = (AliMCParticle*)fMCEvent->GetTrack(itr);
+ AliMCParticle *part = (AliMCParticle*)fMCevent->GetTrack(itr);
if (!part->Charge()) continue;
//
//---------------------------------------- CHECK ------------------------------>>>
}
//_________________________________________________________________________
- void AliTrackletTaskMulti::FillHistosSet(TObjArray* histos, double eta,
+ void AliTrackletTaskMultipp::FillHistosSet(TObjArray* histos, double eta,
//double /*phi*/,double /*theta*/,
double dphi,double dtheta,double dThetaX,
double dist)
}
//__________________________________________________________________
-void AliTrackletTaskMulti::FillSpecies(Int_t primsec, Int_t id)
+void AliTrackletTaskMultipp::FillSpecies(Int_t primsec, Int_t id)
{
// fill PDGcode
TH1 *hPart=0,*hParent=0;
}
//_________________________________________________________________________
-Int_t AliTrackletTaskMulti::GetCentralityBin(Float_t perc) const
+Int_t AliTrackletTaskMultipp::GetCentralityBin(Float_t perc) const
{
// calculate centrality bin
for (int i=0;i<fNCentBins;i++) if (perc>=fgkCentPerc[i] && perc<=fgkCentPerc[i+1]) return i;
}
//_________________________________________________________________________
-Int_t AliTrackletTaskMulti::GetPdgBin(Int_t pdgCode)
+Int_t AliTrackletTaskMultipp::GetPdgBin(Int_t pdgCode)
{
// return my pdg bin
int ncodes = sizeof(fgkPDGCodes)/sizeof(int);
}
//_________________________________________________________________________
-Bool_t AliTrackletTaskMulti::HaveCommonParent(const float* clLabs0,const float* clLabs1)
+Bool_t AliTrackletTaskMultipp::HaveCommonParent(const float* clLabs0,const float* clLabs1)
{
// do 2 clusters have common parrent
const int kMaxPar = 50;
//_________________________________________________________________________
-void AliTrackletTaskMulti::CheckReconstructables()
+void AliTrackletTaskMultipp::CheckReconstructables()
{
// fill reconstructable tracklets hitsos
static TArrayI trInd;
}
//_________________________________________________________________________
-void AliTrackletTaskMulti::FillClusterInfo()
+void AliTrackletTaskMultipp::FillClusterInfo()
{
// fill info on clusters associated to good tracklets
if (!fMultReco) return;
}
//_________________________________________________________________________
-void AliTrackletTaskMulti::FillClusterInfoFromMult(const AliMultiplicity* mlt, double zVertex)
+void AliTrackletTaskMultipp::FillClusterInfoFromMult(const AliMultiplicity* mlt, double zVertex)
{
// fill info on clusters taking them from Multiplicity object
const double kRSPD1 = 3.9;
}
//_________________________________________________________________________
-void AliTrackletTaskMulti::FillClusterAutoCorrelationFromMult(const AliMultiplicity* mlt, double zVertex)
+void AliTrackletTaskMultipp::FillClusterAutoCorrelationFromMult(const AliMultiplicity* mlt, double zVertex)
{
// fill mutual distance between SPD1 clusters
const double kRSPD1 = 3.9;
-#ifndef ALITRACKLETTASKMULTI_H
-#define ALITRACKLETTASKMULTI_H
+#ifndef ALITRACKLETTASKMULTIPP_H
+#define ALITRACKLETTASKMULTIPP_H
///////////////////////////////////////////////////////////////////////////
-// Class AliTrackletTaskMulti //
+// Class AliTrackletTaskMultipp //
// Analysis task to produce data and MC histos needed for tracklets //
// dNdEta extraction in multiple bins in one go //
// Author: ruben.shahoyan@cern.ch //
class AliMCParticle;
class AliITSMultRecBg;
class AliESDTrackCuts;
-
-#include "../ITS/AliITSsegmentationSPD.h"
+class AliITSsegmentationSPD;
#include "AliAnalysisTaskSE.h"
#include "AliTriggerAnalysis.h"
#include <TMath.h>
-class AliTrackletTaskMulti : public AliAnalysisTaskSE {
+class AliTrackletTaskMultipp : public AliAnalysisTaskSE {
public:
enum {kData,kBgInj,kBgRot,kBgMix,kMC};
enum {kCentV0M,kCentFMD,kCentTRK,kCentTKL,kCentCL0,kCentCL1,kCentV0MvsFMD,kCentTKLvsV0,kCentZEMvsZDC,kNCentTypes}; // what is used to define centrality
};
//
- AliTrackletTaskMulti(const char *name = "AliTrackletTaskMulti");
- virtual ~AliTrackletTaskMulti();
+ AliTrackletTaskMultipp(const char *name = "AliTrackletTaskMultipp");
+ virtual ~AliTrackletTaskMultipp();
virtual void UserCreateOutputObjects();
virtual void UserExec(Option_t *option);
Bool_t fDoRotation; // do rotation
Bool_t fDoMixing; // do mixing
//
- Bool_t fUseMC;
- Bool_t fCheckReconstructables;
+ Bool_t fUseMC; // flag of MC processing
+ Bool_t fCheckReconstructables; // request check
//
TObjArray* fHistosTrData; //! all tracklets in data
TObjArray* fHistosTrInj; //! injected
TTree* fRPTree; //! tree of recpoints
TTree* fRPTreeMix; //! tree of recpoints for mixing
AliStack* fStack; //! MC stack
- AliMCEvent* fMCEvent; //! MC Event
+ AliMCEvent* fMCevent; //! MC Event
Float_t fESDVtx[3]; // ESD vertex
//
Float_t fNPart; // number of participant pairs from MC
//
static const Float_t fgkCentPerc[]; //! centrality in percentiles
//
- static const char* fgCentSelName[]; //!centrality types
+ static const char* fgkCentSelName[]; //!centrality types
static const char* fgkPDGNames[]; //!pdg names
static const Int_t fgkPDGCodes[]; //!pdg codes
//
private:
- AliTrackletTaskMulti(const AliTrackletTaskMulti&); // not implemented
- AliTrackletTaskMulti& operator=(const AliTrackletTaskMulti&); // not implemented
+ AliTrackletTaskMultipp(const AliTrackletTaskMultipp&); // not implemented
+ AliTrackletTaskMultipp& operator=(const AliTrackletTaskMultipp&); // not implemented
- ClassDef(AliTrackletTaskMulti, 1);
+ ClassDef(AliTrackletTaskMultipp, 1);
};
#include "../ITS/AliITSRecPoint.h"
#include "../ITS/AliITSgeomTGeo.h"
#include "../ITS/AliITSMultReconstructor.h"
-
+#include "../ITS/AliITSsegmentationSPD.h"
#include "AliLog.h"
#include "AliPhysicsSelection.h"
fRPTree(0),
fRPTreeMix(0),
fStack(0),
- fMCEvent(0),
+ fMCevent(0),
fDontMerge(kFALSE)
/*
,
// Destructor
// histograms are in the output list and deleted when the output
// list is deleted by the TSelector dtor
- if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { //RRR
+ if (!AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { //RRR
printf("Deleteing output\n");
delete fOutput;
- fOutput = 0;
}
//
delete fMultReco;
//________________________________________________________________________
void AliTrackletTaskUni::UserCreateOutputObjects()
{
- //
+ // create output
if (fDontMerge) {
OpenFile(1);
//________________________________________________________________________
void AliTrackletTaskUni::RegisterStat()
{
+ // account conditions
static Bool_t done = kFALSE;
if (done) return;
TH1* hstat;
// multESD->Print();
//
AliMCEventHandler* eventHandler = 0;
- fMCEvent = 0;
+ fMCevent = 0;
fStack = 0;
//
if (fUseMC) {
eventHandler = (AliMCEventHandler*)anMan->GetMCtruthEventHandler();
if (!eventHandler) { printf("ERROR: Could not retrieve MC event handler\n"); return; }
- fMCEvent = eventHandler->MCEvent();
- if (!fMCEvent) { printf("ERROR: Could not retrieve MC event\n"); return; }
- fStack = fMCEvent->Stack();
+ fMCevent = eventHandler->MCEvent();
+ if (!fMCevent) { printf("ERROR: Could not retrieve MC event\n"); return; }
+ fStack = fMCevent->Stack();
if (!fStack) { printf("Stack not available\n"); return; }
}
//
//________________________________________________________________________
void AliTrackletTaskUni::Terminate(Option_t *)
{
+ // print itself
Printf("Terminating...");
RegisterStat();
// AliAnalysisTaskSE::Terminate();
AliGenHijingEventHeader* pyHeader = 0;
//
if (fUseMC) {
- pyHeader = (AliGenHijingEventHeader*) fMCEvent->GenEventHeader();//header->GenEventHeader();
+ pyHeader = (AliGenHijingEventHeader*) fMCevent->GenEventHeader();//header->GenEventHeader();
pyHeader->PrimaryVertex(vtxMC);
}
//---------------------------------------- CHECK ------------------------------<<<
void AliTrackletTaskUni::FillMCPrimaries(TH2F* hetaz)
{
// fill all MC primaries Zv vs Eta
- if (!fStack || !fMCEvent) return;
+ if (!fStack || !fMCevent) return;
//---------------------------------------- CHECK ------------------------------>>>
TArrayF vtxMC;
AliGenHijingEventHeader* pyHeader = 0;
//
if (fUseMC) {
- pyHeader = (AliGenHijingEventHeader*) fMCEvent->GenEventHeader();//header->GenEventHeader();
+ pyHeader = (AliGenHijingEventHeader*) fMCevent->GenEventHeader();//header->GenEventHeader();
pyHeader->PrimaryVertex(vtxMC);
}
//---------------------------------------- CHECK ------------------------------<<<
int ntr = fStack->GetNtrack();
for (int itr=ntr;itr--;) {
if (!fStack->IsPhysicalPrimary(itr)) continue;
- AliMCParticle *part = (AliMCParticle*)fMCEvent->GetTrack(itr);
+ AliMCParticle *part = (AliMCParticle*)fMCevent->GetTrack(itr);
if (!part->Charge()) continue;
//
//---------------------------------------- CHECK ------------------------------>>>
class AliMCParticle;
class AliITSMultRecBg;
-
-#include "../ITS/AliITSsegmentationSPD.h"
+class AliITSsegmentationSPD;
#include "AliAnalysisTaskSE.h"
#include "AliTriggerAnalysis.h"
Bool_t fDoRotation; // do rotation
Bool_t fDoMixing; // do mixing
//
- Bool_t fUseMC;
- Bool_t fCheckReconstructables;
+ Bool_t fUseMC; // flag of MC processing
+ Bool_t fCheckReconstructables; // request check
//
TObjArray* fHistosTrData; //! all tracklets in data
TObjArray* fHistosTrInj; //! injected
TTree* fRPTree; //! tree of recpoints
TTree* fRPTreeMix; //! tree of recpoints for mixing
AliStack* fStack; //! MC stack
- AliMCEvent* fMCEvent; //! MC Event
+ AliMCEvent* fMCevent; //! MC Event
Float_t fESDVtx[3]; // ESD vertex
//
/*
+/**************************************************************/
+/* */
+/* Set of methods to manipulate with canvas */
+/* its elements etc. */
+/* Author: */
+/* ruben.shahoyan@cern.ch */
+/* */
+/**************************************************************/
+
#if !defined(__CINT__) || defined(__MAKECINT__)
#include <TCanvas.h>
#include <TString.h>
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff