#include "AliFlowCommonConstants.h"
#include "AliAnalysisTaskFlowEvent.h"
+#include "AliESDpid.h"
+#include "AliTOFcalib.h"
+#include "AliTOFT0maker.h"
+#include "AliCDBManager.h"
+
#include "AliLog.h"
ClassImp(AliAnalysisTaskFlowEvent)
fV2(0.),
fV3(0.),
fV4(0.),
- fMyTRandom3(NULL)
+ fMyTRandom3(NULL),
+ fESDpid(NULL),
+ fTOFresolution(0.0),
+ fTOFcalib(NULL),
+ ftofT0maker(NULL)
{
// Constructor
cout<<"AliAnalysisTaskFlowEvent::AliAnalysisTaskFlowEvent()"<<endl;
fV2(0.),
fV3(0.),
fV4(0.),
- fMyTRandom3(NULL)
+ fMyTRandom3(NULL),
+ fESDpid(NULL),
+ fTOFresolution(0.0),
+ fTOFcalib(NULL),
+ ftofT0maker(NULL)
{
// Constructor
cout<<"AliAnalysisTaskFlowEvent::AliAnalysisTaskFlowEvent(const char *name, Bool_t on, UInt_t iseed)"<<endl;
DefineInput(1, TList::Class());
}
+ //PID
+ fESDpid=new AliESDpid();
+ fTOFcalib = new AliTOFcalib();
+
// Define output slots here
// Define here the flow event output
DefineOutput(1, AliFlowEventSimple::Class());
//
// Destructor
//
- if (fMyTRandom3) delete fMyTRandom3;
+ delete fMyTRandom3;
+ delete fESDpid;
+ delete fTOFcalib;
+ delete ftofT0maker;
// objects in the output list are deleted
// by the TSelector dtor (I hope)
}
+//________________________________________________________________________
+void AliAnalysisTaskFlowEvent::NotifyRun()
+{
+ //at the beginning of each new run
+ AliESDEvent* fESD = dynamic_cast<AliESDEvent*> (InputEvent());
+ Int_t run = fESD->GetRunNumber();
+ if(fTOFresolution>0.0)
+ {
+ AliCDBManager *cdb = AliCDBManager::Instance();
+ cdb->SetDefaultStorage("raw://");
+ cdb->SetRun(run);
+ fTOFcalib->Init(run);
+ fTOFcalib->CreateCalObjects();
+ delete ftofT0maker;
+ ftofT0maker= new AliTOFT0maker(fESDpid,fTOFcalib);
+ }
+ AliInfo(Form("Stariting run #%i",run));
+}
+
//________________________________________________________________________
void AliAnalysisTaskFlowEvent::UserCreateOutputObjects()
{
exit(1);
}
+ if (!(fCutsRP&&fCutsPOI))
+ {
+ AliError("cuts not set");
+ return;
+ }
+ if (fCutsEvent)
+ {
+ if (!fCutsEvent->IsSelected(InputEvent())) return;
+ }
+
+ //PID
+ if (fCutsRP->GetParamType()==AliFlowTrackCuts::kMC)
+ {
+ fESDpid->GetTPCResponse().SetBetheBlochParameters( 2.15898e+00/50.,
+ 1.75295e+01,
+ 3.40030e-09,
+ 1.96178e+00,
+ 3.91720e+00);
+ }
+ else
+ {
+ fESDpid->GetTPCResponse().SetBetheBlochParameters( 0.0283086,
+ 2.63394e+01,
+ 5.04114e-11,
+ 2.12543e+00,
+ 4.88663e+00 );
+ }
+
+ fCutsRP->SetESDpid(fESDpid);
+ fCutsPOI->SetESDpid(fESDpid);
+
//set the common constants
AliFlowCommonConstants* cc = AliFlowCommonConstants::GetMaster();
cc->SetNbinsMult(fNbinsMult);
//use the new and temporarily inclomplete way of doing things
if (fAnalysisType == "AUTOMATIC")
{
- if (!(fCutsRP&&fCutsPOI))
- {
- AliError("cuts not set");
- return;
- }
- if (fCutsEvent)
- {
- if (!fCutsEvent->IsSelected(InputEvent())) return;
- }
+ //PID
+ recalibTOF(dynamic_cast<AliESDEvent*>(InputEvent()));
//first attach all possible information to the cuts
fCutsRP->SetEvent( InputEvent() ); //attach event
fCutsRP->SetMCevent( MCEvent() ); //attach mc truth
fCutsPOI->SetEvent( InputEvent() );
fCutsPOI->SetMCevent( MCEvent() );
+ fCutsRP->SetESDpid(fESDpid);
+ fCutsPOI->SetESDpid(fESDpid);
+
//then make the event
flowEvent = new AliFlowEvent( fCutsRP, fCutsPOI );
if (myESD)
// Called once at the end of the query -- do not call in case of CAF
}
-
+//___________________________________________________________
+void AliAnalysisTaskFlowEvent::recalibTOF(AliESDEvent *event)
+{
+ if(!(fTOFresolution>0.0))
+ return;
+ ftofT0maker->SetTimeResolution(fTOFresolution);
+ ftofT0maker->ComputeT0TOF(event);
+ ftofT0maker->WriteInESD(event);
+}
class TRandom3;
class AliAnalysisTaskSE;
class TString;
+class AliESDpid;
+class AliTOFcalib;
+class AliTOFT0maker;
class AliAnalysisTaskFlowEvent : public AliAnalysisTaskSE {
public:
virtual void UserCreateOutputObjects();
virtual void UserExec(Option_t *option);
virtual void Terminate(Option_t *);
+ virtual void NotifyRun();
void SetAnalysisType(TString type) { this->fAnalysisType = type; }
TString GetAnalysisType() const { return this->fAnalysisType; }
void SetFlow(Double_t v1, Double_t v2, Double_t v3, Double_t v4) {fV1=v1;fV2=v2;fV3=v3;fV4=v4;}
// end setters afterburner
+ //PID
+ void recalibTOF(AliESDEvent *event);
+ void SetTOFresolution(Float_t res) {fTOFresolution=res;}
+
private:
AliAnalysisTaskFlowEvent(const AliAnalysisTaskFlowEvent& aAnalysisTask);
TRandom3* fMyTRandom3; // TRandom3 generator
// end afterburner
+ //PID stuff
+ AliESDpid *fESDpid;//pid object
+ Float_t fTOFresolution;
+ AliTOFcalib* fTOFcalib;
+ AliTOFT0maker* ftofT0maker;
+
ClassDef(AliAnalysisTaskFlowEvent, 1); // example of analysis
};
: AliAnalysisTaskSE(),
fOutput(NULL),
fFillNtuple(kFALSE),
+ fDoCorrelations(kFALSE),
fNtuple(NULL),
fEventCuts(NULL),
fTrackCuts(NULL)
: AliAnalysisTaskSE(name),
fOutput(NULL),
fFillNtuple(kFALSE),
+ fDoCorrelations(kFALSE),
fNtuple(NULL),
fEventCuts(NULL),
fTrackCuts(NULL)
before->Add(hist); after->Add(hist->Clone()); //17
hist = new TH1D("charges", "charge distribution", 5,-2.5,2.5);
before->Add(hist); after->Add(hist->Clone()); //18
- hist = new TH1D("dphivsdeta", "#Delta#phi separation", 10000,-0.1,0.1);
+ hist = new TH1D("dphivsdeta", "#Delta#phi separation", 10000,-TMath::PiOver2(),TMath::Pi()+TMath::PiOver2());
before->Add(hist); after->Add(hist->Clone()); //19
hist = new TH1I("standardTPC_multiplicity", "standard TPC track multiplicity",10000,0,10000);
before->Add(hist); after->Add(hist->Clone()); //20
TH1* hstdspdtrmultB = dynamic_cast<TH1*>(before->At(23));
TH1* hstdspdtrmultA = dynamic_cast<TH1*>(after->At(23));
+ Bool_t passevent = fEventCuts->IsSelected(event);
+ Bool_t isSelectedEventSelection = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB);
+
AliMultiplicity* tracklets = const_cast<AliMultiplicity*>(event->GetMultiplicity());
Int_t ntracklets=0;
Int_t nspdclusters=0;
}
}
- AliFlowEventCuts newcuts;
- newcuts.SetRefMultCuts(fTrackCuts);
AliFlowEventCuts stdtpcrefmultcuts;
stdtpcrefmultcuts.SetRefMultMethod(AliFlowEventCuts::kTPConly);
AliFlowEventCuts stdv0refmultcuts;
AliFlowEventCuts stdspdrefmult;
stdspdrefmult.SetRefMultMethod(AliFlowEventCuts::kSPDtracklets);
- Int_t trackmult = newcuts.RefMult(event);
+ AliFlowEventSimple* flowevent=NULL;
+ AliFlowEventSimple* floweventin = dynamic_cast<AliFlowEventSimple*>(GetInputData(1));
+ if (!floweventin) flowevent = new AliFlowEvent(fTrackCuts,fTrackCuts);
+ else flowevent = new AliFlowEventSimple(*floweventin);
+
+ Int_t rpmult = flowevent->GetReferenceMultiplicity();
Int_t refmult = fEventCuts->RefMult(event);
Int_t refmultv0 = stdv0refmultcuts.RefMult(event);
Int_t refmulttpc = stdtpcrefmultcuts.RefMult(event);
Int_t refmultspdtr = stdspdrefmult.RefMult(event);
Int_t refmultspdcls = stdspd1refmult.RefMult(event);
- Bool_t passevent = fEventCuts->IsSelected(event);
-
htrackletmultB->Fill(ntracklets); if (passevent) htrackletmultA->Fill(ntracklets);
- htrackmultB->Fill(trackmult); if (passevent) htrackmultA->Fill( trackmult);
+ htrackmultB->Fill(rpmult); if (passevent) htrackmultA->Fill(rpmult);
hrefmultB->Fill(refmult); if (passevent) hrefmultA->Fill( refmult);
hstdv0multB->Fill(refmultv0); if (passevent) hstdv0multA->Fill( refmultv0);
hstdtpcmultB->Fill(refmulttpc); if (passevent) hstdtpcmultA->Fill( refmulttpc);
if (charge>0) {hptyieldplusB->Fill(pt); if (pass) hptyieldplusA->Fill(pt);}
if (charge<0) {hptyieldnegB->Fill(pt); if (pass) hptyieldnegA->Fill(pt);}
hchargesB->Fill(charge); if (pass) hchargesA->Fill(charge);
- for (Int_t j=i+1; j<ntracks; j++)
+ /////////////////////////////////////////////////////////////////////////////
+ //// correlation part ///////////////////////
+ /////////////////////////////////////////
+ if (fDoCorrelations)
{
- TObject* obj2 = fTrackCuts->GetInputObject(j);
- if (!obj2) continue;
- Bool_t pass2 = fTrackCuts->IsSelected(obj2,j);
- AliESDtrack* track2 = dynamic_cast<AliESDtrack*>(fTrackCuts->GetTrack());
- if (track2)
+ for (Int_t j=i+1; j<ntracks; j++)
{
- Double_t dphi = phi-track2->Phi();
- hphisepB->Fill(dphi); if (pass&&pass2) hphisepA->Fill(dphi);
+ TObject* obj2 = fTrackCuts->GetInputObject(j);
+ if (!obj2) continue;
+ Bool_t pass2 = fTrackCuts->IsSelected(obj2,j);
+ AliESDtrack* track2 = dynamic_cast<AliESDtrack*>(fTrackCuts->GetTrack());
+ if (track2)
+ {
+ Double_t dphi = phi-track2->Phi();
+ hphisepB->Fill(dphi); if (pass&&pass2) hphisepA->Fill(dphi);
+ }
}
- }
+ }//correlations
}
}
- if (ntracks!=0) meanpt = meanpt/nselected;
+ if (nselected!=0) meanpt = meanpt/nselected;
if (ntracks!=0) rawmeanpt = rawmeanpt/ntracks;
- Bool_t isSelectedEventSelection = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB);
-
///////////////////////////////////////////////////////////////////////
if (fFillNtuple)
{
Double_t qxb = 0.0;
Double_t qyb = 0.0;
Double_t qmb = 0.0;
- AliFlowVector qvec;
- AliFlowEventSimple* flowevent = dynamic_cast<AliFlowEventSimple*>(GetInputData(1));
- if (!flowevent) flowevent = new AliFlowEvent(fTrackCuts,fTrackCuts);
- AliFlowTrackCuts cutspos(*fTrackCuts);
- cutspos.SetEvent(event);
- cutspos.SetCharge(1);
- AliFlowTrackCuts cutsneg(*fTrackCuts);
- cutsneg.SetEvent(event);
- cutsneg.SetCharge(-1);
- AliFlowTrackCuts cutssuba(*fTrackCuts);
- cutssuba.SetEvent(event);
- cutssuba.SetEtaRange(-0.8,-0.1);
- AliFlowTrackCuts cutssubb(*fTrackCuts);
- cutssubb.SetEvent(event);
- cutssubb.SetEtaRange(0.1,0.8);
- AliFlowEvent evpos(&cutspos,&cutspos);
- AliFlowEvent evneg(&cutsneg,&cutsneg);
- AliFlowEvent evsuba(&cutssuba,&cutssuba);
- AliFlowEvent evsubb(&cutssubb, &cutssubb);
+ AliFlowVector qvec[2];
+
+ qvec[0] = flowevent->GetQ(2);
+ qx = qvec[0].X();
+ qy = qvec[0].Y();
+ qm = qvec[0].GetMult();
+ flowevent->TagSubeventsByCharge();
+ flowevent->Get2Qsub(qvec,2);
+ qxp = qvec[0].X();
+ qyp = qvec[0].Y();
+ qmp = qvec[0].GetMult();
+ qxn = qvec[1].X();
+ qyn = qvec[1].Y();
+ qmn = qvec[1].GetMult();
+ flowevent->TagSubeventsInEta(-0.8,-0.1,0.1,0.8);
+ flowevent->Get2Qsub(qvec,2);
+ qxa = qvec[0].X();
+ qya = qvec[0].Y();
+ qma = qvec[0].GetMult();
+ qxb = qvec[1].X();
+ qyb = qvec[1].Y();
+ qmb = qvec[1].GetMult();
- qvec = flowevent->GetQ(2);
- qx = qvec.X();
- qy = qvec.Y();
- qm = qvec.GetMult();
- qvec = evpos.GetQ(2);
- qxp = qvec.X();
- qyp = qvec.Y();
- qmp = qvec.GetMult();
- qvec = evneg.GetQ(2);
- qxn = qvec.X();
- qyn = qvec.Y();
- qmn = qvec.GetMult();
- qvec = evsuba.GetQ(2);
- qxa = qvec.X();
- qya = qvec.Y();
- qma = qvec.GetMult();
- qvec = evsubb.GetQ(2);
- qxb = qvec.X();
- qyb = qvec.Y();
- qmb = qvec.GetMult();
Float_t x[45];
- x[0]=meanpt; x[1]=qx; x[2]=qy; x[3]=trackmult; x[4]=refmult; x[5]=(isSelectedEventSelection)?1:0;
+ x[0]=meanpt; x[1]=qx; x[2]=qy; x[3]=rpmult; x[4]=refmult; x[5]=(isSelectedEventSelection)?1:0;
x[6]=vtxTPCx; x[7]=vtxTPCy; x[8]=vtxTPCz; x[9]=ntrackletsA; x[10]=ntrackletsC;
x[11]=mv0a; x[12]=mv0c; x[13]=zdcp1; x[14]=zdcn1; x[15]=zdcp2; x[16]=zdcn2;
x[17]=zdcpart1; x[18]=zdcpart2;
x[44]=qmb;
fNtuple->Fill(x);
}//if flowevent
+
+ delete flowevent;
}
//________________________________________________________________________
void SetTrackCuts(AliFlowTrackCuts* trackcuts) {fTrackCuts=trackcuts;}
void SetEventCuts(AliFlowEventCuts* eventcuts) {fEventCuts=eventcuts;}
- void SetFillNTuple(Bool_t b) {fFillNtuple=b;}
+ void SetFillNTuple(Bool_t b=kTRUE) {fFillNtuple=b;}
+ void SetDoCorrelations(Bool_t b=kTRUE) {fDoCorrelations=b;}
private:
TObjArray* fOutput; //output histograms
Bool_t fFillNtuple; //fil; the ntuple
+ Bool_t fDoCorrelations; //do the slow loopinloop correlations
TNtuple* fNtuple; //output ntuple
AliFlowEventCuts* fEventCuts; //AliAnalysisCuts - applied before analysis - for comparing different event classes
AliFlowTrackCuts* fTrackCuts; //AliFlowTrackCuts go in here
const AliESDEvent* esdevent = dynamic_cast<const AliESDEvent*>(event);
const AliMultiplicity* mult = esdevent->GetMultiplicity();
Int_t refmult=0;
- if (!fRefMultCuts)
+
+ switch (fRefMultMethod)
{
- switch (fRefMultMethod)
- {
- case kTPConly:
- fRefMultCuts = AliFlowTrackCuts::GetStandardTPCOnlyTrackCuts();
- fRefMultCuts->SetEtaRange(-0.8,0.8);
- fRefMultCuts->SetPtMin(0.15);
- break;
- case kSPDtracklets:
- fRefMultCuts = new AliFlowTrackCuts();
- fRefMultCuts->SetParamType(AliFlowTrackCuts::kESD_SPDtracklet);
- fRefMultCuts->SetEtaRange(-0.8,0.8);
- break;
- case kV0:
- if (!esdevent) return 0;
- vzero=esdevent->GetVZEROData();
- if (!vzero) return 0;
- refmult = TMath::Nint(vzero->GetMTotV0A()+vzero->GetMTotV0C());
- return refmult;
- case kSPD1clusters:
- if (!mult) return 0;
- refmult = mult->GetNumberOfITSClusters(1);
- return refmult;
- default:
- return 0;
- }
+ case kTPConly:
+ if (fRefMultCuts) break;
+ fRefMultCuts = AliFlowTrackCuts::GetStandardTPCOnlyTrackCuts();
+ fRefMultCuts->SetEtaRange(-0.8,0.8);
+ fRefMultCuts->SetPtMin(0.15);
+ break;
+ case kSPDtracklets:
+ if (fRefMultCuts) break;
+ fRefMultCuts = new AliFlowTrackCuts();
+ fRefMultCuts->SetParamType(AliFlowTrackCuts::kESD_SPDtracklet);
+ fRefMultCuts->SetEtaRange(-0.8,0.8);
+ break;
+ case kV0:
+ if (!esdevent) return 0;
+ vzero=esdevent->GetVZEROData();
+ if (!vzero) return 0;
+ refmult = TMath::Nint(vzero->GetMTotV0A()+vzero->GetMTotV0C());
+ return refmult;
+ case kSPD1clusters:
+ if (!mult) return 0;
+ refmult = mult->GetNumberOfITSClusters(1);
+ return refmult;
+ default:
+ return 0;
}
fRefMultCuts->SetEvent(const_cast<AliVEvent*>(event));
#include <limits.h>
#include <float.h>
+#include <TMatrix.h>
#include "TParticle.h"
#include "TObjArray.h"
#include "AliStack.h"
#include "AliFlowTrack.h"
#include "AliFlowTrackCuts.h"
#include "AliLog.h"
+#include "AliESDpid.h"
ClassImp(AliFlowTrackCuts)
fCutChi2PerClusterTPC(kFALSE),
fMaxChi2PerClusterTPC(FLT_MAX),
fMinChi2PerClusterTPC(-FLT_MAX),
+ fCutNClustersTPC(kFALSE),
+ fNClustersTPCMax(INT_MAX),
+ fNClustersTPCMin(INT_MIN),
fParamType(kGlobal),
fParamMix(kPure),
fTrack(NULL),
fMCevent(NULL),
fMCparticle(NULL),
fEvent(NULL),
- fTPCtrack()
+ fTPCtrack(),
+ fESDpid(NULL),
+ fPIDsource(kTPCTOFpid),
+ fTPCpidCuts(NULL),
+ fTOFpidCuts(NULL),
+ fTPCTOFpidCrossOverPt(0.4),
+ fAliPID(AliPID::kPion)
{
//constructor
}
fCutChi2PerClusterTPC(that.fCutChi2PerClusterTPC),
fMaxChi2PerClusterTPC(that.fMaxChi2PerClusterTPC),
fMinChi2PerClusterTPC(that.fMinChi2PerClusterTPC),
+ fCutNClustersTPC(that.fCutNClustersTPC),
+ fNClustersTPCMax(that.fNClustersTPCMax),
+ fNClustersTPCMin(that.fNClustersTPCMin),
fParamType(that.fParamType),
fParamMix(that.fParamMix),
fTrack(NULL),
fMCevent(NULL),
fMCparticle(NULL),
fEvent(NULL),
- fTPCtrack()
+ fTPCtrack(),
+ fESDpid(that.fESDpid),
+ fPIDsource(that.fPIDsource),
+ fTPCpidCuts(NULL),
+ fTOFpidCuts(NULL),
+ fTPCTOFpidCrossOverPt(that.fTPCTOFpidCrossOverPt),
+ fAliPID(that.fAliPID)
{
//copy constructor
+ if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts));
+ if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts));
}
//-----------------------------------------------------------------------
fCutChi2PerClusterTPC=that.fCutChi2PerClusterTPC;
fMaxChi2PerClusterTPC=that.fMaxChi2PerClusterTPC;
fMinChi2PerClusterTPC=that.fMinChi2PerClusterTPC;
+ fCutNClustersTPC=that.fCutNClustersTPC;
+ fNClustersTPCMax=that.fNClustersTPCMax;
+ fNClustersTPCMin=that.fNClustersTPCMin;
fParamType=that.fParamType;
fParamMix=that.fParamMix;
fMCparticle=NULL;
fEvent=NULL;
+ fESDpid = that.fESDpid;
+ fPIDsource = that.fPIDsource;
+
+ if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts));
+ if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts));
+ fTPCTOFpidCrossOverPt=that.fTPCTOFpidCrossOverPt;
+
+ fAliPID=that.fAliPID;
+
return *this;
}
{
//dtor
delete fAliESDtrackCuts;
+ delete fTPCpidCuts;
+ delete fTOFpidCuts;
}
//-----------------------------------------------------------------------
Bool_t pass=kTRUE;
//check the common cuts for the current particle fTrack (MC,AOD,ESD)
+ Double_t pt = fTrack->Pt();
if (!fFakesAreOK) {if (fTrackLabel<0) pass=kFALSE;}
- if (fCutPt) {if (fTrack->Pt() < fPtMin || fTrack->Pt() >= fPtMax ) pass=kFALSE;}
+ if (fCutPt) {if (pt < fPtMin || pt >= fPtMax ) pass=kFALSE;}
if (fCutEta) {if (fTrack->Eta() < fEtaMin || fTrack->Eta() >= fEtaMax ) pass=kFALSE;}
if (fCutPhi) {if (fTrack->Phi() < fPhiMin || fTrack->Phi() >= fPhiMax ) pass=kFALSE;}
if (fRequireCharge) {if (fTrack->Charge() == 0) pass=kFALSE;}
{
//in case of an MC particle the charge is stored in units of 1/3|e|
Int_t charge = TMath::Nint(fTrack->Charge()/3.0); //mc particles have charge in units of 1/3e
- return (charge==fCharge);
+ if (charge!=fCharge) pass=kFALSE;
}
//if(fCutPID) {if (fTrack->PID() != fPID) pass=kFALSE;}
if (zout < fIgnoreTPCzRangeMin || zout > fIgnoreTPCzRangeMax) pass=kFALSE;
}
}
+
if (!fAliESDtrackCuts->IsSelected(static_cast<AliESDtrack*>(fTrack))) pass=kFALSE;
+
+ Int_t ntpccls = ( fParamType==kESD_TPConly )?
+ esdTrack->GetTPCNclsIter1():esdTrack->GetTPCNcls();
if (fCutChi2PerClusterTPC)
{
Float_t tpcchi2 = (fParamType==kESD_TPConly)?
esdTrack->GetTPCchi2Iter1():esdTrack->GetTPCchi2();
- Int_t ntpccls = esdTrack->GetTPCNcls();
tpcchi2 = (ntpccls>0)?tpcchi2/ntpccls:-FLT_MAX;
if (tpcchi2<fMinChi2PerClusterTPC || tpcchi2 >=fMaxChi2PerClusterTPC)
pass=kFALSE;
}
+
+ if (fCutNClustersTPC)
+ {
+ if (ntpccls < fNClustersTPCMin || ntpccls > fNClustersTPCMax) pass=kFALSE;
+ }
+
+ if (fCutPID)
+ {
+ switch (fPIDsource)
+ {
+ case kTPCpid:
+ if (!PassesTPCpidCut(esdTrack)) pass=kFALSE;
+ break;
+ case kTOFpid:
+ if (!PassesTOFpidCut(esdTrack)) pass=kFALSE;
+ break;
+ case kTPCTOFpid:
+ if (pt< fTPCTOFpidCrossOverPt)
+ {
+ if (!PassesTPCpidCut(esdTrack)) pass=kFALSE;
+ }
+ else //if (pt>=fTPCTOFpidCrossOverPt)
+ {
+ if (!PassesTOFpidCut(esdTrack)) pass=kFALSE;
+ }
+ break;
+ default:
+ printf("AliFlowTrackCuts::PassesCuts() this should never be called!\n");
+ pass=kFALSE;
+ break;
+ }
+ }
}
return pass; //true by default, if we didn't set any cuts
{
default:
fTrack = track;
+ break;
}
}
break;
default:
fTrack = track;
+ break;
}
}
tmpTParticle = fMCparticle->Particle();
tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
flowtrack->SetPt(tmpAliMCParticle->Pt());
+ break;
default:
flowtrack = new AliFlowTrack();
flowtrack->SetPhi(fTrackPhi);
flowtrack->SetEta(fTrackEta);
+ break;
}
flowtrack->SetSource(AliFlowTrack::kFromTracklet);
}
if (!fMCparticle) return NULL;
flowtrack = new AliFlowTrack(fTrack);
flowtrack->SetPt(fMCparticle->Pt());
+ break;
case kTrackWithPtFromFirstMother:
if (!fMCparticle) return NULL;
flowtrack = new AliFlowTrack(fTrack);
tmpTParticle = fMCparticle->Particle();
tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
flowtrack->SetPt(tmpAliMCParticle->Pt());
+ break;
default:
flowtrack = new AliFlowTrack(fTrack);
+ break;
}
if (fParamType==kMC) flowtrack->SetSource(AliFlowTrack::kFromMC);
else if (dynamic_cast<AliESDtrack*>(fTrack)) flowtrack->SetSource(AliFlowTrack::kFromESD);
fTrackEta=0.0;
fTrackPhi=0.0;
}
+
+//-----------------------------------------------------------------------
+Bool_t AliFlowTrackCuts::PassesTOFpidCut(AliESDtrack* t )
+{
+ //check if passes PID cut using timing in TOF
+ if (!fESDpid) return kFALSE;
+ if (!(t && (t->GetStatus() & AliESDtrack::kTOFout) && (t->GetStatus() & AliESDtrack::kTIME)
+ && (t->GetTOFsignal() > 12000) && (t->GetTOFsignal() < 100000) && (t->GetIntegratedLength() > 365)))
+ return kFALSE;
+ Float_t pt = t->Pt();
+ Float_t p = t->GetP();
+ Float_t trackT0 = fESDpid->GetTOFResponse().GetStartTime(p);
+ Float_t timeTOF = t->GetTOFsignal()- trackT0;
+ //2=pion 3=kaon 4=protons
+ Double_t inttimes[5] = {-1.0,-1.0,-1.0,-1.0,-1.0};
+ t->GetIntegratedTimes(inttimes);
+ //construct the pid index because it's screwed up in TOF
+ Int_t pid = 0;
+ switch (fAliPID)
+ {
+ case AliPID::kPion:
+ pid=2;
+ break;
+ case AliPID::kKaon:
+ pid=3;
+ break;
+ case AliPID::kProton:
+ pid=4;
+ break;
+ default:
+ return kFALSE;
+ }
+ Float_t s = timeTOF-inttimes[pid];
+
+ Float_t* arr = fTOFpidCuts->GetMatrixArray();
+ Int_t col = TMath::BinarySearch(fTOFpidCuts->GetNcols(),arr,static_cast<Float_t>(pt));
+ if (col<0) return kFALSE;
+ Float_t min = (*fTOFpidCuts)(1,col);
+ Float_t max = (*fTOFpidCuts)(2,col);
+
+ //printf("TOF pid cut %s\n",(s>min && s<max)?"PASS":"FAIL");
+ return (s>min && s<max);
+}
+
+//-----------------------------------------------------------------------
+Bool_t AliFlowTrackCuts::PassesTPCpidCut(AliESDtrack* track)
+{
+ //check if passes PID cut using dedx signal in the TPC
+ if (!fESDpid)
+ {
+ return kFALSE;
+ }
+ if (!fTPCpidCuts)
+ {
+ printf("no TPCpidCuts\n");
+ return kFALSE;
+ }
+
+ const AliExternalTrackParam* tpcparam = track->GetInnerParam();
+ if (!tpcparam) return kFALSE;
+ Float_t sigExp = fESDpid->GetTPCResponse().GetExpectedSignal(tpcparam->GetP(), fAliPID);
+ Float_t sigTPC = track->GetTPCsignal();
+ Float_t s = (sigTPC-sigExp)/sigExp;
+ Double_t pt = track->Pt();
+
+ Float_t* arr = fTPCpidCuts->GetMatrixArray();
+ Int_t col = TMath::BinarySearch(fTPCpidCuts->GetNcols(),arr,static_cast<Float_t>(pt));
+ if (col<0) return kFALSE;
+ Float_t min = (*fTPCpidCuts)(1,col);
+ Float_t max = (*fTPCpidCuts)(2,col);
+
+ //printf("------------TPC pid cut %s\n",(s>min && s<max)?"PASS":"FAIL");
+ return (s>min && s<max);
+}
+
+//-----------------------------------------------------------------------
+void AliFlowTrackCuts::InitPIDcuts()
+{
+ //init matrices with PID cuts
+ TMatrixF* t = NULL;
+ if (!fTPCpidCuts)
+ {
+ if (fAliPID==AliPID::kPion)
+ {
+ t = new TMatrixF(3,10);
+ (*t)(0,0) = 0.20; (*t)(1,0) = -0.4; (*t)(2,0) = 0.2;
+ (*t)(0,1) = 0.25; (*t)(1,1) = -0.4; (*t)(2,1) = 0.2;
+ (*t)(0,2) = 0.30; (*t)(1,2) = -0.4; (*t)(2,2) = 0.25;
+ (*t)(0,3) = 0.35; (*t)(1,3) = -0.4; (*t)(2,3) = 0.25;
+ (*t)(0,4) = 0.40; (*t)(1,4) = -0.4; (*t)(2,4) = 0.3;
+ (*t)(0,5) = 0.45; (*t)(1,5) = -0.4; (*t)(2,5) = 0.3;
+ (*t)(0,6) = 0.50; (*t)(1,6) = -0.4; (*t)(2,6) = 0.25;
+ (*t)(0,7) = 0.55; (*t)(1,7) = -0.4; (*t)(2,7) = 0.15;
+ (*t)(0,8) = 0.60; (*t)(1,8) = -0.4; (*t)(2,8) = 0.1;
+ (*t)(0,9) = 0.65; (*t)(1,9) = 0; (*t)(2,9) = 0;
+ }
+ else
+ if (fAliPID==AliPID::kProton)
+ {
+ t = new TMatrixF(3,16);
+ (*t)(0,0) = 0.20; (*t)(1,0) = 0; (*t)(2,0) = 0.3;
+ (*t)(0,1) = 0.25; (*t)(1,1) = -0.2; (*t)(2,1) = 0.6;
+ (*t)(0,2) = 0.30; (*t)(1,2) = -0.2; (*t)(2,2) = 0.6;
+ (*t)(0,3) = 0.35; (*t)(1,3) = -0.2; (*t)(2,3) = 0.6;
+ (*t)(0,4) = 0.40; (*t)(1,4) = -0.2; (*t)(2,4) = 0.6;
+ (*t)(0,5) = 0.45; (*t)(1,5) = -0.15; (*t)(2,5) = 0.6;
+ (*t)(0,6) = 0.50; (*t)(1,6) = -0.1; (*t)(2,6) = 0.6;
+ (*t)(0,7) = 0.55; (*t)(1,7) = -0.05; (*t)(2,7) = 0.45;
+ (*t)(0,8) = 0.60; (*t)(1,8) = -0.05; (*t)(2,8) = 0.45;
+ (*t)(0,9) = 0.65; (*t)(1,9) = -0.05; (*t)(2,9) = 0.45;
+ (*t)(0,10) = 0.70; (*t)(1,10) = -0.05; (*t)(2,10) = 0.45;
+ (*t)(0,11) = 0.75; (*t)(1,11) = -0.05; (*t)(2,11) = 0.45;
+ (*t)(0,12) = 0.80; (*t)(1,12) = 0; (*t)(2,12) = 0.45;
+ (*t)(0,13) = 0.85; (*t)(1,13) = 0; (*t)(2,13) = 0.45;
+ (*t)(0,14) = 0.90; (*t)(1,14) = 0; (*t)(2,14) = 0.45;
+ (*t)(0,15) = 0.95; (*t)(1,15) = 0; (*t)(2,15) = 0;
+ }
+ else
+ if (fAliPID==AliPID::kKaon)
+ {
+ t = new TMatrixF(3,7);
+ (*t)(0,0) = 0.20; (*t)(1,0) = -0.2; (*t)(2,0) = 0.4;
+ (*t)(0,1) = 0.25; (*t)(1,1) =-0.15; (*t)(2,1) = 0.4;
+ (*t)(0,2) = 0.30; (*t)(1,2) = -0.1; (*t)(2,2) = 0.4;
+ (*t)(0,3) = 0.35; (*t)(1,3) = -0.1; (*t)(2,3) = 0.4;
+ (*t)(0,4) = 0.40; (*t)(1,4) = -0.1; (*t)(2,4) = 0.6;
+ (*t)(0,5) = 0.45; (*t)(1,5) = -0.1; (*t)(2,5) = 0.6;
+ (*t)(0,6) = 0.50; (*t)(1,6) = 0; (*t)(2,6) =0;
+ }
+ fTPCpidCuts=t;
+ }
+ if (!fTOFpidCuts)
+ {
+ if (fAliPID==AliPID::kPion)
+ {
+ t = new TMatrixF(3,26);
+ (*t)(0,0) = 0.3; (*t)(1,0) = -700; (*t)(2,0) = 700;
+ (*t)(0,1) = 0.35; (*t)(1,1) = -800; (*t)(2,1) = 800;
+ (*t)(0,2) = 0.40; (*t)(1,2) = -600; (*t)(2,2) = 800;
+ (*t)(0,3) = 0.45; (*t)(1,3) = -500; (*t)(2,3) = 700;
+ (*t)(0,4) = 0.50; (*t)(1,4) = -400; (*t)(2,4) = 700;
+ (*t)(0,5) = 0.55; (*t)(1,5) = -400; (*t)(2,5) = 700;
+ (*t)(0,6) = 0.60; (*t)(1,6) = -400; (*t)(2,6) = 700;
+ (*t)(0,7) = 0.65; (*t)(1,7) = -400; (*t)(2,7) = 700;
+ (*t)(0,8) = 0.70; (*t)(1,8) = -400; (*t)(2,8) = 700;
+ (*t)(0,9) = 0.75; (*t)(1,9) = -400; (*t)(2,9) = 700;
+ (*t)(0,10) = 0.80; (*t)(1,10) = -400; (*t)(2,10) = 600;
+ (*t)(0,11) = 0.85; (*t)(1,11) = -400; (*t)(2,11) = 600;
+ (*t)(0,12) = 0.90; (*t)(1,12) = -400; (*t)(2,12) = 600;
+ (*t)(0,13) = 0.95; (*t)(1,13) = -400; (*t)(2,13) = 600;
+ (*t)(0,14) = 1.00; (*t)(1,14) = -400; (*t)(2,14) = 550;
+ (*t)(0,15) = 1.10; (*t)(1,15) = -400; (*t)(2,15) = 450;
+ (*t)(0,16) = 1.20; (*t)(1,16) = -400; (*t)(2,16) = 400;
+ (*t)(0,17) = 1.30; (*t)(1,17) = -400; (*t)(2,17) = 300;
+ (*t)(0,18) = 1.40; (*t)(1,18) = -400; (*t)(2,18) = 300;
+ (*t)(0,19) = 1.50; (*t)(1,19) = -400; (*t)(2,19) = 250;
+ (*t)(0,20) = 1.60; (*t)(1,20) = -400; (*t)(2,20) = 200;
+ (*t)(0,21) = 1.70; (*t)(1,21) = -400; (*t)(2,21) = 150;
+ (*t)(0,22) = 1.80; (*t)(1,22) = -400; (*t)(2,22) = 100;
+ (*t)(0,23) = 1.90; (*t)(1,23) = -400; (*t)(2,23) = 70;
+ (*t)(0,24) = 2.00; (*t)(1,24) = -400; (*t)(2,24) = 50;
+ (*t)(0,25) = 2.10; (*t)(1,25) = 0; (*t)(2,25) = 0;
+ }
+ else
+ if (fAliPID==AliPID::kProton)
+ {
+ t = new TMatrixF(3,39);
+ (*t)(0,0) = 0.3; (*t)(1,0) = 0; (*t)(2,0) = 0;
+ (*t)(0,1) = 0.35; (*t)(1,1) = 0; (*t)(2,1) = 0;
+ (*t)(0,2) = 0.40; (*t)(1,2) = 0; (*t)(2,2) = 0;
+ (*t)(0,3) = 0.45; (*t)(1,3) = 0; (*t)(2,3) = 0;
+ (*t)(0,4) = 0.50; (*t)(1,4) = 0; (*t)(2,4) = 0;
+ (*t)(0,5) = 0.55; (*t)(1,5) = -900; (*t)(2,5) = 600;
+ (*t)(0,6) = 0.60; (*t)(1,6) = -800; (*t)(2,6) = 600;
+ (*t)(0,7) = 0.65; (*t)(1,7) = -800; (*t)(2,7) = 600;
+ (*t)(0,8) = 0.70; (*t)(1,8) = -800; (*t)(2,8) = 600;
+ (*t)(0,9) = 0.75; (*t)(1,9) = -700; (*t)(2,9) = 500;
+ (*t)(0,10) = 0.80; (*t)(1,10) = -700; (*t)(2,10) = 500;
+ (*t)(0,11) = 0.85; (*t)(1,11) = -700; (*t)(2,11) = 500;
+ (*t)(0,12) = 0.90; (*t)(1,12) = -600; (*t)(2,12) = 500;
+ (*t)(0,13) = 0.95; (*t)(1,13) = -600; (*t)(2,13) = 500;
+ (*t)(0,14) = 1.00; (*t)(1,14) = -600; (*t)(2,14) = 500;
+ (*t)(0,15) = 1.10; (*t)(1,15) = -600; (*t)(2,15) = 500;
+ (*t)(0,16) = 1.20; (*t)(1,16) = -500; (*t)(2,16) = 500;
+ (*t)(0,17) = 1.30; (*t)(1,17) = -500; (*t)(2,17) = 500;
+ (*t)(0,18) = 1.40; (*t)(1,18) = -500; (*t)(2,18) = 500;
+ (*t)(0,19) = 1.50; (*t)(1,19) = -500; (*t)(2,19) = 500;
+ (*t)(0,20) = 1.60; (*t)(1,20) = -400; (*t)(2,20) = 500;
+ (*t)(0,21) = 1.70; (*t)(1,21) = -400; (*t)(2,21) = 500;
+ (*t)(0,22) = 1.80; (*t)(1,22) = -400; (*t)(2,22) = 500;
+ (*t)(0,23) = 1.90; (*t)(1,23) = -400; (*t)(2,23) = 500;
+ (*t)(0,24) = 2.00; (*t)(1,24) = -400; (*t)(2,24) = 500;
+ (*t)(0,25) = 2.10; (*t)(1,25) = -350; (*t)(2,25) = 500;
+ (*t)(0,26) = 2.20; (*t)(1,26) = -350; (*t)(2,26) = 500;
+ (*t)(0,27) = 2.30; (*t)(1,27) = -300; (*t)(2,27) = 500;
+ (*t)(0,28) = 2.40; (*t)(1,28) = -300; (*t)(2,28) = 500;
+ (*t)(0,29) = 3.30; (*t)(1,29) = -300; (*t)(2,29) = 500;
+ (*t)(0,30) = 3.30; (*t)(1,30) = -250; (*t)(2,30) = 500;
+ (*t)(0,31) = 3.30; (*t)(1,31) = -200; (*t)(2,31) = 500;
+ (*t)(0,32) = 3.30; (*t)(1,32) = -150; (*t)(2,32) = 500;
+ (*t)(0,33) = 3.30; (*t)(1,33) = -150; (*t)(2,33) = 500;
+ (*t)(0,34) = 3.30; (*t)(1,34) = -100; (*t)(2,34) = 400;
+ (*t)(0,35) = 3.30; (*t)(1,35) = -100; (*t)(2,35) = 400;
+ (*t)(0,36) = 3.30; (*t)(1,36) = 0; (*t)(2,36) = 0;
+ (*t)(0,37) = 3.30; (*t)(1,37) = 0; (*t)(2,37) = 0;
+ (*t)(0,38) = 3.30; (*t)(1,38) = 0; (*t)(2,38) = 0;
+ }
+ else
+ if (fAliPID==AliPID::kKaon)
+ {
+ t = new TMatrixF(3,23);
+ (*t)(0,0) = 0.3; (*t)(1,0) = 0; (*t)(2,0) = 0;
+ (*t)(0,1) = 0.35; (*t)(1,1) = 0; (*t)(2,1) = 0;
+ (*t)(0,2) = 0.40; (*t)(1,2) = -800; (*t)(2,2) = 600;
+ (*t)(0,3) = 0.45; (*t)(1,3) = -800; (*t)(2,3) = 600;
+ (*t)(0,4) = 0.50; (*t)(1,4) = -800; (*t)(2,4) = 600;
+ (*t)(0,5) = 0.55; (*t)(1,5) = -800; (*t)(2,5) = 600;
+ (*t)(0,6) = 0.60; (*t)(1,6) = -800; (*t)(2,6) = 600;
+ (*t)(0,7) = 0.65; (*t)(1,7) = -700; (*t)(2,7) = 600;
+ (*t)(0,8) = 0.70; (*t)(1,8) = -600; (*t)(2,8) = 600;
+ (*t)(0,9) = 0.75; (*t)(1,9) = -600; (*t)(2,9) = 500;
+ (*t)(0,10) = 0.80; (*t)(1,10) = -500; (*t)(2,10) = 500;
+ (*t)(0,11) = 0.85; (*t)(1,11) = -500; (*t)(2,11) = 500;
+ (*t)(0,12) = 0.90; (*t)(1,12) = -400; (*t)(2,12) = 500;
+ (*t)(0,13) = 0.95; (*t)(1,13) = -400; (*t)(2,13) = 500;
+ (*t)(0,14) = 1.00; (*t)(1,14) = -400; (*t)(2,14) = 500;
+ (*t)(0,15) = 1.10; (*t)(1,15) = -350; (*t)(2,15) = 450;
+ (*t)(0,16) = 1.20; (*t)(1,16) = -300; (*t)(2,16) = 400;
+ (*t)(0,17) = 1.30; (*t)(1,17) = -300; (*t)(2,17) = 400;
+ (*t)(0,18) = 1.40; (*t)(1,18) = -250; (*t)(2,18) = 400;
+ (*t)(0,19) = 1.50; (*t)(1,19) = -200; (*t)(2,19) = 400;
+ (*t)(0,20) = 1.60; (*t)(1,20) = -150; (*t)(2,20) = 400;
+ (*t)(0,21) = 1.70; (*t)(1,21) = -100; (*t)(2,21) = 400;
+ (*t)(0,22) = 1.80; (*t)(1,22) = 0; (*t)(2,22) = 0;
+ }
+ fTOFpidCuts=t;
+ }
+}
#ifndef ALIFLOWTRACKCUTS_H
#define ALIFLOWTRACKCUTS_H
+#include <TMatrix.h>
#include "AliFlowTrackSimpleCuts.h"
#include "AliESDtrackCuts.h"
#include "TMCProcess.h"
#include "AliESDtrack.h"
+#include "AliPID.h"
class TObjArray;
class AliVParticle;
class AliMCEvent;
class AliVEvent;
class AliMultiplicity;
+class AliESDpid;
class AliFlowTrackCuts : public AliFlowTrackSimpleCuts {
enum trackParameterType { kMC, kGlobal, kESD_TPConly, kESD_SPDtracklet };
enum trackParameterMix { kPure, kTrackWithMCkine, kTrackWithMCPID, kTrackWithMCpt, kTrackWithPtFromFirstMother };
+ enum PIDsource {kTPCpid, kTOFpid, kTPCTOFpid};
//setters (interface to AliESDtrackCuts)
void SetMinNClustersTPC( Int_t a ) {fAliESDtrackCuts->SetMinNClustersTPC(a);}
TObject* GetInputObject(Int_t i);
void Clear(Option_t* option="");
+ //PID
+ void SetPID(AliPID::EParticleType pid, PIDsource s=kTPCTOFpid) {fAliPID=pid; fPIDsource=s; fCutPID=kTRUE; InitPIDcuts();}
+ void SetESDpid(AliESDpid* o) {fESDpid=o;}
+ void SetTPCTOFpidCrossOverPt(Double_t pt) {fTPCTOFpidCrossOverPt=pt;}
+ void SetTPCpidCuts(TMatrixF* mat) {fTPCpidCuts=new TMatrixF(*mat);}
+ void SetTOFpidCuts(TMatrixF* mat) {fTOFpidCuts=new TMatrixF(*mat);}
+
protected:
Bool_t PassesCuts(AliVParticle* track);
Bool_t PassesCuts(AliFlowTrackSimple* track);
Bool_t PassesCuts(AliMultiplicity* track, Int_t id);
Bool_t PassesMCcuts();
Bool_t PassesMCcuts(AliMCEvent* mcevent, Int_t label);
+ Bool_t PassesTPCpidCut(AliESDtrack* track);
+ Bool_t PassesTOFpidCut(AliESDtrack* track);
void HandleESDtrack(AliESDtrack* track);
void HandleVParticle(AliVParticle* track);
void DefineHistograms();
+ void InitPIDcuts();
//the cuts
AliESDtrackCuts* fAliESDtrackCuts; //alianalysis cuts
Bool_t fCutChi2PerClusterTPC; //cut on tpc chi2
Float_t fMaxChi2PerClusterTPC; //max chi2 tpc/cluster
Float_t fMinChi2PerClusterTPC; //min chi2 tpc/cluster
+ Bool_t fCutNClustersTPC; //cut on clusters?
+ Int_t fNClustersTPCMax; //max tpc ncls
+ Int_t fNClustersTPCMin; //min tpc clusters
trackParameterType fParamType; //parameter type tu cut on
trackParameterMix fParamMix; //parameter mixing
AliVEvent* fEvent; //!placeholder for current event
AliESDtrack fTPCtrack; //!placeholder for TPC only track to avoid new/delete on every track
+ //PID
+ AliESDpid* fESDpid; //pid obj
+ PIDsource fPIDsource; //pid source
+ TMatrixF* fTPCpidCuts; //tpc pid cuts
+ TMatrixF* fTOFpidCuts; //tof pid cuts
+ Double_t fTPCTOFpidCrossOverPt; //pt cross over for pid, below TPC is taken, above TOF
+ AliPID::EParticleType fAliPID; //alipid
+
ClassDef(AliFlowTrackCuts,4)
};
// generate the control ntuple
Bool_t FillQAntuple=kFALSE;
+Bool_t DoQAcorrelations=kFALSE;
// RUN SETTINGS
// Flow analysis method can be:(set to kTRUE or kFALSE)
//cutsPOI->SetMaxNsigmaToVertex(1.e+10);
//cutsPOI->SetRequireSigmaToVertex(kFALSE);
cutsPOI->SetAcceptKinkDaughters(kFALSE);
+ //cutsPOI->SetPID(AliPID::kProton, AliFlowTrackCuts::kTOFpid);
+ //cutsPOI->SetPID(AliPID::kPion, AliFlowTrackCuts::kTPCpid);
+ //cutsPOI->SetPID(AliPID::kProton, AliFlowTrackCuts::kTPCTOFpid);
+ //cutsPOI->SetTPCTOFpidCrossOverPt(0.4);
+
// common constants:
Int_t nBinsMult = 10000;
// Pass cuts for RPs and POIs to the task:
taskFE->SetCutsRP(cutsRP);
taskFE->SetCutsPOI(cutsPOI);
-
+ taskFE->SetTOFresolution(80);
+
// Pass common constants:
taskFE->SetNbinsMult(nBinsMult);
taskFE->SetNbinsPt(nBinsPt);
taskQAflow->SetEventCuts(cutsEvent);
taskQAflow->SetTrackCuts(cutsRP);
taskQAflow->SetFillNTuple(FillQAntuple);
+ taskQAflow->SetDoCorrelations(DoQAcorrelations);
mgr->AddTask(taskQAflow);
// Create the output container for the data produced by the task
mgr->ConnectInput(taskQAflow,0,mgr->GetCommonInputContainer());
mgr->ConnectInput(taskQAflow,1,coutputFE);
mgr->ConnectOutput(taskQAflow,1,coutputQAtask);
- mgr->ConnectOutput(taskQAflow,2,coutputQAtaskTree);
+ if (FillQAntuple) mgr->ConnectOutput(taskQAflow,2,coutputQAtaskTree);
}
AliAnalysisAlien *plugin = new AliAnalysisAlien();
// Set if you want to use par files on Grid:
- Bool_t bUseParFiles = kFALSE;
+ Bool_t bUseParFiles = kTRUE;
// Set the run mode (can be "full", "test", "offline", "submit" or "terminate")
//plugin->SetRunMode("test");
//plugin->SetRunMode("submit");
plugin->SetRunMode("full");
//plugin->SetRunMode("terminate");
- plugin->SetNtestFiles(1); // Relevant only for run mode "test"
+ plugin->SetNtestFiles(3); // Relevant only for run mode "test"
// Set versions of used packages
plugin->SetAPIVersion("V1.1x");
plugin->SetROOTVersion("v5-27-06b");
- plugin->SetAliROOTVersion("v4-21-04-AN");
+ plugin->SetAliROOTVersion("v4-21-07-AN");
// Declare input data to be processed - can be done in two ways:
// METHOD 1: Create automatically XML collections using alien 'find' command.
// ============================================================================
// Example 2: Real data (set in macro runFlowTask.C: DATA = kTRUE, MCEP = kFALSE)
plugin->SetGridDataDir("/alice/data/2010/LHC10h");
- plugin->SetDataPattern("*ESDs/pass1/*ESDs.root");
+ plugin->SetDataPattern("*ESDs/pass1_5plus/*ESDs.root");
plugin->SetRunPrefix("000"); // IMPORTANT!
- plugin->AddRunNumber(137042);
+ plugin->AddRunNumber(137161);
// plugin->AddRunNumber(119844); // Alternatively use e.g. plugin->SetRunRange(104044,106044); to add more runs in one go
plugin->SetOutputToRunNo();
// ============================================================================
// Define alien work directory where all files will be copied. Relative to alien $HOME.
plugin->SetGridWorkingDir("data");
// Declare alien output directory. Relative to working directory.
- plugin->SetGridOutputDir("output"); // In this case will be $HOME/work/output
+ plugin->SetGridOutputDir("output1_5plus"); // In this case will be $HOME/work/output
// Declare the analysis source files names separated by blancs. To be compiled runtime
// using ACLiC on the worker nodes:
// ... (if this is needed see in official tutorial example how to do it!)
// Declare all libraries (other than the default ones for the framework. These will be
// loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
+ //plugin->SetAdditionalLibs("libCORRFW.so libTOFbase.so libTOFrec.so");
if(!bUseParFiles)
{
- plugin->SetAdditionalLibs("libPWG2flowCommon.so libPWG2flowTasks.so");
- } else // load libs via par files
- {
- plugin->EnablePackage("PWG2flowCommon.par");
- plugin->EnablePackage("PWG2flowTasks.par");
- }
+ plugin->SetAdditionalLibs("libGui.so libProof.so libMinuit.so libXMLParser.so libRAWDatabase.so libRAWDatarec.so libCDB.so libSTEERBase.so libSTEER.so libTOFbase.so libTOFrec.so libPWG2flowCommon.so libPWG2flowTasks.so");
+ }
+ else // load libs via par files
+ {
+ plugin->SetAdditionalLibs("libGui.so libProof.so libMinuit.so libXMLParser.so libRAWDatabase.so libRAWDatarec.so libCDB.so libSTEERBase.so libSTEER.so libTOFbase.so libTOFrec.so");
+ plugin->EnablePackage("PWG2flowCommon.par");
+ plugin->EnablePackage("PWG2flowTasks.par");
+ }
// Do not specify your outputs by hand anymore:
plugin->SetDefaultOutputs(kTRUE);
// To specify your outputs by hand set plugin->SetDefaultOutputs(kFALSE); and comment in line plugin->SetOutputFiles("...");
//Bool_t DATA = kFALSE, const Char_t* dataDir="/Users/snelling/alice_data/Therminator_midcentral", Int_t offset = 0)
void runFlowTaskCentralityTrain(Int_t mode = mPROOF, Int_t nRuns = 50000000,
- Bool_t DATA = kTRUE, const Char_t* dataDir="/alice/data/LHC10h_000137161_p1_plusplusplus", Int_t offset=0)
+ Bool_t DATA = kTRUE, const Char_t* dataDir="/alice/data/LHC10h_000137161_p1_plusplusplus", Int_t offset=0)
+//void runFlowTaskCentralityTrain(Int_t mode = mLocal, Int_t nRuns = 50000000,
+// Bool_t DATA = kTRUE, const Char_t* dataDir="./data/", Int_t offset=0)
//void runFlowTaskCentralityTrain(Int_t mode = mGridPAR, Bool_t DATA = kTRUE)
{
// Time:
mgr->SetMCtruthEventHandler(mc);
}
- // Load the analysis task:
- gROOT->LoadMacro("AddTaskFlowCentrality.C");
+ // Task to check the offline trigger:
+ gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
+ AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(!DATA,0);
// Setup analysis per centrality bin:
+ gROOT->LoadMacro("AddTaskFlowCentrality.C");
for (Int_t i=binfirst; i<binlast+1; i++)
{
Int_t lowCentralityBinEdge = centralityArray[i];
i );
} // end of for (Int_t i=0; i<numberOfCentralityBins; i++)
- // Task to check the offline trigger:
- if(mode == mLocal || mode == mGrid || mode == mGridPAR) {
- gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
- } else if(mode == mPROOF || mode == mLocalPAR) {
- gROOT->LoadMacro("AddTaskPhysicsSelection.C");
- }
-
-
- AliPhysicsSelectionTask* physicsSelTask = AddTaskPhysicsSelection(!DATA,0);
-
// Enable debug printouts:
mgr->SetDebugLevel(2);
// Run the analysis:
// Load the needed libraries most of them already loaded by aliroot
//--------------------------------------
+ gSystem->Load("libCore");
+ gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libXMLIO");
gSystem->Load("libPhysics");
+ gSystem->Load("libXMLParser");
+ gSystem->Load("libProof");
- //----------------------------------------------------------
- // >>>>>>>>>>> Local mode <<<<<<<<<<<<<<
- //----------------------------------------------------------
- if (mode==mLocal || mode==mGrid || mode == mGridPAR) {
- //--------------------------------------------------------
- // If you want to use already compiled libraries
- // in the aliroot distribution
- //--------------------------------------------------------
+ if (mode==mLocal || mode==mGrid || mode == mGridPAR || mode == mLocalPAR )
+ {
gSystem->Load("libSTEERBase");
+ gSystem->Load("libCDB");
+ gSystem->Load("libRAWDatabase");
+ gSystem->Load("libRAWDatarec");
gSystem->Load("libESD");
gSystem->Load("libAOD");
+ gSystem->Load("libSTEER");
gSystem->Load("libANALYSIS");
- gSystem->Load("libANALYSISalice");
- gSystem->Load("libCORRFW");
- gSystem->Load("libPWG2forward");
- if(mode==mLocal || mode==mGrid)
+ gSystem->Load("libANALYSISalice");
+ gSystem->Load("libTOFbase");
+ gSystem->Load("libTOFrec");
+
+ if (mode == mLocal || mode == mGrid)
{
- gSystem->Load("libPWG2flowCommon");
- cerr<<"libPWG2flowCommon loaded..."<<endl;
- gSystem->Load("libPWG2flowTasks");
- cerr<<"libPWG2flowTasks loaded..."<<endl;
+ gSystem->Load("libPWG2flowCommon");
+ gSystem->Load("libPWG2flowTasks");
}
- if(mode==mGridPAR)
+ if (mode == mLocalPAR || mode == mGridPAR )
{
- AliAnalysisAlien::SetupPar("STEERBase");
- cerr<<"STEERBase.par loaded..."<<endl;
- AliAnalysisAlien::SetupPar("ESD");
- cerr<<"ESD.par loaded..."<<endl;
- AliAnalysisAlien::SetupPar("AOD");
- cerr<<"AOD.par loaded..."<<endl;
- AliAnalysisAlien::SetupPar("ANALYSIS");
- cerr<<"ANALYSIS.par loaded..."<<endl;
- AliAnalysisAlien::SetupPar("ANALYSISalice");
- cerr<<"ANALYSISalice.par loaded..."<<endl;
- AliAnalysisAlien::SetupPar("CORRFW");
- AliAnalysisAlien::SetupPar("PWG2flowCommon");
- cerr<<"PWG2flowCommon.par loaded..."<<endl;
- AliAnalysisAlien::SetupPar("PWG2flowTasks");
- cerr<<"PWG2flowTasks.par loaded..."<<endl;
+ AliAnalysisAlien::SetupPar("PWG2flowCommon");
+ AliAnalysisAlien::SetupPar("PWG2flowTasks");
}
}
- else if (mode == mLocalPAR) {
- //--------------------------------------------------------
- //If you want to use root and par files from aliroot
- //--------------------------------------------------------
- AliAnalysisAlien::SetupPar("STEERBase");
- AliAnalysisAlien::SetupPar("ESD");
- AliAnalysisAlien::SetupPar("AOD");
- AliAnalysisAlien::SetupPar("ANALYSIS");
- AliAnalysisAlien::SetupPar("ANALYSISalice");
- AliAnalysisAlien::SetupPar("CORRFW");
- AliAnalysisAlien::SetupPar("PWG2flowCommon");
- cerr<<"PWG2flowCommon.par loaded..."<<endl;
- AliAnalysisAlien::SetupPar("PWG2flowTasks");
- cerr<<"PWG2flowTasks.par loaded..."<<endl;
- }
-
//---------------------------------------------------------
// <<<<<<<<<< PROOF mode >>>>>>>>>>>>
//---------------------------------------------------------
// Connect to proof
printf("*** Connect to PROOF ***\n");
gEnv->SetValue("XSec.GSI.DelegProxy","2");
- TProof::Open("alice-caf.cern.ch");
- //TProof::Open("skaf.saske.sk");
+ TProof::Open("mkrzewic@alice-caf.cern.ch");
+ //TProof::Open("mkrzewic@skaf.saske.sk");
// list the data available
//gProof->ShowDataSets("/*/*");
//gProof->ShowDataSets("/alice/sim/"); //for MC Data
*/
//gProof->ClearPackage("ANALYSIS.par");
//gProof->ClearPackage("ANALYSISalice.par");
- gProof->ClearPackage("CORRFW.par");
+ //gProof->ClearPackage("CORRFW.par");
gProof->ClearPackage("PWG2flowCommon");
gProof->ClearPackage("PWG2flowTasks");
gProof->UploadPackage("CORRFW.par");
gProof->UploadPackage("PWG2flowCommon.par");
gProof->UploadPackage("PWG2flowTasks.par");
+ gProof->UploadPackage("ALIRECO.par");
// Enable the Packages
// The global package
- gProof->EnablePackage("VO_ALICE@AliRoot::v4-21-05-AN");
- //gProof->EnablePackage("aliroot_v4-19-05-AN",kTRUE);
- // Or separate
-
- //gProof->EnablePackage("STEERBase");
- //gProof->EnablePackage("ESD");
- //gProof->EnablePackage("AOD");
-
- // Always needed
+ TList* list = new TList();
+ list->Add(new TNamed("ALIROOT_EXTRA_INCLUDES","RAW:OCDB:STEER:TOF"));
+ gProof->EnablePackage("VO_ALICE@AliRoot::v4-21-07-AN",list);
+ gProof->EnablePackage("ALIRECO");
//gProof->EnablePackage("ANALYSIS");
//gProof->EnablePackage("ANALYSISalice");
- gProof->EnablePackage("CORRFW");
+ //gProof->EnablePackage("CORRFW");
gProof->EnablePackage("PWG2flowCommon");
gProof->EnablePackage("PWG2flowTasks");
EXPORT:=
-EINCLUDE:= PWG2/FLOW/AliFlowCommon PWG2/FLOW/AliFlowTasks
+EINCLUDE:= PWG2/FLOW/AliFlowCommon PWG2/FLOW/AliFlowTasks TOF
ifeq (win32gcc,$(ALICE_TARGET))
PACKSOFLAGS:= $(SOFLAGS) -L$(ALICE_ROOT)/lib/tgt_$(ALICE_TARGET) -lSTEERBase \
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff