if(fisAOD){
AliAODHeader *aodheader = 0x0;
- aodheader = aod->GetHeader();
+ aodheader = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!aodheader) AliFatal("Not a standard AOD");
if(!aodheader){
AliFatal("AOD header not there ?!");
return kFALSE;
AliFatal("Event is neither of AOD nor ESD type");
return kFALSE;
}
- Int_t bc2 = (aod)?aod->GetHeader()->GetIRInt2ClosestInteractionMap():esd->GetHeader()->GetIRInt2ClosestInteractionMap();
+ Int_t bc2 = (aod)?((AliVAODHeader*)aod->GetHeader())->GetIRInt2ClosestInteractionMap():esd->GetHeader()->GetIRInt2ClosestInteractionMap();
if (bc2 != 0)
return kTRUE;
- Int_t bc1 = (aod)?aod->GetHeader()->GetIRInt1ClosestInteractionMap():esd->GetHeader()->GetIRInt1ClosestInteractionMap();
+ Int_t bc1 = (aod)?((AliVAODHeader*)aod->GetHeader())->GetIRInt1ClosestInteractionMap():esd->GetHeader()->GetIRInt1ClosestInteractionMap();
if (bc1 != 0)
return kTRUE;
//nTracks = event->GetNumberOfTracks();
nTracks = fTrackCuts ? (Short_t)fTrackCuts->GetReferenceMultiplicity(esd,kTRUE):-1;
} else {
- AliAODHeader *h = aod->GetHeader();
+ AliAODHeader *h = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!h) AliFatal("Not a standard AOD");
nTracks = h!=0 ? (Short_t)h->GetTPConlyRefMultiplicity():-1;
}
} else {
AliAODTracklets *mult = aod->GetTracklets();
nTracklets = mult->GetNumberOfTracklets();
- AliAODHeader *h = aod->GetHeader();
+ AliAODHeader *h = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!h) AliFatal("Not a standard AOD");
for(Int_t ilay=0; ilay<6; ilay++){
nClusters[ilay] = h->GetNumberOfITSClusters(ilay);
}
if (zpcFired) zpcTower = ZPCtower[0];
} else {
- AliAODHeader *h = aod->GetHeader();
+ AliAODHeader *h = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!h) AliFatal("Not a standard AOD");
zncEnergy = (Float_t) (h->GetZDCN1Energy());
zpcEnergy = (Float_t) (h->GetZDCP1Energy());
znaEnergy = (Float_t) (h->GetZDCN2Energy());
if (headerH) fRP = headerH->GetReactionPlaneAngle();
}
- esdEP = aod->GetHeader()->GetEventplaneP();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+ esdEP = header->GetEventplaneP();
if(!esdEP) return; // protection against missing EP branch (nanoAODs)
esdEP->Reset();
AliCodeTimerAuto("",0);
- AliAODHeader* header = AODEvent()->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(AODEvent()->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
header->SetRunNumber(esd.GetRunNumber());
header->SetOfflineTrigger(fInputHandler->IsEventSelected()); // propagate the decision of the physics selection
if( handler )
{
AliAODEvent* aod = handler->GetAOD();
- AliAODHeader* header = aod->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
header->SetRunNumber(lESD->GetRunNumber());
AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
void AliNanoAODSimpleSetter::SetNanoAODHeader(const AliAODEvent * event , AliNanoAODHeader * head ) {
+
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(event->GetHeader());
+ if (!header) AliFatal("Not a standard AOD");
// Set custom nano aod vars
- Double_t centr = event->GetHeader()->GetCentralityP()->GetCentralityPercentile("V0M");
- Double_t magfield = event->GetHeader()->GetMagneticField();
+ Double_t centr = header->GetCentralityP()->GetCentralityPercentile("V0M");
+ Double_t magfield = header->GetMagneticField();
head->SetVar(0, centr);
head->SetVar(1, magfield);
AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
offtrigger = ((AliInputEventHandler*)(am->GetInputEventHandler()))->IsEventSelected();
} else {
- offtrigger = fAod->GetHeader()->GetOfflineTrigger();
+ offtrigger = ((AliVAODHeader*)fAod->GetHeader())->GetOfflineTrigger();
}
if (!MCEvent()) {
if (fEsd) {
gm = fEsd->GetEMCALMatrix(mod);
} else {
- AliAODHeader *aodheader = fAod->GetHeader();
+ AliAODHeader *aodheader = dynamic_cast<AliAODHeader*>(fAod->GetHeader());
+ if(!aodheader) AliFatal("Not a standard AOD");
if (aodheader) {
gm = aodheader->GetEMCALMatrix(mod);
}
} else {
const AliAODEvent *aev = dynamic_cast<const AliAODEvent*>(InputEvent());
if (aev) {
- res = aev->GetHeader()->GetOfflineTrigger();
+ res = ((AliVAODHeader*)aev->GetHeader())->GetOfflineTrigger();
}
}
if ((res & fOffTrigger) == 0) {
am->LoadBranch("AliESDRun.");
TString title(eev->GetHeader()->GetTitle());
if (1&&(title.Length()>0)) {
- res = eev->GetHeader()->GetUniqueID();
+ res = ((AliVAODHeader*)eev->GetHeader())->GetUniqueID();
res &= 0x4FFFFFFF;
} else {
res = IsCollisionCandidate(eev);
}
} else {
aev = dynamic_cast<const AliAODEvent*>(obj);
- res = aev->GetHeader()->GetOfflineTrigger();
+ res = ((AliVAODHeader*)aev->GetHeader())->GetOfflineTrigger();
}
// return 0, if 0 found
//At the momment the cutting class does not handle AOD event properly
//so we are doing the cuts explicitly here
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
if(!aodHeader) return;
AliCentrality *centrality = aodHeader->GetCentralityP();
if(!centrality) return;
void AliAnalysisTaskFlowEPCascade::ReadFromAODv0(AliAODEvent *fAOD){
- AliEventplane * ep = (fAOD->GetHeader())->GetEventplaneP();
+ AliEventplane * ep = ((AliVAODHeader*)fAOD->GetHeader())->GetEventplaneP();
Double_t psiTPC = ep->GetEventplane("Q", fAOD, 2); // in range of [0, pi]
// if(psiTPC > TMath::PiOver2())
// psiTPC -= TMath::Pi();
// Update the header
- AliAODHeader* header = AODEvent()->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(AODEvent()->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
header->SetRunNumber(esd->GetRunNumber());
header->SetQTheta(dRP,1);
//=======================================================================
Bool_t AliAnalysisTaskFlowStrange::MinimumRequirementsAA(AliAODEvent *tAOD) {
fRunNumber = tAOD->GetRunNumber();
- AliCentrality *cent = tAOD->GetHeader()->GetCentralityP();
+ AliCentrality *cent = ((AliVAODHeader*)tAOD->GetHeader())->GetCentralityP();
fV0M = cent->GetCentralityPercentile("V0M");
fTRK = cent->GetCentralityPercentile("TRK");
TString mycent = fCentMethod;
// PA reading discontinued: TO BE UPDATED
/*
//if(aod->GetHeader()->GetEventNumberESDFile() == 0) return; //rejecting first chunk NOT NEEDED ANYMORE
- Int_t bc2 = tAOD->GetHeader()->GetIRInt2ClosestInteractionMap();
+ Int_t bc2 = ((AliVAODHeader*)tAOD->GetHeader())->GetIRInt2ClosestInteractionMap();
if(bc2!=0) return kFALSE;
- Int_t bc1 = tAOD->GetHeader()->GetIRInt1ClosestInteractionMap();
+ Int_t bc1 = ((AliVAODHeader*)tAOD->GetHeader())->GetIRInt1ClosestInteractionMap();
if(bc1!=0) return kFALSE;
Short_t isPileup = tAOD->IsPileupFromSPD(5);
if(isPileup!=0) return kFALSE;
Double_t tSPDVtxZ = aodevent->GetPrimaryVertexSPD()->GetZ();
if( TMath::Abs(tVtxZ-tSPDVtxZ) > 0.5 ) pass = kFALSE;
}
- AliCentrality* centr = aodevent->GetHeader()->GetCentralityP();
+ AliCentrality* centr = ((AliVAODHeader*)aodevent->GetHeader())->GetCentralityP();
if(fCutTPCmultiplicityOutliers || fCutTPCmultiplicityOutliersAOD){
Double_t v0Centr = centr->GetCentralityPercentile("V0M");
Double_t trkCentr = centr->GetCentralityPercentile("TRK");
if (esdEvent)
centr = esdEvent->GetCentrality();
if (aodEvent)
- centr = aodEvent->GetHeader()->GetCentralityP();
+ centr = ((AliVAODHeader*)aodEvent->GetHeader())->GetCentralityP();
if (!centr) return -1.;
if (fReplicateHeader)
{
- *fHeader = *(source.GetHeader());
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(source.GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+ *fHeader = *(header);
}
if (fReplicateTracklets)
// CORRFW includes
#include "AliCFGridSparse.h"
+#include "assert.h"
/// \cond CLASSIMP
ClassImp(AliAnalysisMuonUtility) // Class implementation in ROOT context
// try first to find the info in the AOD header
// (which is a priori safer because it works even on local copies of AODs)
// and if it does not work, directly check the path to the AOD
- filePath = static_cast<const AliAODEvent*> (event)->GetHeader()->GetESDFileName();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(static_cast<const AliAODEvent*> (event)->GetHeader());
+ assert(header && "Not a standard AOD");
+ filePath = header->GetESDFileName();
TString passName = GetPassName(filePath.Data());
if ( passName.IsNull() ) AliWarningClass("Check again with the AOD path");
else return passName;
}
}
- fOutputUserAOD->GetHeader()->SetRefMultiplicity(nFWMUonsAdded);
- fOutputUserAOD->GetHeader()->SetRefMultiplicityPos(nPosTracksAdded);
- fOutputUserAOD->GetHeader()->SetRefMultiplicityNeg(nNegTracksAdded);
+
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(fOutputUserAOD->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+ header->SetRefMultiplicity(nFWMUonsAdded);
+ header->SetRefMultiplicityPos(nPosTracksAdded);
+ header->SetRefMultiplicityNeg(nNegTracksAdded);
fOutputUserHandler -> FinishEvent();
// for (Int_t i = 0; i < 10; pid[i++] = 0.) {}
// pid[AliAODTrack::kMuon]=1.;
- AliAODHeader* header = AODEvent()->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(AODEvent()->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
AliAODTrack *aodTrack = 0x0;
AliESDMuonTrack *esdMuTrack = 0x0;
// for (Int_t i = 0; i < 10; pid[i++] = 0.) {}
// pid[AliAODTrack::kMuon]=1.;
- AliAODHeader* header = AODEvent()->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(AODEvent()->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
AliAODTrack *aodTrack = 0x0;
AliESDMuonTrack *esdMuTrack = 0x0;
Double_t covVtx[6];
// Access to the header
- AliAODHeader *header = fNewAOD->GetHeader();
+ AliAODHeader *header = dynamic_cast<AliAODHeader*>(fNewAOD->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
// fill the header
header->SetRunNumber (fOrgAOD->GetRunNumber() );
Double_t pos[2];
Double_t covar[3];
AliAODTrack* clone = (AliAODTrack*) part->Clone();
- Bool_t success = clone->PropagateToDCA(vertex, aodEvent->GetHeader()->GetMagneticField(), 3, pos, covar);
+ Bool_t success = clone->PropagateToDCA(vertex, ((AliVAODHeader*)aodEvent->GetHeader())->GetMagneticField(), 3, pos, covar);
delete clone;
if (!success)
return 0;
_eventAccounting->Fill(1);// count all calls to this function with a valid pointer
//Centrality
- AliCentrality* centralityObject = fAODEvent->GetHeader()->GetCentralityP();
+ AliCentrality* centralityObject = ((AliVAODHeader*)fAODEvent->GetHeader())->GetCentralityP();
if (centralityObject)
{
// cout << "AliAnalysisTask3PCorrelations::UserExec(Option_t *option) - 6" << endl;
}
Double_t centrality = 0;
- AliCentrality *centralityObj = fAOD->GetHeader()->GetCentralityP();
+ AliCentrality *centralityObj = ((AliVAODHeader*)fAOD->GetHeader())->GetCentralityP();
if (centralityObj)
{
centrality = centralityObj->GetCentralityPercentileUnchecked("V0M");
else tMult=fESD->GetVZEROData()->GetMTotV0A()+fESD->GetVZEROData()->GetMTotV0C();
}
else{
- AliAODHeader *tHeader=fAOD->GetHeader();
+ AliAODHeader *tHeader=dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!tHeader) AliFatal("Not a standard AOD");
tMult=tHeader->GetCentrality();
}
if(fAODEvent)
{
//Centrality
- AliCentrality* centralityObject = fAODEvent->GetHeader()->GetCentralityP();
+ AliCentrality* centralityObject = ((AliVAODHeader*)fAODEvent->GetHeader())->GetCentralityP();
if (centralityObject)
{
//cout << "AliAnalysisTaskDptDptCorrelations::UserExec(Option_t *option) - 6" << endl;
//cout << "AliAnalysisTaskDptDptQA::UserExec(Option_t *option) - 5" << endl;
//Centrality
- AliCentrality* centralityObject = fAODEvent->GetHeader()->GetCentralityP();
+ AliCentrality* centralityObject = ((AliVAODHeader*)fAODEvent->GetHeader())->GetCentralityP();
if (centralityObject)
{
//cout << "AliAnalysisTaskDptDptQA::UserExec(Option_t *option) - 6" << endl;
AliAODEvent* pAOD(dynamic_cast<AliAODEvent*>(InputEvent()));
if (NULL == pAOD) return;
- AliAODHeader *pAODHeader = pAOD->GetHeader();
+ AliAODHeader *pAODHeader = dynamic_cast<AliAODHeader*>(pAOD->GetHeader());
+ if(!pAODHeader) AliFatal("Not a standard AOD");
if (NULL == pAODHeader) return;
AliAODMCHeader *pAODMCHeader(dynamic_cast<AliAODMCHeader*>(pAOD->FindListObject(AliAODMCHeader::StdBranchName())));
{
AliCentrality *centralityObj = 0;
if (fAODEvent)
- centralityObj = fAODEvent->GetHeader()->GetCentralityP();
+ centralityObj = ((AliVAODHeader*)fAODEvent->GetHeader())->GetCentralityP();
else if (fESDEvent)
centralityObj = fESDEvent->GetCentrality();
if (centralityObj)
{
AliCentrality *centralityObj = 0;
if (fAOD)
- centralityObj = fAOD->GetHeader()->GetCentralityP();
+ centralityObj = ((AliVAODHeader*)fAOD->GetHeader())->GetCentralityP();
else if (fESD)
centralityObj = fESD->GetCentrality();
else
{
if (fAOD)
- centralityObj = fAOD->GetHeader()->GetCentralityP();
+ centralityObj = ((AliVAODHeader*)fAOD->GetHeader())->GetCentralityP();
else if (fESD)
centralityObj = fESD->GetCentrality();
referenceMultiplicity = AliESDtrackCuts::GetReferenceMultiplicity(fESD);
else if (fAOD)
referenceMultiplicity = tracks->GetEntriesFast(); // TODO to be replaced by the estimator once available in the AOD
-// referenceMultiplicity = fAOD->GetHeader()->GetRefMultiplicityComb05();
+// referenceMultiplicity = ((AliVAODHeader*)fAOD->GetHeader())->GetRefMultiplicityComb05();
((TH2F*) fListOfHistos->FindObject("referenceMultiplicity"))->Fill(centrality, referenceMultiplicity);
Double_t centrality = 0;
AliCentrality *centralityObj = 0;
- centralityObj = fAOD->GetHeader()->GetCentralityP();
+ centralityObj = ((AliVAODHeader*)fAOD->GetHeader())->GetCentralityP();
if (centralityObj)
{
//Centrality
- //AliAODHeader* centralityObject = fAODEvent->GetHeader()->GetCentralityP();
- AliCentrality* centralityObject = fAODEvent->GetHeader()->GetCentralityP();
+ //AliAODHeader* centralityObject = ((AliVAODHeader*)fAODEvent->GetHeader())->GetCentralityP();
+ AliCentrality* centralityObject = ((AliVAODHeader*)fAODEvent->GetHeader())->GetCentralityP();
if (centralityObject)
{
v0Centr = centralityObject->GetCentralityPercentile("V0M");
// Before Physics Selection
//------------------------------------------------
ltrackMultiplicity = (InputEvent())->GetNumberOfTracks();
- lrefMultiplicity =fAODEvent->GetHeader()->GetRefMultiplicity();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(fAODEvent->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+ lrefMultiplicity = header->GetRefMultiplicity();
fHist_Mult_B4_Trg_Sel->Fill(ltrackMultiplicity,lrefMultiplicity);
}
// Get the event header.
- AliAODHeader* CurrentHeader = event->GetHeader();
+ AliAODHeader* CurrentHeader = dynamic_cast<AliAODHeader*>(event->GetHeader());
+ if(!CurrentHeader) AliFatal("Not a standard AOD");
// Test minimum reference multiplicity.
Int_t CurrentRefMultiplicity = CurrentHeader->GetRefMultiplicity();
Info("Exec()", "Event REJECTED (AOD vertex not OK). z = %.1f", fZVertex);
return;
}
- const AliCentrality *aodCent = fAOD->GetHeader()->GetCentralityP();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(fAOD);
+ if(!header) AliFatal("Not a standard AOD");
+
+ const AliCentrality *aodCent = header->GetCentralityP();
if (aodCent) {
fCentrality = aodCent->GetCentralityPercentile(fCentMethod);
}
Double_t AliAnalysisTaskDiMuonCorrelations::GetITSMultiplicity() {
- Double_t multiplicity = fAOD->GetHeader()->GetNumberOfITSClusters(1);
+ Double_t multiplicity = ((AliVAODHeader*)fAOD->GetHeader())->GetNumberOfITSClusters(1);
return multiplicity;
Double_t AliAnalysisTaskMuonHadronCorrelations::GetITSMultiplicity() {
- Double_t multiplicity = fAOD->GetHeader()->GetNumberOfITSClusters(1);
+ Double_t multiplicity = ((AliVAODHeader*)fAOD->GetHeader())->GetNumberOfITSClusters(1);
return multiplicity;
//now deal with reco tracks
- Float_t bSign1=aod->GetHeader()->GetMagneticField() ;//used for reconstructed track dca cut
+ Float_t bSign1=((AliVAODHeader*)aod->GetHeader())->GetMagneticField() ;//used for reconstructed track dca cut
//detrmine the ref mult in case of Reco(not required if we get centrality info from AliCentrality)
if (fSampleType=="pp_2_76" || fCentralityMethod.EndsWith("_MANUAL") || (fSampleType=="pp_7" && fPPVsMultUtils==kFALSE)) cent_v0=refmultReco;
AliAODTrack *PIDtrack=track;//for PID purpose, mainly important for TPC only tracks
if(fFilterBit==128){
-Int_t gid1 = track->GetID();
-//if(gid1>=0) PIDtrack = track;
- PIDtrack = aod->GetTrack(trackMap->GetValue(-1-gid1));
-if(!PIDtrack) continue;//for safety; so that each of the TPC only tracks have corresponding global track along with it
+ Int_t gid1 = track->GetID();
+ //if(gid1>=0) PIDtrack = track;
+ PIDtrack = dynamic_cast<AliAODTrack*>(aod->GetTrack(trackMap->GetValue(-1-gid1)));
+ if(!PIDtrack) continue;//for safety; so that each of the TPC only tracks have corresponding global track along with it
}
trackscount++;
bSign = (aod->GetMagneticField() > 0) ? 1 : -1;//for two track efficiency cut in correlation function calculation
- Float_t bSign1=aod->GetHeader()->GetMagneticField() ;//for dca cut in ClassifyTrack(), i.e in track loop
+ Float_t bSign1=((AliVAODHeader*)aod->GetHeader())->GetMagneticField() ;//for dca cut in ClassifyTrack(), i.e in track loop
// check event cuts and fill event histograms and return the centrality or reference multiplicity value
AliAODTrack *PIDtrack=track;//for PID purpose, mainly important for TPC only tracks
if(fFilterBit==128){
-Int_t gid1 = track->GetID();
-//if(gid1>=0) PIDtrack = track;
- PIDtrack = aod->GetTrack(trackMap->GetValue(-1-gid1));
-if(!PIDtrack) continue;//for safety; so that each of the TPC only tracks have corresponding global track along with it
+ Int_t gid1 = track->GetID();
+ //if(gid1>=0) PIDtrack = track;
+ PIDtrack = dynamic_cast<AliAODTrack*>(aod->GetTrack(trackMap->GetValue(-1-gid1)));
+ if(!PIDtrack) continue;//for safety; so that each of the TPC only tracks have corresponding global track along with it
}
//check for eta , phi holes
for(Int_t iT = 0; iT < nAODTracks; iT++) {
- AliAODTrack* aodTrack = event->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(event->GetTrack(iT));
if (!aodTrack){
continue;
// for HBT like cuts need magnetic field sign
bSign = (gAOD->GetMagneticField() > 0) ? 1 : -1;
- AliAODHeader *aodHeader = gAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(gAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
// store offline trigger bits
fHistTriggerStats->Fill(aodHeader->GetOfflineTrigger());
// for HBT like cuts need magnetic field sign
bSign = (aodEventMain->GetMagneticField() > 0) ? 1 : -1;
- AliAODHeader *aodHeaderMain = aodEventMain->GetHeader();
+ AliAODHeader *aodHeaderMain = dynamic_cast<AliAODHeader*>(aodEventMain->GetHeader());
+ if(!aodHeaderMain) AliFatal("Not a standard AOD");
// event selection done in AliAnalysisTaskSE::Exec() --> this is not used
fHistEventStats->Fill(1); //all events
}
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
Int_t cent = -1;
cent = aodHeader->GetCentralityP()->GetCentralityClass10(fCentralityEstimator.Data());
return;
}
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
Int_t cent = -1;
cent = aodHeader->GetCentralityP()->GetCentralityClass10(fCentralityEstimator.Data());
if(!ProperVertex(fAOD)) return;
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
fCentrality = (Int_t)aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());
if(!ProperVertex(fAOD)) return;
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
fCentrality = (Int_t)aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());
if(!ProperVertex(fAOD)) return;
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
fCentrality = (Int_t)aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());
if(!ProperVertex(fAOD)) return;
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
fCentrality = (Int_t)aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());
- AliAODHeader *fHeader = fAOD->GetHeader();
+ AliAODHeader *fHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!fHeader) AliFatal("Not a standard AOD");
Int_t spdmult0 = fHeader->GetNumberOfITSClusters(0);
Int_t spdmult1 = fHeader->GetNumberOfITSClusters(1);
Int_t run = fHeader->GetRunNumber();
}
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
fCentrality = (Int_t)aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());
/* Int_t cent = -1;
return;
}
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
fCentrality = (Int_t)aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());
if(esdHandler)
centrality = fESD->GetCentrality();
else if(aodHandler)
- centrality = fAOD->GetHeader()->GetCentralityP();
+ centrality = ((AliVAODHeader*)fAOD->GetHeader())->GetCentralityP();
if (!centrality) {
AliError("Centrality not available");
// -- Check Centrality
// ------------------------------------------------------------------
- if (!fAOD->GetHeader()->GetCentralityP()) {
+ if (!((AliVAODHeader*)fAOD->GetHeader())->GetCentralityP()) {
AliError("Could not get centrality");
return -1;
}
Int_t gCent = -1;
Float_t gRefMul = -1;
- AliAODHeader *aodHeader = event->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(event->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
gCent = (Int_t)aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());
gRefMul = aodHeader->GetRefMultiplicity();
if (gCent < 0 || gCent > 100) return;
Int_t gCent = -1;
// Float_t gRefMul = -1;
- AliAODHeader *aodHeader = event->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(event->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
gCent = (Int_t)aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());
// gRefMul = aodHeader->GetRefMultiplicity();
if (gCent < 0 || gCent > 100) return;
Int_t gCent = -1;
//Float_t gRefMul = -1;
- AliAODHeader *aodHeader = event->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(event->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
gCent = (Int_t)aodHeader->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());
// gRefMul = aodHeader->GetRefMultiplicity();
if (gCent < 0 || gCent > 100) return;
cout<<"AliAnalysisTaskFemto::AodpidUtil:"<<fAODpidUtil<<endl;
femtoReaderAOD->SetAODpidUtil(fAODpidUtil);
- fAODheader = fAOD->GetHeader();
+ fAODheader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!fAODheader) AliFatal("Not a standard AOD");
femtoReaderAOD->SetAODheader(fAODheader);
}
#include "AliAODpidUtil.h"
#include "AliAnalysisUtils.h"
+#include "assert.h"
#include "AliGenHijingEventHeader.h"
ClassImp(AliFemtoEventReaderAOD)
}
}
- tEvent->SetReactionPlaneAngle(fEvent->GetHeader()->GetQTheta(0)/2.0);
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(fEvent->GetHeader());
+ assert(header&&"Not a standard AOD");
+
+ tEvent->SetReactionPlaneAngle(header->GetQTheta(0)/2.0);
// Int_t *motherids=0;
// if (mcP) {
// const int motherTabSize = ((AliAODMCParticle *) mcP->At(mcP->GetEntries()-1))->GetLabel();
// looking for global tracks and saving their numbers to copy from them PID information to TPC-only tracks in the main loop over tracks
for (int i=0;i<nofTracks;i++) {
- const AliAODTrack *aodtrack=fEvent->GetTrack(i);
+ const AliAODTrack *aodtrack=dynamic_cast<const AliAODTrack*>(fEvent->GetTrack(i));
+ assert(aodtrack&&"Not a standard AOD");
if (!aodtrack->TestFilterBit(fFilterBit)) {
if(aodtrack->GetID() < 0) continue;
labels[aodtrack->GetID()] = i;
// No additional information exists
// Read in the normal AliAODTracks
- // const AliAODTrack *aodtrack=fEvent->GetTrack(i); // getting the AODtrack directly
- AliAODTrack *aodtrack=fEvent->GetTrack(i); // getting the AODtrack directly
+ // const AliAODTrack *aodtrack=dynamic_cast<AliAODTrack*>(fEvent->GetTrack(i));
+ AliAODTrack *aodtrack=dynamic_cast<AliAODTrack*>(fEvent->GetTrack(i));
+ assert(aodtrack&&"Not a standard AOD"); // getting the AODtrack directly
AliAODTrack *aodtrackpid;
if((fFilterBit == (1 << (7))) || fFilterMask == 128) {//for TPC Only tracks we have to copy PID information from corresponding global tracks
- aodtrackpid = fEvent->GetTrack(labels[-1-fEvent->GetTrack(i)->GetID()]);
+ aodtrackpid = dynamic_cast<AliAODTrack*>(fEvent->GetTrack(labels[-1-fEvent->GetTrack(i)->GetID()]));
}
else {
- aodtrackpid = fEvent->GetTrack(i);
+ aodtrackpid = dynamic_cast<AliAODTrack*>(fEvent->GetTrack(i));
}
+ assert(aodtrackpid&&"Not a standard AOD");
CopyPIDtoFemtoTrack(aodtrackpid, trackCopy);
#include "AliAODMCParticle.h"
#include "AliVertexerTracks.h"
+#include "assert.h"
ClassImp(AliFemtoEventReaderStandard)
if (!mcP) {
cout << "AOD MC information requested, but no particle array found!" << endl;
}
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(fAODEvent->GetHeader());
+ assert(header&&"Not a standard AOD");
- hbtEvent->SetReactionPlaneAngle(fAODEvent->GetHeader()->GetQTheta(0)/2.0);
+ hbtEvent->SetReactionPlaneAngle(header->GetQTheta(0)/2.0);
if (mcP) {
motherids = new Int_t[((AliAODMCParticle *) mcP->At(mcP->GetEntries()-1))->GetLabel()];
//AliESDEvent *esdEvent = dynamic_cast<AliESDEvent *>(InputEvent());
AliAODEvent* aodEvent = dynamic_cast<AliAODEvent*>(InputEvent());
if (!aodEvent) return;
- AliAODHeader *fAODheader = aodEvent->GetHeader();
+ AliAODHeader *fAODheader = dynamic_cast<AliAODHeader*>(aodEvent->GetHeader());
+ if(!fAODheader) AliFatal("Not a standard AOD");
Double_t mult = fAODheader->GetRefMultiplicity();
// AliCentrality* alicent= aodEvent->GetCentrality(); //in PbPb and pPb
// Double_t mult = alicent->GetCentralityPercentile("V0A"); //in pPb
// Update the header
- AliAODHeader* header = fAOD->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
header->SetRunNumber(fESD->GetRunNumber());
if (old) {
header->SetBunchCrossNumber(0);
nanoEv->GetVertex(0)->SetNContributors((static_cast<AliAODEvent*>(InputEvent()))->GetPrimaryVertex()->GetNContributors());
nanoEv->GetVertex(1)->SetNContributors((static_cast<AliAODEvent*>(InputEvent()))->GetPrimaryVertexSPD()->GetNContributors());
// set event plane
- nanoEv->GetHeader()->SetEventplane((static_cast<AliAODEvent*>(InputEvent()))->GetHeader()->GetEventplaneP());
- nanoEv->GetHeader()->ResetEventplanePointer();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(nanoEv->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+
+
+ header->SetEventplane(((AliVAODHeader*)static_cast<AliAODEvent*>(InputEvent())->GetHeader())->GetEventplaneP());
+ header->ResetEventplanePointer();
// set multiplicity
- nanoEv->GetHeader()->SetRefMultiplicity((Int_t)values[AliDielectronVarManager::kNTrk]);
- nanoEv->GetHeader()->SetRefMultiplicityPos((Int_t)values[AliDielectronVarManager::kNacc]);
+ header->SetRefMultiplicity((Int_t)values[AliDielectronVarManager::kNTrk]);
+ header->SetRefMultiplicityPos((Int_t)values[AliDielectronVarManager::kNacc]);
//nanoEv->GetHeader()->SetRefMultiplicityNeg(values[AliDielectronVarManager::kMatchEffITSTPC]);
for(int kj=0; kj<(fDielectron->GetTrackArray(0))->GetEntries(); kj++){
if(fCreateNanoAOD && isAOD && (!hasCand) && fStoreHeader)
{
- // set event plane
- extDielectron->GetAOD()->GetHeader()->SetEventplane((static_cast<AliAODEvent*>(InputEvent()))->GetHeader()->GetEventplaneP());
- extDielectron->GetAOD()->GetHeader()->ResetEventplanePointer();
- extDielectron->GetTree()->Fill(); // fill header for all events without tracks
+ // set event plane
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(extDielectron->GetAOD()->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+ header->SetEventplane(((AliAODHeader*)(static_cast<AliAODEvent*>(InputEvent()))->GetHeader())->GetEventplaneP());
+ header->ResetEventplanePointer();
+ extDielectron->GetTree()->Fill(); // fill header for all events without tracks
}
PostData(1, const_cast<THashList*>(fDielectron->GetHistogramList()));
}
}
if(isAOD) {
- fReducedEvent->fIRIntClosestIntMap[0] = aodEvent->GetHeader()->GetIRInt1ClosestInteractionMap();
- fReducedEvent->fIRIntClosestIntMap[1] = aodEvent->GetHeader()->GetIRInt2ClosestInteractionMap();
- fReducedEvent->fEventNumberInFile = aodEvent->GetHeader()->GetEventNumberESDFile();
- fReducedEvent->fL0TriggerInputs = aodEvent->GetHeader()->GetL0TriggerInputs();
- fReducedEvent->fL1TriggerInputs = aodEvent->GetHeader()->GetL1TriggerInputs();
- fReducedEvent->fL2TriggerInputs = aodEvent->GetHeader()->GetL2TriggerInputs();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(aodEvent->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+
+
+ fReducedEvent->fIRIntClosestIntMap[0] = header->GetIRInt1ClosestInteractionMap();
+ fReducedEvent->fIRIntClosestIntMap[1] = header->GetIRInt2ClosestInteractionMap();
+ fReducedEvent->fEventNumberInFile = header->GetEventNumberESDFile();
+ fReducedEvent->fL0TriggerInputs = header->GetL0TriggerInputs();
+ fReducedEvent->fL1TriggerInputs = header->GetL1TriggerInputs();
+ fReducedEvent->fL2TriggerInputs = header->GetL2TriggerInputs();
fReducedEvent->fTimeStamp = 0;
fReducedEvent->fNpileupSPD = aodEvent->GetNumberOfPileupVerticesSPD();
fReducedEvent->fNpileupTracks = aodEvent->GetNumberOfPileupVerticesTracks();
#include "AliVZEROEPSelectionTask.h"
#include "AliAODMCHeader.h"
+#include "assert.h"
class AliVEvent;
FillVarVEvent(event, values);
// Fill AliAODEvent interface specific information
- AliAODHeader *header = event->GetHeader();
+ AliAODHeader *header = dynamic_cast<AliAODHeader*>(event->GetHeader());
+ assert(header&&"Not a standard AOD");
Double_t centralityF=-1; Double_t centralitySPD=-1;
AliCentrality *aodCentrality = header->GetCentralityP();
}
if(event->IsA() == AliAODEvent::Class()) {
const AliAODEvent* aodEv = static_cast<const AliAODEvent*>(event);
- AliAODHeader *header = aodEv->GetHeader();
+ AliAODHeader *header = dynamic_cast<AliAODHeader*>(aodEv->GetHeader());
+ assert(header&&"Not a standard AOD");
AliCentrality *aodCentrality = header->GetCentralityP();
if(aodCentrality) centralitySPD = aodCentrality->GetCentralityPercentile("CL1");
}
if(fgZDCRecentering[0][0]){
const AliAODEvent* aodEv = static_cast<const AliAODEvent*>(event);
- AliAODHeader *header = aodEv->GetHeader();
+ AliAODHeader *header = dynamic_cast<AliAODHeader*>(aodEv->GetHeader());
if(!header) return;
TPCRefMulti = header -> GetTPConlyRefMultiplicity();
{
// AOD header copy
- AliAODHeader* header = AODEvent()->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(AODEvent()->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
// Copy from AODs
if(fAODEvent)
{
- *header = *(fAODEvent->GetHeader());
+ *header = *((AliAODHeader*)fAODEvent->GetHeader());
return;
}
Double_t covVtx[6];
for (Int_t i = 0; i < 6; i++) covVtx[i] = 0.;
- AliAODHeader* header = AODEvent()->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(AODEvent()->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
header->SetRunNumber(fEvent->GetRunNumber());
if(esdevent)
if (file) header->SetESDFileName(file->GetName());
}
}
- else if (aodevent) header->SetESDFileName(aodevent->GetHeader()->GetESDFileName());
+ else if (aodevent) {
+ AliAODHeader * aodheader = dynamic_cast<AliAODHeader*>(aodevent->GetHeader());
+ if(!aodheader) AliFatal("Not a standard AOD");
+ header->SetESDFileName(aodheader->GetESDFileName());
+ }
header->SetBunchCrossNumber(fEvent->GetBunchCrossNumber());
header->SetOrbitNumber(fEvent->GetOrbitNumber());
return;
}
am->LoadBranch("header");
- offtrigger = fAodEv->GetHeader()->GetOfflineTrigger();
+ offtrigger = ((AliVAODHeader*)fAodEv->GetHeader())->GetOfflineTrigger();
}
if (!fMcMode && (offtrigger & AliVEvent::kFastOnly)) {
AliWarning(Form("EMCAL not in fast only partition"));
const TGeoHMatrix *geom = 0;
if (fEsdEv)
geom = fEsdEv->GetESDRun()->GetEMCALMatrix(i);
- else
- geom = fAodEv->GetHeader()->GetEMCALMatrix(i);
+ else {
+ AliAODHeader * aodheader = dynamic_cast<AliAODHeader*>(fAodEv->GetHeader());
+ if(!aodheader) AliFatal("Not a standard AOD");
+ geom = aodheader->GetEMCALMatrix(i);
+ }
if (!geom)
continue;
geom->Print();
AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
if (fAodEv) {
+ AliAODHeader * aodheader = dynamic_cast<AliAODHeader*>(fAodEv->GetHeader());
+ if(!aodheader) AliFatal("Not a standard AOD");
+
fHeader->fRun = fAodEv->GetRunNumber();
- fHeader->fOrbit = fAodEv->GetHeader()->GetOrbitNumber();
- fHeader->fPeriod = fAodEv->GetHeader()->GetPeriodNumber();
- fHeader->fBx = fAodEv->GetHeader()->GetBunchCrossNumber();
- fHeader->fL0 = fAodEv->GetHeader()->GetL0TriggerInputs();
- fHeader->fL1 = fAodEv->GetHeader()->GetL1TriggerInputs();
- fHeader->fL2 = fAodEv->GetHeader()->GetL2TriggerInputs();
- fHeader->fTrClassMask = fAodEv->GetHeader()->GetTriggerMask();
- fHeader->fTrCluster = fAodEv->GetHeader()->GetTriggerCluster();
- fHeader->fOffTriggers = fAodEv->GetHeader()->GetOfflineTrigger();
- fHeader->fFiredTriggers = fAodEv->GetHeader()->GetFiredTriggerClasses();
+ fHeader->fOrbit = aodheader->GetOrbitNumber();
+ fHeader->fPeriod = aodheader->GetPeriodNumber();
+ fHeader->fBx = aodheader->GetBunchCrossNumber();
+ fHeader->fL0 = aodheader->GetL0TriggerInputs();
+ fHeader->fL1 = aodheader->GetL1TriggerInputs();
+ fHeader->fL2 = aodheader->GetL2TriggerInputs();
+ fHeader->fTrClassMask = aodheader->GetTriggerMask();
+ fHeader->fTrCluster = aodheader->GetTriggerCluster();
+ fHeader->fOffTriggers = aodheader->GetOfflineTrigger();
+ fHeader->fFiredTriggers = aodheader->GetFiredTriggerClasses();
} else {
fHeader->fRun = fEsdEv->GetRunNumber();
fHeader->fOrbit = fEsdEv->GetHeader()->GetOrbitNumber();
AliAODEvent *aodEvent=dynamic_cast<AliAODEvent*>(event);
if(aodEvent){
- if(aodEvent->GetHeader()){return aodEvent->GetHeader()->GetCentrality();}
+ if(aodEvent->GetHeader()){return ((AliVAODHeader*)aodEvent->GetHeader())->GetCentrality();}
}
return -1;
AliAODEvent *aodEvent=dynamic_cast<AliAODEvent*>(event);
if(aodEvent){
- if(aodEvent->GetHeader()){return aodEvent->GetHeader()->GetCentrality();}
+ if(aodEvent->GetHeader()){return ((AliVAODHeader*)aodEvent->GetHeader())->GetCentrality();}
}
return -1;
}
FillHistogram("hSelEvents",1.5) ;
- AliAODHeader *header = event->GetHeader() ;
+ AliAODHeader *header = dynamic_cast<AliAODHeader*>(event->GetHeader()) ;
+ if(!header) AliFatal("Not a standard AOD");
// Checks if we have a primary vertex
// Get primary vertices form ESD
}
FillHistogram("hSelEvents",1.5) ;
- AliAODHeader *header = event->GetHeader() ;
+ AliAODHeader *header = dynamic_cast<AliAODHeader*>(event->GetHeader()) ;
+ if(!header) AliFatal("Not a standard AOD");
// Checks if we have a primary vertex
// Get primary vertices form ESD
//______________________________________________________________________________
void AliPHOSEmbedding::ConvertHeader(AliESDEvent & esd){
- AliAODHeader* header = AODEvent()->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(AODEvent()->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
header->SetRunNumber(esd.GetRunNumber());
header->SetOfflineTrigger(fInputHandler->IsEventSelected()); // propagate the decision of the physics selection
}
if(fSystem == AA){ // PbPb
- centralityObj = AOD->GetHeader()->GetCentralityP();
+ centralityObj = ((AliVAODHeader*)AOD->GetHeader())->GetCentralityP();
MultipOrCent = centralityObj->GetCentralityPercentileUnchecked("V0M");
AliInfo(Form("Centrality is %f", MultipOrCent));
}
Double_t MultipOrCent = -1;
AliAODEvent* aodEvent=dynamic_cast<AliAODEvent*>(pEvent);
if (aodEvent) {
- centralityObj = aodEvent->GetHeader()->GetCentralityP();
+ centralityObj = ((AliVAODHeader*)aodEvent->GetHeader())->GetCentralityP();
if (centralityObj) {
MultipOrCent = centralityObj->GetCentralityPercentileUnchecked("V0M");
}
MultipOrCent = multiplicity; // convert from Int_t to Double_t
}
if(fSystem){ // PbPb
- centralityObj = AOD->GetHeader()->GetCentralityP();
+ centralityObj = ((AliVAODHeader*)AOD->GetHeader())->GetCentralityP();
MultipOrCent = centralityObj->GetCentralityPercentileUnchecked("V0M");
AliInfo(Form("Centrality is %f", MultipOrCent));
}
if(fUseCentrality){ // PbPb
if(!fDMesonCutObject){
- centralityObj = fAODEvent->GetHeader()->GetCentralityP();
+ centralityObj = ((AliVAODHeader*)fAODEvent->GetHeader())->GetCentralityP();
fMultCentr = centralityObj->GetCentralityPercentileUnchecked("V0M");
}
else fMultCentr = fDMesonCutObject->GetCentrality(fAODEvent);
if(fIsAOD)
{
- fCentrality = fAOD->GetHeader()->GetCentralityP();
+ fCentrality = ((AliVAODHeader*)fAOD->GetHeader())->GetCentralityP();
}
else
{
if(fIsAOD){
- //AliAODHeader * aodh = fAOD->GetHeader();
+ //AliAODHeader * aodh = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ // if(!aodh) AliFatal("Not a standard AOD");
//Int_t bc= aodh->GetBunchCrossNumber();
Int_t trigger = -1;
if (fAOD){
- Double_t multiplicity=fAOD->GetHeader()->GetRefMultiplicity();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+ Double_t multiplicity=header->GetRefMultiplicity();
fTrigMulti->Fill(-0.5, multiplicity);
if(evSelMask & AliVEvent::kAny) fTrigMulti->Fill(0.5, multiplicity);
if(evSelMask & AliVEvent::kMB) fTrigMulti->Fill(1.5, multiplicity);
UInt_t evSelMask=((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
Double_t centrality=fCuts->GetCentrality(aod);
- Double_t multiplicity=aod->GetHeader()->GetRefMultiplicity();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+
+ Double_t multiplicity=header->GetRefMultiplicity();
Int_t runNumber = aod->GetRunNumber();
TString trigClass=aod->GetFiredTriggerClasses();
Int_t nAODtracks=aod->GetNumberOfTracks();
if(mincent==100)mincent--;
((AliCounterCollection*)fOutputCounters->FindObject("secondEstimator"))->Count(Form("centralityclass:%d_%d/Run:%d",mincent,mincent+10,runNumber));
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+
+
if(stdCent<fCuts->GetMinCentrality() || stdCent>fCuts->GetMaxCentrality()){
((TH1F*)fOutputCheckCentrality->FindObject("hNtrackletsOut"))->Fill(aod->GetTracklets()->GetNumberOfTracklets());
- ((TH1F*)fOutputCheckCentrality->FindObject("hMultOut"))->Fill(aod->GetHeader()->GetRefMultiplicity());
+ ((TH1F*)fOutputCheckCentrality->FindObject("hMultOut"))->Fill(header->GetRefMultiplicity());
}else{
((TH1F*)fOutputCheckCentrality->FindObject("hNtrackletsIn"))->Fill(aod->GetTracklets()->GetNumberOfTracklets());
- ((TH1F*)fOutputCheckCentrality->FindObject("hMultIn"))->Fill(aod->GetHeader()->GetRefMultiplicity());
+ ((TH1F*)fOutputCheckCentrality->FindObject("hMultIn"))->Fill(header->GetRefMultiplicity());
}
- ((TH2F*)fOutputCheckCentrality->FindObject("hMultvsPercentile"))->Fill(aod->GetHeader()->GetRefMultiplicity(),stdCentf);
+ ((TH2F*)fOutputCheckCentrality->FindObject("hMultvsPercentile"))->Fill(header->GetRefMultiplicity(),stdCentf);
((TH2F*)fOutputCheckCentrality->FindObject("hntrklvsPercentile"))->Fill(aod->GetTracklets()->GetNumberOfTracklets(),stdCentf);
((TH2F*)fOutputCheckCentrality->FindObject("hntrklvsPercentile01"))->Fill(AliVertexingHFUtils::GetNumberOfTrackletsInEtaRange(aod,-1.,1.),stdCentf);
((TH2F*)fOutputCheckCentrality->FindObject("hnTPCTracksvsPercentile"))->Fill(nSelTracksTPCOnly,stdCentf);
if(fOnOff[0]){
((TH1F*)fOutputTrack->FindObject("hNtracklets"))->Fill(aod->GetTracklets()->GetNumberOfTracklets());
((TH1F*)fOutputTrack->FindObject("hNtracklets01"))->Fill(AliVertexingHFUtils::GetNumberOfTrackletsInEtaRange(aod,-1.,1.));
- ((TH1F*)fOutputTrack->FindObject("hMult"))->Fill(aod->GetHeader()->GetRefMultiplicity());
+ ((TH1F*)fOutputTrack->FindObject("hMult"))->Fill(header->GetRefMultiplicity());
((TH1F*)fOutputTrack->FindObject("hMultFBit4"))->Fill(ntracksFBit4);
- ((TH1F*)fOutputTrack->FindObject("hMultComb05"))->Fill(aod->GetHeader()->GetRefMultiplicityComb05());
- ((TH1F*)fOutputTrack->FindObject("hMultComb08"))->Fill(aod->GetHeader()->GetRefMultiplicityComb08());
+ ((TH1F*)fOutputTrack->FindObject("hMultComb05"))->Fill(header->GetRefMultiplicityComb05());
+ ((TH1F*)fOutputTrack->FindObject("hMultComb08"))->Fill(header->GetRefMultiplicityComb08());
}
}
}
TClonesArray *mcArray = (TClonesArray*)((AliAODEvent*)aodEvent)->GetList()->FindObject(AliAODMCParticle::StdBranchName());
if(mcArray) {fUseAOD049=kFALSE;}
- AliAODHeader *header=aodEvent->GetHeader();
+ AliAODHeader *header=dynamic_cast<AliAODHeader*>(aodEvent->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
AliCentrality *centrality=header->GetCentralityP();
Float_t cent=-999.;
Bool_t isSelRun=kFALSE;
Double_t centValue = 0.;
if(fESD) {cent = fESD->GetCentrality();
if(cent) centValue = cent->GetCentralityPercentile("V0M");}
- else centValue=aod->GetHeader()->GetCentrality();
+ else centValue=((AliVAODHeader*)aod->GetHeader())->GetCentrality();
if(fDebug) printf("centrality: %f\n", centValue);
// if (centValue < fCentMin || centValue > fCentMax){
Int_t cl = 0;
if(handler->InheritsFrom("AliAODInputHandler")){
// since it is not supported by the helper task define own classes
- centPercent = fAOD->GetHeader()->GetCentrality();
+ centPercent = ((AliVAODHeader*)fAOD->GetHeader())->GetCentrality();
cl = 1;
if(centPercent>10) cl = 2;
if(centPercent>30) cl = 3;
if(fIsPbPb){
if(fESD) {cent = fESD->GetCentrality();
if(cent) centValue = cent->GetCentralityPercentile("V0M");}
- else centValue=aod->GetHeader()->GetCentrality();
+ else centValue=((AliVAODHeader*)aod->GetHeader())->GetCentrality();
if(fDebug) printf("centrality: %f\n", centValue);
if (centValue < fCentMin || centValue > fCentMax){
Int_t iCount=0;
Int_t trigJet=-1;
Int_t trigBBTrack=-1;
- // Int_t trigInTrack=-1;
- fRPAngle = aod->GetHeader()->GetEventplane();
+ // Int_t trigInTrack=-1;
+ fRPAngle = ((AliVAODHeader*)aod->GetHeader())->GetEventplane();
if(fHardest==0 || fHardest==1){
AliVParticle *partback = (AliVParticle*)ParticleList.At(nT);
for(int it = 0;it < aod->GetNumberOfTracks();++it){
- AliAODTrack *tr = aod->GetTrack(it);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>(aod->GetTrack(it));
+ if(!tr) AliFatal("Not a standard AOD");
Bool_t bGood = false;
if(fFilterType == 0)bGood = true;
else if(fFilterType == 1)bGood = tr->IsHybridTPCConstrainedGlobal();
for(Int_t cr=0;cr<100;cr++){triggers[cr]=-1;}
Int_t im=0;
for(int it = 0;it < aod->GetNumberOfTracks();++it){
- AliAODTrack *tr = aod->GetTrack(it);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>(aod->GetTrack(it));
+ if(!tr) AliFatal("Not a standard AOD");
Bool_t bGood = false;
if(fFilterType == 0)bGood = true;
else if(fFilterType == 1)bGood = tr->IsHybridTPCConstrainedGlobal();
// Double_t dif=0;
Int_t iCount=0;
for(int it = 0;it < aod->GetNumberOfTracks();++it){
- AliAODTrack *tr = aod->GetTrack(it);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>(aod->GetTrack(it));
+ if(!tr) AliFatal("Not a standard AOD");
if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask)))continue;
if(TMath::Abs(tr->Eta())>0.9)continue;
if(tr->Pt()<0.15)continue;
else aod = fAODOut;
for(int it = 0;it < aod->GetNumberOfTracks();++it){
- AliAODTrack *tr = aod->GetTrack(it);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>(aod->GetTrack(it));
+ if(!tr) AliFatal("Not a standard AOD");
if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask)))continue;
if(TMath::Abs(tr->Eta())>0.9)continue;
if(tr->Pt()<0.15)continue;
cent = fESD->GetCentrality();
if(cent) centValue = cent->GetCentralityPercentile("V0M");
}else{
- centValue = aod->GetHeader()->GetCentrality();
+ centValue = ((AliVAODHeader*)aod->GetHeader())->GetCentrality();
}
if(fDebug) printf("centrality: %f\n", centValue);
//Input events
//-----------------select disjunct event subsamples ----------------
if(!fIsKine){ //reconstructed data
- Int_t eventnum = aod->GetHeader()->GetEventNumberESDFile();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+
+ Int_t eventnum = header->GetEventNumberESDFile();
Int_t lastdigit = eventnum % 10;
if(!(fEventNumberRangeLow<=lastdigit && lastdigit<=fEventNumberRangeHigh)){
fHistEvtSelection->Fill(5);
Float_t cent = 0;
if(fCollisionType==kPbPb){
- if(aod)cent = aod->GetHeader()->GetCentrality();
+ if(aod)cent = ((AliVAODHeader*)aod->GetHeader())->GetCentrality();
if(fDebug)Printf("%s:%d %3.3f",(char*)__FILE__,__LINE__,cent);
if(cent<0)cent = 101;
}
Float_t zvtx = vtxAOD->GetZ();
Int_t iCl = GetEventClass(aod);
AliAnalysisHelperJetTasks::EventClass(kTRUE,iCl);
- Bool_t cand = aod->GetHeader()->GetOfflineTrigger()&fPhysicsSelectionFlag;
- if(fDebug)Printf("%s:%d AOD selection %d %d",(char*)__FILE__,__LINE__,cand,aod->GetHeader()->GetOfflineTrigger());
+ Bool_t cand = ((AliVAODHeader*)aod->GetHeader())->GetOfflineTrigger()&fPhysicsSelectionFlag;
+ if(fDebug)Printf("%s:%d AOD selection %d %d",(char*)__FILE__,__LINE__,cand,((AliVAODHeader*)aod->GetHeader())->GetOfflineTrigger());
fh2TriggerCount->Fill(0.,kAllTriggered);
fh2TriggerCount->Fill(iCl,kAllTriggered);
if(cand){
TList recTracks;
GetListOfTracks(&recTracks);
CalculateReactionPlaneAngleVZERO(aod);
- fRPAngle = aod->GetHeader()->GetEventplane();
+ fRPAngle = ((AliVAODHeader*)aod->GetHeader())->GetEventplane();
fh1RP->Fill(fRPAngle);
fh2RPCentrality->Fill(fCentrality,fRPAngle);
fh2RPACentrality->Fill(fCentrality,fPsiVZEROA);
Int_t AliAnalysisTaskJetServices::GetEventClass(AliAODEvent *aod){
if(fCollisionType==kPbPb){
- Float_t cent = aod->GetHeader()->GetCentrality();
+ Float_t cent = ((AliVAODHeader*)aod->GetHeader())->GetCentrality();
if(cent>80||cent<0)return 5;
if(cent>50)return 4;
if(cent>30)return 3;
// CalculateReactionPlaneAngle(&recParticles);
fRPAngle = 0;
- if(fRPMethod==0)fRPAngle = aod->GetHeader()->GetEventplane();
+ if(fRPMethod==0)fRPAngle = ((AliVAODHeader*)aod->GetHeader())->GetEventplane();
else if(fRPMethod==1||fRPMethod==2){
- fRPAngle = aod->GetHeader()->GetQTheta(fRPMethod);
+ AliAODHeader * aodheader = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!aodheader) AliFatal("Not a standard AOD");
+ fRPAngle = aodheader->GetQTheta(fRPMethod);
}
fh1RP->Fill(fRPAngle);
fh2RPCentrality->Fill(fCentrality,fRPAngle);
if(!aod){
return 101;
}
- return aod->GetHeader()->GetCentrality();
+ return ((AliVAODHeader*)aod->GetHeader())->GetCentrality();
}
if(fIsHIevent)
{
- AliAODHeader *aodHeader = fAOD->GetHeader();
+ AliAODHeader *aodHeader = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
fEventCent = aodHeader->GetCentrality();
}
fJetAcceptance = 0.5 - fIncExcR; // if the increase is 0.1 -> only jets within |eta|<0.4
// First test of reference multiplicity
- Int_t refMultiplicity = fAOD->GetHeader()->GetRefMultiplicity();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+
+ Int_t refMultiplicity = header->GetRefMultiplicity();
fRefMult->Fill(refMultiplicity);
// Multiplicity from V0 (V0A+V0C)
}
}
else if(fDataType==kAOD) {
- if(dynamic_cast<AliAODEvent*>(fEvent)->GetHeader()->GetCentrality())
- cent = dynamic_cast<AliAODEvent*>(fEvent)->GetHeader()->GetCentrality();
+ if(((AliVAODHeader*)dynamic_cast<AliAODEvent*>(fEvent)->GetHeader())->GetCentrality())
+ cent = ((AliVAODHeader*)dynamic_cast<AliAODEvent*>(fEvent)->GetHeader())->GetCentrality();
}
if(cent>90.) {
fNEventReject->Fill("cent>90",1);
//
if(!aod) return 5;
- Float_t cent = aod->GetHeader()->GetCentrality();
+ Float_t cent = ((AliVAODHeader*)aod->GetHeader())->GetCentrality();
if(fDebug>3) printf("centrality: %f\n",cent);
return GetCentralityClass(cent);
if(handler && handler->InheritsFrom("AliAODInputHandler")){
- centPercent = fAOD->GetHeader()->GetCentrality();
+ centPercent = ((AliVAODHeader*)fAOD->GetHeader())->GetCentrality();
cl = 1;
//std::cout<<"centPercent: "<<centPercent<<std::endl;
return;
}
-// fdCentrality = fAODIn->GetHeader()->GetCentrality(); // event centrality
- fdCentrality = fAODIn->GetHeader()->GetCentralityP()->GetCentralityPercentile("V0M"); // event centrality
+// fdCentrality = ((AliVAODHeader*)fAODIn->GetHeader())->GetCentrality(); // event centrality
+ fdCentrality = ((AliVAODHeader*)fAODIn->GetHeader())->GetCentralityP()->GetCentralityPercentile("V0M"); // event centrality
if(!fbIsPbPb)
fdCentrality = 0.;
Int_t iCentIndex = GetCentralityBinIndex(fdCentrality); // get index of centrality bin
return kFALSE;
Double_t centrality;
// centrality = fAOD->GetHeader()->GetCentrality();
- centrality = fAOD->GetHeader()->GetCentralityP()->GetCentralityPercentile("V0M");
+ centrality = ((AliVAODHeader*)fAOD->GetHeader())->GetCentralityP()->GetCentralityPercentile("V0M");
if(fbIsPbPb)
{
if(centrality < 0)
Int_t cl = 0;
if(handler->InheritsFrom("AliAODInputHandler")){
// since it is not supported by the helper task define own classes
- centPercent = fAOD->GetHeader()->GetCentrality();
+ centPercent = ((AliVAODHeader*)fAOD->GetHeader())->GetCentrality();
cl = 1;
if(centPercent>10) cl = 2;
if(centPercent>30) cl = 3;
Int_t cl = 0;
if(handler->InheritsFrom("AliAODInputHandler")){
// since it is not supported by the helper task define own classes
- centPercent = fAOD->GetHeader()->GetCentrality();
+ centPercent = ((AliVAODHeader*)fAOD->GetHeader())->GetCentrality();
cl = 1;
if(centPercent>10) cl = 2;
if(centPercent>30) cl = 3;
}
// Retrieve reference multiplicities in |eta|<0.8 and <0.5
- const Int_t refMult5 = fAOD->GetHeader()->GetRefMultiplicityComb05();
- const Int_t refMult8 = fAOD->GetHeader()->GetRefMultiplicityComb08();
+
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(fAOD->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+
+ const Int_t refMult5 = header->GetRefMultiplicityComb05();
+ const Int_t refMult8 = header->GetRefMultiplicityComb08();
const Double_t centPercentPP = fAnaUtils->GetMultiplicityPercentile(fAOD, "V0M");
// all rec. tracks, esd filter mask, eta range
for(Int_t it=0; it<fAOD->GetNumberOfTracks(); ++it){
- AliAODTrack *tr = fAOD->GetTrack(it);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(it));
+ if(!tr) AliFatal("Not a standard AOD");
if(type == kTrackAODCuts || type==kTrackAODQualityCuts || type==kTrackAODExtraCuts){
if(fIsPbPb){
if(fESD) {cent = fESD->GetCentrality();
if(cent) centValue = cent->GetCentralityPercentile("V0M");}
- else centValue=aod->GetHeader()->GetCentrality();
+ else centValue=((AliVAODHeader*)aod->GetHeader())->GetCentrality();
if(fDebug) printf("centrality: %f\n", centValue);
if (centValue < fCentMin || centValue > fCentMax){
if(fESD) {cent = fESD->GetCentrality();
if(cent) centrality = cent->GetCentralityPercentile("V0M");}
- else centrality=aodE->GetHeader()->GetCentrality();
+ else centrality=((AliVAODHeader*)aodE->GetHeader())->GetCentrality();
if(!fkIsPbPb) {
Float_t centrality = -1;
if(fEventClass > 0)
{
- if(handler->InheritsFrom("AliAODHandler")) centrality = fAODIn->GetHeader()->GetCentrality();
+ if(handler->InheritsFrom("AliAODHandler")) centrality = ((AliVAODHeader*)fAODIn->GetHeader())->GetCentrality();
else if(fESD) centrality = fESD->GetCentrality()->GetCentralityPercentile("V0M");
else centrality = AliAnalysisHelperJetTasks::EventClass();
}
if (HasCentrality()) {
Double_t cent = forward->GetCentrality();
if (!fCentMethod.IsNull()) {
- AliAODHeader* hdr = aod.GetHeader();
+ AliAODHeader* hdr = dynamic_cast<AliAODHeader*>(aod.GetHeader());
+ if(!hdr) AliFatal("Not a standard AOD");
if (hdr) {
AliCentrality* cP = hdr->GetCentralityP();
if (cP) {
LoadBranches();
- AliAODHeader* aodHeader = aod->GetHeader();
+ AliAODHeader* aodHeader = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+ if(!aodHeader) AliFatal("Not a standard AOD");
if (!aodHeader) {
AliWarning("Missing AOD header");
aodHeader = new AliAODHeader(esd->GetRunNumber(),
plane = fInputEvent->GetEventplane();
else if (fInputEvent->InheritsFrom(AliAODEvent::Class())) {
AliAODEvent *aodEvent = (AliAODEvent *)fInputEvent;
- plane = aodEvent->GetHeader()->GetEventplaneP();
+ plane = ((AliVAODHeader*)aodEvent->GetHeader())->GetEventplaneP();
}
if (plane)
if(fLnID == 0) AliFatal("PID not set");
// multiplicity and centrality
-
- fNtrk = (fMaxEta > 0.5) ? fAODevent->GetHeader()->GetRefMultiplicityComb08() : fAODevent->GetHeader()->GetRefMultiplicityComb05();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(fAODevent->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+
+ fNtrk = (fMaxEta > 0.5) ? header->GetRefMultiplicityComb08() : header->GetRefMultiplicityComb05();
if(fSimulation) fNch = this->GetChargedMultiplicity(fMaxEta);
if(fHeavyIons)
{
- Double_t centrality = fAODevent->GetHeader()->GetCentrality();
+ Double_t centrality = ((AliVAODHeader*)fAODevent->GetHeader())->GetCentrality();
fCentTriggerFired = (centrality >= fMinCentrality) && (centrality < fMaxCentrality);
}
}
Int_t Nch=0;
for (Int_t iTracks = 0; iTracks < fAOD->GetNumberOfTracks(); iTracks++) {
- AliAODTrack* track = fAOD->GetTrack(iTracks);
- if (!fTrackCuts->IsSelected(track,kFALSE)) continue;
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
+ if (!fTrackCuts->IsSelected(track,kFALSE)) continue;
((TH1F*)fOutput->FindObject("fHistoEtaBefSel"))->Fill(track->Eta());
if(fIsSelected){
((TH1F*)fOutput->FindObject("fHistoEtaAftSel"))->Fill(track->Eta());
// FIXME: why this is not tracket in the track stats histos?
Int_t Ncharged=0;
for (Int_t iTracks = 0; iTracks < fAOD->GetNumberOfTracks(); iTracks++){
- AliAODTrack* track = fAOD->GetTrack(iTracks);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!fTrackCuts->IsSelected(track,kFALSE)) continue;
Ncharged++;
}
Double_t Qx2 = 0, Qy2 = 0;
Int_t mult = 0;
for(Int_t iT = 0; iT < fAOD->GetNumberOfTracks(); iT++) {
- AliAODTrack* aodTrack = fAOD->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (!aodTrack->TestFilterBit(128)) continue; //FIXME track type hard coded -> TPC only constrained to the vertex
if (aodTrack->Eta() <etaMin || aodTrack->Eta() > etaMax)continue;
mult++;
AliCentrality* centrality = 0;
AliAODEvent* aod = (AliAODEvent*)ev;
- centrality = aod->GetHeader()->GetCentralityP();
+ centrality = ((AliVAODHeader*)aod->GetHeader())->GetCentralityP();
Float_t centV0 = centrality->GetCentralityPercentile("V0M");
Float_t centTrk = centrality->GetCentralityPercentile("TRK");
{
AliAODEvent* aodevent=0x0;
aodevent=dynamic_cast<AliAODEvent*>(fAOD);
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(aodevent->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+
if(TMath::Abs(0.8-fetarangeofmultiplicitycut)<0.1)
- Ncharged=aodevent->GetHeader()->GetRefMultiplicityComb08();
+ Ncharged=header->GetRefMultiplicityComb08();
else if (TMath::Abs(0.5-fetarangeofmultiplicitycut)<0.1)
- Ncharged=aodevent->GetHeader()->GetRefMultiplicityComb05();
+ Ncharged=header->GetRefMultiplicityComb05();
else
Ncharged=-1;
}
// Centrality definition
Double_t lCent = 0.0;
AliCentrality *centralityObj = 0;
- centralityObj = aod->GetHeader()->GetCentralityP();
+ centralityObj = ((AliVAODHeader*)aod->GetHeader())->GetCentralityP();
lCent = centralityObj->GetCentralityPercentile("V0M");
if ((lCent < 0.)||(lCent > 90.)) return;
fHistCentVtx->Fill(lCent,lPVz);
if (fReplicateHeader)
{
- *fHeader = *(source.GetHeader());
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(source.GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+ *fHeader = *(header);
}
fVertices->Clear("C");
if (fReplicateHeader)
{
- *fHeader = *(source.GetHeader());
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(source.GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
+ *fHeader = *(header);
}
fVertices->Clear("C");
centrality = lAODevent->GetCentrality();
Float_t percentile=centrality->GetCentralityPercentile("V0M");
- Float_t refMult = lAODevent->GetHeader()->GetRefMultiplicity();
+ Float_t refMult = ((AliVAODHeader*)lAODevent->GetHeader())->GetRefMultiplicity();
fHistTrackMultiplicity->Fill(refMult,percentile); //tracce per evento
if(isAOD) {
AliAODEvent* aodEvent = dynamic_cast<AliAODEvent*>(fInputEvent);
if(!aodEvent) return cent;
- AliAODHeader* header = aodEvent->GetHeader();
+ AliAODHeader* header = dynamic_cast<AliAODHeader*>(aodEvent->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
if(!header) return cent;
AliCentrality *centrality = header->GetCentralityP();
if(!centrality) return cent;
if(fIsAOD){
Int_t nclsITS = 0;
runNumber=((AliAODEvent*)event)->GetRunNumber();
- nclsITS = ((AliAODEvent*)event)->GetHeader()->GetNumberOfITSClusters(1);
+ nclsITS = ((AliVAODHeader*)((AliAODEvent*)event)->GetHeader())->GetNumberOfITSClusters(1);
if(nclsITS<fMinMult || nclsITS>fMaxMult) return;
firedTriggerClasses=((AliAODEvent*)event)->GetFiredTriggerClasses();
if(!firedTriggerClasses.Contains(fTriggerClass.Data())) return;
if(!aod) return;
//input data
- fDataFilnam = aod->GetHeader()->GetESDFileName();
- fEvtNum = aod->GetHeader()->GetEventNumberESDFile();
+ AliAODHeader * header = dynamic_cast<AliAODHeader*>(aod->GetHeader());
+if(!header) AliFatal("Not a standard AOD");
+
+ fDataFilnam = header->GetESDFileName();
+ fEvtNum = header->GetEventNumberESDFile();
fRunNum = aod->GetRunNumber();
if(!isTriggered ) return;
//trigger inputs
- fL0inputs = aod->GetHeader()->GetL0TriggerInputs();
- fL1inputs = aod->GetHeader()->GetL1TriggerInputs();
+ fL0inputs = ((AliVAODHeader*)aod->GetHeader())->GetL0TriggerInputs();
+ fL1inputs = ((AliVAODHeader*)aod->GetHeader())->GetL1TriggerInputs();
//Event identification
fPerNum = aod ->GetPeriodNumber();
// FIXME: use dynamic cast in AliAODEVent?
virtual AliCentrality* GetCentralityP() const {AliError("Not Implemented"); return 0;};
virtual AliEventplane* GetEventplaneP() const {AliError("Not Implemented"); return 0;};
+ virtual Double_t GetEventplane() const {AliError("Not Implemented"); return 0;};
virtual const Float_t* GetVZEROEqFactors() const {AliError("Not Implemented"); return 0;};
virtual Float_t GetVZEROEqFactors(Int_t /* i */) const {AliError("Not Implemented"); return 0;};
virtual void SetVZEROEqFactors(const Float_t* /*factors*/) {AliError("Not Implemented"); }
virtual void Clear(Option_t * opt) ;
+ virtual Int_t GetIRInt2ClosestInteractionMap() const {AliError("Not Implemented"); return 0;};
+ virtual Int_t GetIRInt1ClosestInteractionMap(Int_t /*gap = 3*/) const {AliError("Not Implemented"); return 0;};
+
+
+ virtual Int_t GetRefMultiplicity() const { AliError("Not Impletented"); return 0; }
Double_t GetMagneticField() const { return GetVar(1); }
- Double_t GetCentrality (const char *estimator = "V0M") { return GetVar(0);}
+ Double_t GetCentrality (/*estimator = "V0M"*/) const { return GetVar(0);}
ClassDef(AliNanoAODHeader, 1)
// FIXME: use dynamic cast in AliAODEVent?
virtual AliCentrality* GetCentralityP() const = 0;
virtual AliEventplane* GetEventplaneP() const = 0;
+ virtual Double_t GetCentrality () const = 0;
virtual const Float_t* GetVZEROEqFactors() const = 0;
virtual Float_t GetVZEROEqFactors(Int_t /* i */) const = 0;
virtual void SetVZEROEqFactors(const Float_t* /*factors*/) = 0;
- virtual UInt_t GetOfflineTrigger() = 0;
+ virtual UInt_t GetOfflineTrigger() = 0;
+ virtual Int_t GetRefMultiplicity() const =0;
+ virtual Double_t GetEventplane() const =0;
};
virtual TBits GetIRInt2InteractionMap() const { static TBits dummy; return dummy; }
virtual TBits GetIRInt1InteractionMap() const { static TBits dummy; return dummy; }
+ virtual Int_t GetIRInt2ClosestInteractionMap() const {return 0;}
+ virtual Int_t GetIRInt1ClosestInteractionMap(Int_t =3/*gap = 3*/) const {return 0;}
+
virtual void Print(Option_t* option = "") const = 0;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff