Short_t nTrTPCcandle = 0;
for (Int_t iTracks = 0; iTracks < aod->GetNumberOfTracks(); iTracks++) {
- AliAODTrack* track = aod->GetTrack(iTracks);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(aod->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!track) continue;
if (!track->TestFilterBit(1<<5) &&
}
}
- AliAODTrack* trmax = aod->GetTrack(0);
+ AliAODTrack* trmax = dynamic_cast<AliAODTrack*>(aod->GetTrack(0));
+ if(!trmax) AliFatal("Not a standard AOD");
for (int iter = 1; iter<NT;iter++){
AliAODTrack* track = dynamic_cast<AliAODTrack*> (tracklist->At(iter));
if (track && (track->Pt() > trmax->Pt())) trmax = track;
Int_t ntpc = fESDtrackCuts->GetMinNClusterTPC();
for (Int_t i = 0; i < aod->GetNumberOfTracks() ; i++){
- tr = aod->GetTrack(i);
+ tr = dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
+ if(!tr) AliFatal("Not a standard AOD");
maxidtemp = tr->GetID();
if(maxidtemp < 0 && fAODfilterbit != 128) continue;
if(maxidtemp > -1 && fAODfilterbit == 128) continue;
//If the input event is AOD, the starting point for extrapolation is at vertex
//AOD tracks are selected according to its filterbit.
else if (aodevent) {
- aodTrack = aodevent->GetTrack(itr);
+ aodTrack = dynamic_cast<AliAODTrack*>(aodevent->GetTrack(itr));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (!aodTrack) continue;
if (fAODTPCOnlyTracks) { // Match with TPC only tracks, default from May 2013, before filter bit 32
for(Int_t it=0; it<nTracks; ++it){
AliAODTrack *tmpTr = 0x0;
- if(fEmbedMode==kAODFull) tmpTr = fAODevent->GetTrack(it);
+ if(fEmbedMode==kAODFull) {
+ tmpTr = dynamic_cast<AliAODTrack*>(fAODevent->GetTrack(it));
+ if(!tmpTr) AliFatal("Not a standard AOD");
+ }
if(fEmbedMode==kAODJetTracks) tmpTr = dynamic_cast<AliAODTrack*>(leadJet->GetRefTracks()->At(it));
if(!tmpTr) continue;
Double_t rd=rndm->Uniform(0.,1.);
Int_t rawN = tAOD->GetNumberOfTracks();
Int_t ref=0;
for(Int_t id=0; id!=rawN; ++id) {
- track = tAOD->GetTrack(id);
+ track = dynamic_cast<AliAODTrack*>(tAOD->GetTrack(id));
+ if(!track) AliFatal("Not a standard AOD");
if(!track->TestFilterBit(fRFPFilterBit)) continue;
++ref;
}
ReadStack(mcArray);
}
for(int i=0; i!=tAOD->GetNumberOfTracks(); ++i) {
- AliAODTrack *t = tAOD->GetTrack( i );
+ AliAODTrack *t = dynamic_cast<AliAODTrack*>(tAOD->GetTrack( i ));
if(!t) continue;
if( !t->TestFilterBit(1) ) continue;
fDecayMass=0.0; // using mass as nsigmas control plot
//=>looping
Int_t rawN = tAOD->GetNumberOfTracks();
for(Int_t id=0; id!=rawN; ++id) {
- track = tAOD->GetTrack(id);
+ track = dynamic_cast<AliAODTrack*>(tAOD->GetTrack(id));
+ if(!track) AliFatal("Not a standard AOD");
//=>cuts
if(!track->TestFilterBit(fRFPFilterBit)) continue;
if( fExcludeTPCEdges )
Int_t AliAnalysisTaskFlowStrange::RefMult(AliAODEvent *tAOD, Int_t fb) {
Int_t found = 0;
for(int i=0; i!=tAOD->GetNumberOfTracks(); ++i) {
- AliAODTrack *t = tAOD->GetTrack( i );
+ AliAODTrack *t = dynamic_cast<AliAODTrack*>(tAOD->GetTrack( i ));
if(!t) continue;
if( !t->TestFilterBit(fb) ) continue;
if( t->Eta()<-0.8 || t->Eta()>+0.8 ) continue;
if(!ev) return -1;
Int_t found = 0;
for(int i=0; i!=ev->GetNumberOfTracks(); ++i) {
- AliAODTrack *t = ev->GetTrack( i );
+ AliAODTrack *t = dynamic_cast<AliAODTrack*>(ev->GetTrack( i ));
if(!t) continue;
if( !t->TestFilterBit(1) ) continue;
if( t->Eta()<-0.8 || t->Eta()>+0.8 ) continue;
if(!ev) return -1;
Int_t found = 0;
for(int i=0; i!=ev->GetNumberOfTracks(); ++i) {
- AliAODTrack *t = ev->GetTrack( i );
+ AliAODTrack *t = dynamic_cast<AliAODTrack*>(ev->GetTrack( i ));
if(!t) continue;
if( !t->TestFilterBit(16) ) continue;
if( t->Eta()<-0.8 || t->Eta()>+0.8 ) continue;
Float_t multTPC(0.); // tpc mult estimate
Float_t multGlob(0.); // global multiplicity
for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill tpc mult
- AliAODTrack* trackAOD = event->GetTrack(iTracks);
+ AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(event->GetTrack(iTracks));
+ if(!trackAOD) AliFatal("Not a standard AOD");
if (!trackAOD) continue;
if (!(trackAOD->TestFilterBit(1))) continue;
if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.2)) continue;
multTPC++;
}
for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill global mult
- AliAODTrack* trackAOD = event->GetTrack(iTracks);
+ AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(event->GetTrack(iTracks));
+ if(!trackAOD) AliFatal("Not a standard AOD");
if (!trackAOD) continue;
if (!(trackAOD->TestFilterBit(16))) continue;
if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.1)) continue;
Float_t multTPC(0.); // tpc mult estimate
Float_t multGlob(0.); // global multiplicity
for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill tpc mult
- AliAODTrack* trackAOD = event->GetTrack(iTracks);
+ AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(event->GetTrack(iTracks));
+ if(!trackAOD) AliFatal("Not a standard AOD");
if (!trackAOD) continue;
if (!(trackAOD->TestFilterBit(1))) continue;
if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.2)) continue;
multTPC++;
}
for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill global mult
- AliAODTrack* trackAOD = event->GetTrack(iTracks);
+ AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(event->GetTrack(iTracks));
+ if(!trackAOD) AliFatal("Not a standard AOD");
if (!trackAOD) continue;
if (!(trackAOD->TestFilterBit(16))) continue;
if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.1)) continue;
Int_t unp(0);
Int_t unn(0);
for (Int_t iTracks = 0; iTracks < unTracks; iTracks++) { // select analysis candidates
- AliAODTrack* track = fAOD->GetTrack(iTracks);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!PhiTrack(track)) continue;
if (fQA) {
if(track->Charge() > 0) {fEventStats->Fill(1); fPtP->Fill(track->Pt());}
arrayMC = (TClonesArray*) fAOD->GetList()->FindObject(AliAODMCParticle::StdBranchName());
if (!arrayMC) AliFatal("Error: MC particles branch not found!\n");
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(!PhiTrack(track) || !IsKaon(track)) { // check for kaons
if(fDebug>1) cout << " Rejected track" << endl;
continue;
for(Int_t iT = 0; iT < nAODTracks; iT++) {
- AliAODTrack* aodTrack = aodEvent->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (!aodTrack){
continue;
fHKsPhiEP->Fill(fZvtx,fgPsi2v0c);
//loop track and get pid
for(Int_t iT = 0; iT < nAODTracks; iT++) { // loop on the tracks
- AliAODTrack* aodTrack = aodEvent->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (!aodTrack){
continue;
// fill pion stacks
Int_t nAODTracks = fOutputAOD->GetNumberOfTracks();
for(Int_t iT = 0; iT < nAODTracks; iT++) { // loop on the tracks
- AliAODTrack* aodTrack = fOutputAOD->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(fOutputAOD->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (!aodTrack){
continue;
}
for(Int_t i=0;i < fNpiPos;i++){
- AliAODTrack *pip = fOutputAOD->GetTrack(fIPiPos[i]);
+ AliAODTrack *pip = dynamic_cast<AliAODTrack*>(fOutputAOD->GetTrack(fIPiPos[i]));
+ if(!pip) AliFatal("Not a standard AOD");
AliESDtrack pipE(pip);
for(Int_t j=0;j < fNpiNeg;j++){
- AliAODTrack *pin = fOutputAOD->GetTrack(fIPiNeg[j]);
+ AliAODTrack *pin = dynamic_cast<AliAODTrack*>(fOutputAOD->GetTrack(fIPiNeg[j]));
+ if(!pin) AliFatal("Not a standard AOD");
AliESDtrack pinE(pin);
Double_t xn, xp, mindist=pinE.GetDCA(&pipE,fOutputAOD->GetMagneticField(),xn,xp);
//loop over tracks
for (Int_t itrkN=0; itrkN<iNumberOfInputTracks; itrkN++)
{
- AliAODTrack* pParticle = anInput->GetTrack(itrkN); //get input particle
+ AliAODTrack* pParticle = dynamic_cast<AliAODTrack*>(anInput->GetTrack(itrkN));
+ if(!pParticle) AliFatal("Not a standard AOD"); //get input particle
//check if pParticle passes the cuts
Bool_t rpOK = kTRUE;
//runnumber
Int_t nTracks(aodevent->GetNumberOfTracks());
for(Int_t iTracks = 0; iTracks < nTracks; iTracks++) {
- AliAODTrack* track = aodevent->GetTrack(iTracks);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(aodevent->GetTrack(iTracks));
if(!track) continue;
if (!track || track->Pt() < .2 || track->Pt() > 5.0 || TMath::Abs(track->Eta()) > .8 || track->GetTPCNcls() < 70 || !track->GetDetPid() || track->GetDetPid()->GetTPCsignal() < 10.0) continue; // general quality cut
if (track->TestFilterBit(1) && track->Chi2perNDF() > 0.2) multTPC++;
#include "AliAODTrack.h"
#include "AliCFManager.h"
#include "AliFlowTrackSimpleCuts.h"
+#include "assert.h"
using std::endl;
using std::cout;
//loop over tracks
while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
- AliAODTrack* pParticle = anInput->GetTrack(itrkN); //get input particle
+ AliAODTrack* pParticle = dynamic_cast<AliAODTrack*>(anInput->GetTrack(itrkN));
+ assert((pParticle)&&"Not a standard AOD"); //get input particle
//make new AliFlowTrackSimple
AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
pTrack->SetPt(pParticle->Pt() );
//normal loop
while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
- AliAODTrack* pParticle = anInput->GetTrack(itrkN); //get input particle
+ AliAODTrack* pParticle = dynamic_cast<AliAODTrack*>(anInput->GetTrack(itrkN));
+ assert((pParticle)&&"Not a standard AOD"); //get input particle
//cut on tracks
if (TMath::Abs(pParticle->Eta()) < 0.9)
{
nTracksEv[0] = fInputAOD[iEv]->GetNumberOfTracks();
nTracksEv[1] = fInputAOD[jEv]->GetNumberOfTracks();
-
- for (Int_t i=0; i<nTracksEv[0]; i++) if(fInputAOD[iEv]->GetTrack(i)->IsMuonTrack()) nFWMuonsEv[0]++;
- for (Int_t i=0; i<nTracksEv[1]; i++) if(fInputAOD[jEv]->GetTrack(i)->IsMuonTrack()) nFWMuonsEv[1]++;
+ // Check if both events contain std aod tracks
+ if (!dynamic_cast<AliAODTrack*>(fInputAOD[iEv]->GetTrack(0)) || dynamic_cast<AliAODTrack*>(fInputAOD[jEv]->GetTrack(0))){
+ AliFatal("Not a standard AOD");
+ }
+
+ for (Int_t i=0; i<nTracksEv[0]; i++) if(((AliAODTrack*)fInputAOD[iEv]->GetTrack(i))->IsMuonTrack()) nFWMuonsEv[0]++;
+ for (Int_t i=0; i<nTracksEv[1]; i++) if(((AliAODTrack*)fInputAOD[jEv]->GetTrack(i))->IsMuonTrack()) nFWMuonsEv[1]++;
// Muon track mixing to fill a mass spectrum
// adding tracks and vertex to the output event...
for (Int_t i=0; i<nTracksEv[0]; i++) {
- if(fInputAOD[iEv]->GetTrack(i)->IsMuonTrack()) {
+ if(((AliAODTrack*)fInputAOD[iEv]->GetTrack(i))->IsMuonTrack()) {
if (fDebug) printf("fInputAOD[%d]->GetTrack(%d) = %p pt = %f uniqueID = %d\n",
iEv,i,fInputAOD[iEv]->GetTrack(i),fInputAOD[iEv]->GetTrack(i)->Pt(),
fInputAOD[iEv]->GetTrack(i)->GetUniqueID());
if (muonCounter[0]==rndMuonTrack[0]) {
- fOutputUserAOD->AddTrack(fInputAOD[iEv]->GetTrack(i));
+ fOutputUserAOD->AddTrack((AliAODTrack*)fInputAOD[iEv]->GetTrack(i));
nFWMUonsAdded++;
if (fInputAOD[iEv]->GetTrack(i)->Charge()>0) nPosTracksAdded++;
else nNegTracksAdded++;
}
for (Int_t i=0; i<nTracksEv[1]; i++) {
- if(fInputAOD[jEv]->GetTrack(i)->IsMuonTrack()) {
+ if(((AliAODTrack*)fInputAOD[jEv]->GetTrack(i))->IsMuonTrack()) {
if (fDebug) printf("fInputAOD[%d]->GetTrack(%d) = %p pt = %f uniqueID = %d\n",
jEv,i,fInputAOD[jEv]->GetTrack(i),fInputAOD[jEv]->GetTrack(i)->Pt(),
fInputAOD[jEv]->GetTrack(i)->GetUniqueID());
if (muonCounter[1]==rndMuonTrack[1]) {
- fOutputUserAOD->AddTrack(fInputAOD[jEv]->GetTrack(i));
+ fOutputUserAOD->AddTrack((AliAODTrack*)fInputAOD[jEv]->GetTrack(i));
nFWMUonsAdded++;
if (fInputAOD[jEv]->GetTrack(i)->Charge()>0) nPosTracksAdded++;
else nNegTracksAdded++;
if (fDebug) {
for (Int_t i=0; i<nFWMUonsAdded; i++) {
- AliAODTrack *tr = (AliAODTrack*) fOutputUserAOD->GetTrack(i);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>( fOutputUserAOD->GetTrack(i));
+ if(!tr) AliFatal("Not a standard AOD");
printf("fOutputUserAOD->GetTrack(%d) = %p pt = %f\n",i,tr,tr->Pt());
}
}
((TH1D*)(fOutput->FindObject("zvSPDcut")))->Fill(aod->GetPrimaryVertex()->GetZ());
if (!fCutOnNContributors || (fCutOnNContributors && (aod->GetPrimaryVertex()->GetNContributors()>fNContributors[0] && aod->GetPrimaryVertex()->GetNContributors()<fNContributors[1]))){
for (Int_t j = 0; j<ntracks; j++) {
- AliAODTrack *mu1 = aod->GetTrack(j);
+ AliAODTrack *mu1 = dynamic_cast<AliAODTrack*>(aod->GetTrack(j));
+ if(!mu1) AliFatal("Not a standard AOD");
if(!mu1->IsMuonTrack()) continue;
if (mu1->Chi2perNDF()<fChi2Track[0] || mu1->Chi2perNDF()>fChi2Track[1]) continue;
if (mu1->GetChi2MatchTrigger()<fChi2MatchTrig[0] || mu1->GetChi2MatchTrigger()>fChi2MatchTrig[1]) continue;
((TH1D*)(fOutput->FindObject("ymuonREC")))->Fill(rapiditymu1);
if(chargemu1<0){
for (Int_t jj = 0; jj<ntracks; jj++) {
- AliAODTrack *mu2 = aod->GetTrack(jj);
+ AliAODTrack *mu2 = dynamic_cast<AliAODTrack*>(aod->GetTrack(jj));
+ if(!mu2) AliFatal("Not a standard AOD");
if(!mu2->IsMuonTrack()) continue;
if (mu2->Chi2perNDF()<fChi2Track[0] || mu2->Chi2perNDF()>fChi2Track[1]) continue;
if (mu2->GetChi2MatchTrigger()<fChi2MatchTrig[0] || mu2->GetChi2MatchTrigger()>fChi2MatchTrig[1]) continue;
Int_t nMuons=0;
for (Int_t j = 0; j<aod->GetNumberOfTracks(); j++) {
- AliAODTrack *track = aod->GetTrack(j);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(aod->GetTrack(j));
+ if(!track) AliFatal("Not a standard AOD");
((TH1D*)(fOutput->FindObject("pt_alltracks")))->Fill(track->Pt());
if(track->IsMuonTrack()) {
nMuons++;
Double_t pos[3];
Double_t covVtx[6];
- // Access to the header
-
AliAODHeader *header = dynamic_cast<AliAODHeader*>(fNewAOD->GetHeader());
- if(!header) AliFatal("Not a standard AOD");
+ // Access to the header
+ AliAODHeader *header = dynamic_cast<AliAODHeader*>(fNewAOD->GetHeader());
+ if(!header) AliFatal("Not a standard AOD");
// fill the header
header->SetRunNumber (fOrgAOD->GetRunNumber() );
static int ncal=0;
static int numtracks=0;
for (Int_t iTrack=0; iTrack<nMuTracks; iTrack++) {
+ AliAODTrack * track = dynamic_cast<AliAODTrack*>((fOrgAOD->GetTrack(mutrNumb[iTrack])));
+ if(!track) AliFatal("Not a standard AOD");
primary->AddDaughter(new(tracks[jTracks++])
- AliAODTrack((*(fOrgAOD->GetTrack(mutrNumb[iTrack])))));
+ AliAODTrack((*track)));
ncal++;
}
numtracks+=jTracks;
// Loop on the muons tracks
- for (Int_t ii = 0; ii < nTracks; ii++)
- if (IsUsableMuon(fAOD->GetTrack(ii)))
+ for (Int_t ii = 0; ii < nTracks; ii++){
+ AliAODTrack * aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(ii));
+ if(!aodtrack) AliFatal("Not a standard AOD");
+ if (IsUsableMuon(aodtrack))
{
- Double_t matchTrigger = fAOD->GetTrack(ii)->GetMatchTrigger();
+ Double_t matchTrigger = aodtrack->GetMatchTrigger();
if (matchTrigger > 1.0)
matchTrigger = 1.0; // We don't care what type of trigger it is (low or high pT)
- Double_t thetaAbs = (180.0 / TMath::Pi()) * TMath::ATan(fAOD->GetTrack(ii)->GetRAtAbsorberEnd()/505.0);
- Double_t eta = fAOD->GetTrack(ii)->Eta();
- Double_t p = fAOD->GetTrack(ii)->P();
- Double_t pT = fAOD->GetTrack(ii)->Pt();
+ Double_t thetaAbs = (180.0 / TMath::Pi()) * TMath::ATan(aodtrack->GetRAtAbsorberEnd()/505.0);
+ Double_t eta = aodtrack->Eta();
+ Double_t p = aodtrack->P();
+ Double_t pT = aodtrack->Pt();
// For the p used in the pDCA, we want the mean between the p before the muon go through the absorber (p corrected) and after (p uncorrected)
// However p uncorrected is not saved in the AODs
// Instead we define p uncorrected as p corrected minus the mean p lost when a muon go through the absorber
// 2.0 < theta_abs < 3.0 ---> 2.98 GeV
// 3.0 < theta_abs < 10.0 ---> 2.4 GeV
// No correction applied otherwise
- Double_t pDCA = p*fAOD->GetTrack(ii)->DCA();
+ Double_t pDCA = p*aodtrack->DCA();
if (2.0 < thetaAbs && thetaAbs < 3.0)
- pDCA = (p-2.98/2.0) * fAOD->GetTrack(ii)->DCA();
+ pDCA = (p-2.98/2.0) * aodtrack->DCA();
if (3.0 < thetaAbs && thetaAbs < 10.0)
- pDCA = (p-2.4/2.0) * fAOD->GetTrack(ii)->DCA();
+ pDCA = (p-2.4/2.0) * aodtrack->DCA();
Double_t valuesMuon[9] = {static_cast<Double_t>(fTrackletMultiplicity), vertexPosition, pileUp, matchTrigger, thetaAbs, eta, pDCA, static_cast<Double_t>(p), static_cast<Double_t>(pT)};
((THnSparseD *)fSingleMuonList->At(triggerClass))->Fill(valuesMuon);
}
-
+ }
// Loop on Dimuons
for (Int_t ii = 0; ii < nDimuons; ii++)
if (fAOD->GetDimuon(ii)->Charge() == 0.0)
ptmu1 = mu1->Pt();
rapiditymu1 = Rapidity(emu1,pzmu1);
} else if(strcmp(fkAnalysisType,"AOD")==0){
- AliAODTrack *mu1 = aod->GetTrack(j);
+ AliAODTrack *mu1 = dynamic_cast<AliAODTrack*>(aod->GetTrack(j));
+ if(!mu1) AliFatal("Not a standard AOD");
if(!mu1->IsMuonTrack()) continue;
chargemu1 = mu1->Charge();
pxmu1 = mu1->Px();
pzmu2 = mu2->Pz();
emu2 = mu2->E();
} else if(strcmp(fkAnalysisType,"AOD")==0){
- AliAODTrack *mu2 = aod->GetTrack(jj);
+ AliAODTrack *mu2 = dynamic_cast<AliAODTrack*>(aod->GetTrack(jj));
+ if(!mu2) AliFatal("Not a standard AOD");
if(!mu2->IsMuonTrack()) continue;
chargemu2 = mu2->Charge();
pxmu2 = mu2->Px();
for(Int_t j=0; j<ntrk; j++) {
for(Int_t jj=j+1; jj<ntrk; jj++) {
- AliAODTrack *mu1 = fAOD->GetTrack(j);
+ AliAODTrack *mu1 = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(j));
+ if(!mu1) AliFatal("Not a standard AOD");
if(!mu1->IsMuonTrack() || !(mu1->Y()>-4 && mu1->Y()<-2.5)) continue;
- AliAODTrack *mu2 = fAOD->GetTrack(jj);
+ AliAODTrack *mu2 = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(jj));
+ if(!mu2) AliFatal("Not a standard AOD");
if(!mu2->IsMuonTrack() || !(mu2->Y()>-4 && mu2->Y()<-2.5)) continue;
Double_t trigCondition=0;
//Int_t count=0;
//track loop
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(!(track->TestFilterBit(32)))continue;
if (TMath::Abs(track->Eta()) > .8 || track->Pt() < .2) continue;
Int_t sNcls, sNclsF, sITScls;
Short_t sCharge;
for(int iTrack=0;iTrack<rTrack;iTrack++){
- AliAODTrack *aodTrack=rAOD->GetTrack(iTrack);
+ AliAODTrack *aodTrack=dynamic_cast<AliAODTrack*>(rAOD->GetTrack(iTrack));
+ if(!aodTrack) AliFatal("Not a standard AOD");
sPt=aodTrack->Pt();
sEta=aodTrack->Eta();
sPhi=aodTrack->Phi();
if (!bitOK) continue; //128bit or 272bit
Int_t gID = t->GetID();
- newAodTrack = gID >= 0 ?t : fAODEvent->GetTrack(trackMap->GetValue(-1-gID));
-
+ newAodTrack = gID >= 0 ?t : dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(trackMap->GetValue(-1-gID)));
+ if(!newAodTrack) AliFatal("Not a standard AOD?");
+
q = t->Charge();
charge = int(q);
phi = t->Phi();
Bool_t useEvent = false;
Int_t nTracks = fAODEvent->GetNumberOfTracks();
for(Int_t itrack=0; itrack<nTracks; itrack++) {
- AliAODTrack * track = fAODEvent->GetTrack(itrack);
+ AliAODTrack * track = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(itrack));
+ if(!track) AliFatal("Not a standard AOD");
if(TESTBIT(track->GetITSClusterMap(),2) || TESTBIT(track->GetITSClusterMap(),3) ){
useEvent=true;
break;
Double_t nAcceptedTracks=0;
Float_t nAcceptedTracksStrange=0;
for (Int_t iTracks = 0; iTracks < ntracks; iTracks++) {
- AliAODTrack *track = (AliAODTrack *)fAODEvent->GetTrack(iTracks);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!track) {
Error("ReadEventAOD", "Could not receive track %d", iTracks);
continue;
Double_t nAcceptedTracks=0;
for (Int_t iTracks = 0; iTracks < ntracks; iTracks++) {
- AliAODTrack *track = (AliAODTrack *)fAODEvent->GetTrack(iTracks);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
AliVParticle *vtrack = fAODEvent->GetTrack(iTracks);
Int_t nAcceptedTracksTPC=0;
Int_t nAcceptedTracksITSTPC=0;
for (Int_t iTracks = 0; iTracks < fAODEvent->GetNumberOfTracks(); iTracks++) {
- AliAODTrack *track = (AliAODTrack *)fAODEvent->GetTrack(iTracks);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!track) continue;
if(track->TestFilterBit(128) && TMath::Abs(track->Eta())<fEtaCut &&
track->Pt()>fPtMin && track->Pt()<fPtMax)
}
Int_t nAcceptedTracks=0;
for (Int_t iTracks = 0; iTracks < fAODEvent->GetNumberOfTracks(); iTracks++) {
- AliAODTrack *track = (AliAODTrack *)fAODEvent->GetTrack(iTracks);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!track) continue;
if(track->TestFilterBit(fFilterBit) && TMath::Abs(track->Eta())<fEtaCut
&& track->Pt()>fPtMin && track->Pt()<fPtMax) nAcceptedTracks++;
if(!fAOD)
AliFatal("Muon selection only implemented on AOD");//FIXME to be implemented also for ESDs as in AliAnalyseLeadingTrackUE::GetAcceptedPArticles
for (Int_t iTrack = 0; iTrack < fAOD->GetNumberOfTracks(); iTrack++) {
- AliAODTrack* track = fAOD->GetTrack(iTrack);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
if (!track->IsMuonTrack()) continue;
//Float_t dca = track->DCA();
//Float_t chi2 = track->Chi2perNDF();
if(!fAOD)
AliFatal("Muon selection only implemented on AOD");//FIXME to be implemented also for ESDs as in AliAnalyseLeadingTrackUE::GetAcceptedPArticles
for (Int_t iTrack = 0; iTrack < fAOD->GetNumberOfTracks(); iTrack++) {
- AliAODTrack* track = fAOD->GetTrack(iTrack);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
if (!track->IsMuonTrack()) continue;
//Float_t dca = track->DCA();
//Float_t chi2 = track->Chi2perNDF();
bitOK = t->TestFilterBit(_trackFilterBit);
if (!bitOK) continue;
Int_t gID = t->GetID();
- newAodTrack = gID >= 0 ?t : fAODEvent->GetTrack(trackMap->GetValue(-1-gID));
+ newAodTrack = gID >= 0 ?t : dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(trackMap->GetValue(-1-gID)));
+ if(!newAodTrack) {
+ AliFatal("Not a standard AOD?");
+ }
q = t->Charge();
charge = int(q);
for (Int_t iTrack = 0; iTrack < fCurrentAODEvent->GetNumberOfTracks(); iTrack++) {
- track = fCurrentAODEvent->GetTrack(iTrack);
+ track = dynamic_cast<AliAODTrack*>(fCurrentAODEvent->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
if (track->GetID()>-1) fGlobalTracksArray->AddAtAndExpand(track,track->GetID());
}
for (Int_t iTrack = 0; iTrack < fCurrentAODEvent->GetNumberOfTracks(); iTrack++) {
// Get the Current Track.
- fCurrentAODTrack = (AliAODTrack*)fCurrentAODEvent->GetTrack(iTrack);
+ fCurrentAODTrack = dynamic_cast<AliAODTrack*>(fCurrentAODEvent->GetTrack(iTrack));
+ if(!fCurrentAODTrack) AliFatal("Not a standard AOD");
if (!fCurrentAODTrack) {
cout<<"AliAnalysisTaskCompareAODTrackCuts::UserExec -> AOD Track not found."<<endl;
continue;
// Loop 1.
for (Int_t i = 0; i < nTrax; ++i) {
- AliAODTrack* aodtrack = fAOD->GetTrack(i);
+ AliAODTrack* aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(i));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if (!aodtrack) {
AliError(Form("Couldn't get AOD track %d\n", i));
continue;
// Loop 2.
for (Int_t i = 0; i < nTrax; ++i) {
- AliAODTrack* aodtrack = fAOD->GetTrack(i);
+ AliAODTrack* aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(i));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if (!aodtrack) {
AliError(Form("Couldn't get AOD track %d\n", i));
continue;
// count good muons
Int_t nGoodMuons = 0;
for (Int_t iMu = 0; iMu<fAOD->GetNumberOfTracks(); iMu++) {
- AliAODTrack* muonTrack = fAOD->GetTrack(iMu);
+ AliAODTrack* muonTrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iMu));
+ if(!muonTrack) AliFatal("Not a standard AOD");
if (muonTrack) {
if (!IsGoodMUONtrack(*muonTrack))
continue;
miniEvt->reserve(miniEvt->size()+nGoodMuons);
// fill them into the mini event
for (Int_t iMu = 0; iMu<fAOD->GetNumberOfTracks(); iMu++) {
- AliAODTrack* muonTrack = fAOD->GetTrack(iMu);
+ AliAODTrack* muonTrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iMu));
+ if(!muonTrack) AliFatal("Not a standard AOD");
if (muonTrack) {
if (!IsGoodMUONtrack(*muonTrack))
continue;
AliAODTrack *track = 0;
for (Int_t iTrack=0; iTrack<nTracks; iTrack++) {
- track = aodEvent->GetTrack(iTrack);
+ track = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
if (track->IsMuonTrack() && track->GetMatchTrigger()>=fTriggerMatchLevelMuon) {
if (track->Chi2perNDF() < fMaxChi2Muon) {
if (track->Eta() > fMinEtaMuon && track->Eta() < fMaxEtaMuon) {
AliAODTrack *track = 0;
for (Int_t iTrack=0; iTrack<nTracks; iTrack++) {
- track = aodEvent->GetTrack(iTrack);
+ track = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
if (track->TestFilterBit(fFilterBitCentralBarrel) && track->Eta()>fMinEtaCentralBarrel && track->Eta()<fMaxEtaCentralBarrel) {
tracks->Add(new AliAODTrack(*track));
}
AliAODTrack *track = 0;
for (Int_t iTrack=0; iTrack<nTracks; iTrack++) {
- track = aodEvent->GetTrack(iTrack);
+ track = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
if (track->IsMuonTrack()) fHistSingleMuonsTrigMatch[centBin]->Fill(track->GetMatchTrigger());
if (track->IsMuonTrack() && track->GetMatchTrigger()>=fTriggerMatchLevelMuon) {
fHistSingleMuonsChi2[centBin]->Fill(track->Chi2perNDF());
//track loop
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,kTRUE)) continue;
if(track->Charge()==0) continue;
if(track->Pt()<fPtCut) continue;
for (Int_t iTrack = 0; iTrack < fAOD->GetNumberOfTracks(); iTrack++) {
- track = fAOD->GetTrack(iTrack);
+ track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
// I.e., if it does NOT pass the filtermask.
if (!(track->TestFilterMask(1<<7))) {
// Track loop to fill a pT spectrum
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 (!track) {
//printf("ERROR: Could not receive track %d\n", iTracks);
continue;
for (Int_t iTrack=0; iTrack<nTracks; ++iTrack)
{
- AliAODTrack* track = inputEvent->GetTrack(iTrack);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(inputEvent->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
Int_t trackclass=ClassifyTrack(track);
if (trackclass==1)
if(!aodTrack->TestFilterBit(fAODtrackCutBit)) continue;
Int_t gID = aodTrack->GetID();
- newAodTrack = gID >= 0 ? aodTrack : gAOD->GetTrack(trackMap->GetValue(-1-gID));
+ newAodTrack = gID >= 0 ? aodTrack : dynamic_cast<AliAODTrack*>(gAOD->GetTrack(trackMap->GetValue(-1-gID)));
+ if(!newAodTrack) AliFatal("Not a standard AOD");
//Printf("Label: %d - Pt: %lf (old) - %d - Pt: %lf(new)",gID,aodTrack->Pt(), newAodTrack->GetID(), newAodTrack->Pt());
//===========================================//
TArrayI labelMCArray(nMCParticles);
for(Int_t jTracks = 0; jTracks < nGoodAODTracks; jTracks++) {
- AliAODTrack* track = fAOD->GetTrack(jTracks);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(jTracks));
+ if(!track) AliFatal("Not a standard AOD");
if(!track) continue;
if (!track->TestFilterBit(fAODTrackCutBit))
Int_t labelCounter = 0;
for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) {
- AliAODTrack *trackAOD =
static_cast<AliAODTrack*>(fAOD->GetTrack(iTracks));
+ AliAODTrack *trackAOD =
dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTracks));
if(!trackAOD) continue;
//track cuts
Printf("There are %d tracks in this event", gAOD->GetNumberOfTracks());
for (Int_t iTracks = 0; iTracks < gAOD->GetNumberOfTracks(); iTracks++) {
- AliAODTrack* track = gAOD->GetTrack(iTracks);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(gAOD->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!track) {
Printf("ERROR: Could not receive track %d", iTracks);
continue;
Int_t gID = aodTrack1->GetID();
//if( aodTrack->GetID() != (-aodTrack1->GetID() -1) ) continue;
- newAodTrack = gID >= 0 ? aodTrack1 : fAOD->GetTrack(trackMap->GetValue(-1-gID)); //Take those global track who corresponds to TPC only track
+ newAodTrack = gID >= 0 ? aodTrack1 : dynamic_cast<AliAODTrack*>(fAOD->GetTrack(trackMap->GetValue(-1-gID))); //Take those global track who corresponds to TPC only track
+ if(!newAodTrack) AliFatal("Not a standard AOD");
Float_t dxy = 0., dz = 0.;
//if( aodTrack->GetID() != (-aodTrack1->GetID() -1) ) continue;
- newAodTrack = gID >= 0 ? aodTrack1 : fAOD->GetTrack(trackMap->GetValue(-1-gID)); //Take those global track who corresponds to TPC only track
+ newAodTrack = gID >= 0 ? aodTrack1 : dynamic_cast<AliAODTrack*>(fAOD->GetTrack(trackMap->GetValue(-1-gID))); //Take those global track who corresponds to TPC only track
+ if(!newAodTrack) AliFatal("Not a standard AOD");
Float_t dxy = 0., dz = 0.;
if(fAOD)
- aodTrack = fAOD->GetTrack(iRec);
+ aodTrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iRec));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if(aodTrack){
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 (!track) {
printf("ERROR: Could not receive track %d\n", iTracks);
continue;
Int_t gID = aodTrack1->GetID();
//if( aodTrack->GetID() != (-aodTrack1->GetID() -1) ) continue;
- newAodTrack = gID >= 0 ? aodTrack1 : fAOD->GetTrack(trackMap->GetValue(-1-gID)); //Take those global track who corresponds to TPC only track
+ newAodTrack = gID >= 0 ? aodTrack1 : dynamic_cast<AliAODTrack*>(fAOD->GetTrack(trackMap->GetValue(-1-gID))); //Take those global track who corresponds to TPC only track
+ if(!newAodTrack) AliFatal("Not a standard AOD");
Float_t dxy = 0., dz = 0.;
//if( aodTrack->GetID() != (-aodTrack1->GetID() -1) ) continue;
- newAodTrack = gID >= 0 ? aodTrack1 : fAOD->GetTrack(trackMap->GetValue(-1-gID)); //Take those global track who corresponds to TPC only track
+ newAodTrack = gID >= 0 ? aodTrack1 : dynamic_cast<AliAODTrack*>(fAOD->GetTrack(trackMap->GetValue(-1-gID))); //Take those global track who corresponds to TPC only track
+ if(!newAodTrack) AliFatal("Not a standard AOD");
//cout << dxy << endl;
if ((fInputType == kAOD) || (fInputType == kAODKine)) {
// Read in the normal AliAODTracks
- const AliAODTrack *aodtrack=fAODEvent->GetTrack(i); // getting the AODtrack directly
+ const AliAODTrack *aodtrack=dynamic_cast<const AliAODTrack*>(fAODEvent->GetTrack(i));
+ assert(aodtrack&&"Not a standard AOD"); // getting the AODtrack directly
// if (!aodtrack->TestFilterBit(fFilterBit))
// continue;
// 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<aodEvent->GetNumberOfTracks();i++) {
- const AliAODTrack *aodtrack=aodEvent->GetTrack(i);
+ const AliAODTrack *aodtrack=dynamic_cast<const AliAODTrack*>(aodEvent->GetTrack(i));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if (!aodtrack->TestFilterBit(128)) {
if(aodtrack->GetID() < 0) continue;
labels[aodtrack->GetID()] = i;
//get track
//AliESDtrack* track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast<AliESDEvent*>(esdEvent),iTracks);
- AliAODTrack *track = aodEvent->GetTrack(iTracks);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!track)continue;
fHistQA[10]->Fill(2);
AliAODTrack* aodtrackpid;
//for FB 128 - tpc only tracks
- if(filterBit==(1 << (7)))
- aodtrackpid = aodEvent->GetTrack(labels[-1-aodEvent->GetTrack(iTracks)->GetID()]);
+ if(filterBit==(1 << (7))) {
+ aodtrackpid = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(labels[-1-aodEvent->GetTrack(iTracks)->GetID()]));
+ if(!aodtrackpid) AliFatal("Not a standard AOD");
+ }
else
aodtrackpid = track;
// Track loop
for (Int_t i = 0; i < fAOD->GetNumberOfTracks(); i++) {
- AliAODTrack* aodtrack = fAOD->GetTrack(randomIndex[i]);
+ AliAODTrack* aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(randomIndex[i]));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if (!aodtrack) continue;
if(myTracks >= fMultLimit) {cout<<"More tracks than Track Limit"<<endl; return;}
if(fFilterBit != 7){
Bool_t goodTrackOtherFB = kFALSE;
for (Int_t j = 0; j < fAOD->GetNumberOfTracks(); j++) {
- AliAODTrack* aodtrack2 = fAOD->GetTrack(randomIndex[j]);
+ AliAODTrack* aodtrack2 = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(randomIndex[j]));
+ if(!aodtrack2) AliFatal("Not a standard AOD");
if(!aodtrack2) continue;
if(!aodtrack2->TestFilterBit(BIT(fFilterBit))) continue;
}else {// FilterBit 7 PID workaround
*/
for(Int_t j = 0; j < fAOD->GetNumberOfTracks(); j++) {
- AliAODTrack* aodTrack2 = fAOD->GetTrack(j);
+ AliAODTrack* aodTrack2 = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(j));
+ if(!aodTrack2) AliFatal("Not a standard AOD");
if (!aodTrack2) continue;
if(aodtrack->GetID() != (-aodTrack2->GetID() - 1)) continue;// (-aodTrack2->GetID() - 1)
// Track loop
for (Int_t i = 0; i < fAOD->GetNumberOfTracks(); i++) {
- AliAODTrack* aodtrack = fAOD->GetTrack(randomIndex[i]);
+ AliAODTrack* aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(randomIndex[i]));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if (!aodtrack) continue;
if(myTracks >= fMultLimit) {cout<<"More tracks than Track Limit"<<endl; return;}
if(fFilterBit != 7){
Bool_t goodTrackOtherFB = kFALSE;
for (Int_t j = 0; j < fAOD->GetNumberOfTracks(); j++) {
- AliAODTrack* aodtrack2 = fAOD->GetTrack(randomIndex[j]);
+ AliAODTrack* aodtrack2 = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(randomIndex[j]));
+ if(!aodtrack2) AliFatal("Not a standard AOD");
if(!aodtrack2) continue;
if(!aodtrack2->TestFilterBit(BIT(fFilterBit))) continue;
}else {// FilterBit 7 PID workaround
for(Int_t j = 0; j < fAOD->GetNumberOfTracks(); j++) {
- AliAODTrack* aodTrack2 = fAOD->GetTrack(j);
+ AliAODTrack* aodTrack2 = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(j));
+ if(!aodTrack2) AliFatal("Not a standard AOD");
if (!aodTrack2) continue;
if(aodtrack->GetID() != (-aodTrack2->GetID() - 1)) continue;// (-aodTrack2->GetID() - 1)
((TH3F*)fOutputList->FindObject("fVertexDist"))->Fill(vertex[0], vertex[1], vertex[2]);
for (Int_t i = 0; i < fAOD->GetNumberOfTracks(); i++) {
- AliAODTrack* aodtrack = fAOD->GetTrack(i);
+ AliAODTrack* aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(i));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if (!aodtrack) continue;
AODTracks++;
if(!aodtrack->TestFilterBit(BIT(fFilterBit))) continue;// AOD filterBit cut
// Track loop
for (Int_t i = 0; i < fAOD->GetNumberOfTracks(); i++) {
- AliAODTrack* aodtrack = fAOD->GetTrack(randomIndex[i]);
+ AliAODTrack* aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(randomIndex[i]));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if (!aodtrack) continue;
if(myTracks >= fMultLimit) {cout<<"More tracks than Track Limit"<<endl; return;}
if(fMCcase && fAOD->GetRunNumber()<=126437) goodTrackOtherFB=kTRUE;// FB7 to FB5 mapping in 10f6a MC does not work
for (Int_t j = 0; j < fAOD->GetNumberOfTracks(); j++) {
- AliAODTrack* aodtrack2 = fAOD->GetTrack(randomIndex[j]);
+ AliAODTrack* aodtrack2 = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(randomIndex[j]));
+ if(!aodtrack2) AliFatal("Not a standard AOD");
if(!aodtrack2) continue;
if(!aodtrack2->TestFilterBit(BIT(fFilterBit))) continue;
}else {// FilterBit 7 PID workaround
for(Int_t j = 0; j < fAOD->GetNumberOfTracks(); j++) {
- AliAODTrack* aodTrack2 = fAOD->GetTrack(j);
+ AliAODTrack* aodTrack2 = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(j));
+ if(!aodTrack2) AliFatal("Not a standard AOD");
if (!aodTrack2) continue;
if(aodtrack->GetID() != (-aodTrack2->GetID() - 1)) continue;// (-aodTrack2->GetID() - 1)
// ..and set it
AliAODTrack *track=NULL;
for (Int_t iTrack=0;iTrack<fAOD->GetNumberOfTracks();iTrack++){
- track = fAOD->GetTrack(iTrack);
+ track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
if (!track) continue;
// Store the reference of the global tracks
// Loop over primary tracks
for (Int_t iTrack=0;iTrack<fAOD->GetNumberOfTracks();iTrack++){
- track = fAOD->GetTrack(iTrack);
+ track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTrack));
+ if(!track) AliFatal("Not a standard AOD");
if (!track) continue;
if(!track->TestFilterBit(128))
// Loop over AOD tracks
for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
- AliAODTrack *aodTrack = fAOD->GetTrack(nTrack);
+ AliAODTrack *aodTrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(nTrack));
+ if(!aodTrack) AliFatal("Not a standard AOD");
Short_t trackId = aodTrack->GetID();
// Get the corresponding ESD track
TExMap *trackMap = new TExMap();
for(int itrk=0; itrk<d_ntrk; itrk++)
{
- AliAODTrack *track = fAOD->GetTrack(itrk);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(itrk));
+ if(!track) AliFatal("Not a standard AOD");
if(!track)
{
if(debug>0) cout<<"ERROR: Could not retrieve AODtrack "<<itrk<<endl;
// --- main track loop
for(int itrk = 0; itrk<d_ntrk; itrk++)
{
- AliAODTrack *track = fAOD->GetTrack(itrk);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(itrk));
+ if(!track) AliFatal("Not a standard AOD");
if(!track)
{
if(debug>0) cout<<"ERROR: Could not retrieve AODtrack "<<itrk<<endl;
int gid = track->GetID();
AliAODTrack *PIDtrack;
if(gid>=0) PIDtrack = track;
- else PIDtrack = fAOD->GetTrack(trackMap->GetValue(-1-gid));
+ else {
+ PIDtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(trackMap->GetValue(-1-gid)));
+ if(!PIDtrack) AliFatal("Not a standard AOD");
+ }
// if(debug>15)
for(int itrk = 0; itrk<d_ntrk; itrk++)
{
- AliAODTrack *track = fAOD->GetTrack(itrk);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(itrk));
+ if(!track) AliFatal("Not a standard AOD");
if(!track)
{
if(debug>0) cout<<"ERROR: Could not retrieve AODtrack "<<itrk<<endl;
nanoEv->GetCaloCluster(posCaloCls)->AddTrackMatched((AliAODTrack*)nanoEv->GetTrack(posit));
}
// set references for vtx
- nanoEv->GetTrack(posit)->SetProdVertex(nanoEv->GetVertex(posVtx));
+ AliAODTrack * trk = dynamic_cast<AliAODTrack*>(nanoEv->GetTrack(posit));
+ if(!trk) AliFatal("Not a standard AOD");
+ trk->SetProdVertex(nanoEv->GetVertex(posVtx));
}
for(int kj=0; kj<(fDielectron->GetTrackArray(1))->GetEntries(); kj++){
for(int u=0; u<clCls->GetNTracksMatched(); u++) clCls->RemoveTrackMatched(clCls->GetTrackMatched(u));
nanoEv->GetCaloCluster(negCaloCls)->AddTrackMatched((AliAODTrack*)nanoEv->GetTrack(negat));
}
- nanoEv->GetTrack(negat)->SetProdVertex(nanoEv->GetVertex(negVtx));
+ AliAODTrack * trk = dynamic_cast<AliAODTrack*>(nanoEv->GetTrack(negat));
+ if(!trk) AliFatal("Not a standard AOD");
+ trk->SetProdVertex(nanoEv->GetVertex(negVtx));
}
delete tmp; delete tmpSpd;
nanoEv->GetTracks()->Expand(nTracks);
Int_t nCopyTrack = 0;
for (Int_t nTrack = 0; nTrack < fAODEvent->GetNumberOfTracks(); ++nTrack)
{
- AliAODTrack *track = fAODEvent->GetTrack(nTrack);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(nTrack));
+ if(!track) AliFatal("Not a standard AOD");
// Select only hybrid tracks?
if(fFillHybridTracks && !track->IsHybridGlobalConstrainedGlobal()) continue;
// _______________Track loop for reconstructed event_____________
for(Int_t itrk = 0; itrk < fAodEv->GetNumberOfTracks(); itrk++) {
- AliAODTrack* aodTrack = fAodEv->GetTrack(itrk); // pointer to reconstructed to track
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(fAodEv->GetTrack(itrk));
+ if(!aodTrack) AliFatal("Not a standard AOD"); // pointer to reconstructed to track
if(!aodTrack) {
AliError(Form("ERROR: Could not retrieve any (AOD) track %d",itrk));
continue;
// _______________Track loop for reconstructed event_____________
for(Int_t itrk = 0; itrk < fAodEv->GetNumberOfTracks(); itrk++) {
- AliAODTrack* aodTrack = fAodEv->GetTrack(itrk); // pointer to reconstructed to track
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(fAodEv->GetTrack(itrk));
+ if(!aodTrack) AliFatal("Not a standard AOD"); // pointer to reconstructed to track
if(!aodTrack) {
AliError(Form("ERROR: Could not retrieve any (AOD) track %d",itrk));
continue;
if (aod) ntracks = aod->GetNumberOfTracks();
for(Int_t itrack=0; itrack<ntracks; itrack++) { // loop on tacks
// ... get the track
- AliAODTrack * track = aod->GetTrack(itrack);
+ AliAODTrack * track = dynamic_cast<AliAODTrack*>(aod->GetTrack(itrack));
+ if(!track) AliFatal("Not a standard AOD");
if(TESTBIT(track->GetITSClusterMap(),2) || TESTBIT(track->GetITSClusterMap(),3) ){
skipEvent=kTRUE;
fNentries->Fill(16);
}
for(Int_t itrack=0; itrack<aod->GetNumberOfTracks(); itrack++) { // loop on tacks
- AliAODTrack * track = aod->GetTrack(itrack);
+ AliAODTrack * track = dynamic_cast<AliAODTrack*>(aod->GetTrack(itrack));
+ if(!track) AliFatal("Not a standard AOD");
//rejection of tracks
if(track->GetID() < 0) continue; //discard negative ID tracks
if(track->Pt() < fPtThreshLow.at(0) || track->Pt() > fPtThreshUp.at(0)) continue; //discard tracks outside pt range for hadrons/K
// Looping over aod tracks
for(Int_t j=0;j<aod->GetNumberOfTracks();j++){
- AliAODTrack *aodtrack=aod->GetTrack(j);
+ AliAODTrack *aodtrack=dynamic_cast<AliAODTrack*>(aod->GetTrack(j));
+ if(!aodtrack) AliFatal("Not a standard AOD");
// CHECK FILTER MAPS
if(!FillTrackHistosAndSelectTrack(aodtrack,&vESD,magfield))continue;
// if(j%100==0)
// use reconstruction
if(fUseReco){
for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
- AliAODTrack* track = inputEvent->GetTrack(iTrack);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(inputEvent->GetTrack(iTrack));
if (!track) continue;
if(!fhadcuts->IsHadronSelected(track,&vESD,Bz)) continue; // apply ESD level selections
if(!fhadcuts->Charge(fDCharge,track)) continue; // apply selection on charge, if required
if(fIsAOD){
//AOD test -- Francesco suggestion
//aod test -- Francesco suggestion
- AliAODTrack *aod_track=fAOD->GetTrack(iTracks);
+ AliAODTrack *aod_track=dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTracks));
+ if(!aod_track) AliFatal("Not a standard AOD");
Int_t type=aod_track->GetType();
if(type==AliAODTrack::kPrimary) fPtPrim->Fill(aod_track->Pt());
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)
continue;
// Track loop
for (Int_t iTracks = 0; iTracks < fAOD->GetNumberOfTracks(); iTracks++)
{
- track = fAOD->GetTrack(iTracks);
+ track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!track)
{
printf("ERROR: Could not receive track %d\n", iTracks);
Bool_t flagPhotonicElec = kFALSE;
for(Int_t jTracks = 0; jTracks<fAOD->GetNumberOfTracks(); jTracks++){
- AliAODTrack *trackAsso = fAOD->GetTrack(jTracks);
+ AliAODTrack *trackAsso = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(jTracks));
+ if(!trackAsso) AliFatal("Not a standard AOD");
if (!trackAsso) {
printf("ERROR: Could not receive track %d\n", jTracks);
continue;
Float_t multTPC(0.); // tpc mult estimate
Float_t multGlob(0.); // global multiplicity
for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill tpc mult
- AliAODTrack* trackAOD = event->GetTrack(iTracks);
+ AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(event->GetTrack(iTracks));
+ if(!trackAOD) AliFatal("Not a standard AOD");
if (!trackAOD) continue;
if (!(trackAOD->TestFilterBit(1))) continue;
if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.2)) continue;
multTPC++;
}
for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill global mult
- AliAODTrack* trackAOD = event->GetTrack(iTracks);
+ AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(event->GetTrack(iTracks));
+ if(!trackAOD) AliFatal("Not a standard AOD");
if (!trackAOD) continue;
if (!(trackAOD->TestFilterBit(16))) continue;
if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.1)) continue;
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)
continue;
// Track loop
for (Int_t iTracks = 0; iTracks < fAOD->GetNumberOfTracks(); iTracks++)
{
- track = fAOD->GetTrack(iTracks);
+ track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTracks));
+ if(!track) AliFatal("Not a standard AOD");
if (!track)
{
printf("ERROR: Could not receive track %d\n", iTracks);
Bool_t flagPhotonicElec = kFALSE;
for(Int_t jTracks = 0; jTracks<fAOD->GetNumberOfTracks(); jTracks++){
- AliAODTrack *trackAsso = fAOD->GetTrack(jTracks);
+ AliAODTrack *trackAsso = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(jTracks));
+ if(!trackAsso) AliFatal("Not a standard AOD");
if (!trackAsso) {
printf("ERROR: Could not receive track %d\n", jTracks);
continue;
Float_t multTPC(0.); // tpc mult estimate
Float_t multGlob(0.); // global multiplicity
for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill tpc mult
- AliAODTrack* trackAOD = event->GetTrack(iTracks);
+ AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(event->GetTrack(iTracks));
+ if(!trackAOD) AliFatal("Not a standard AOD");
if (!trackAOD) continue;
if (!(trackAOD->TestFilterBit(1))) continue;
if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.2)) continue;
multTPC++;
}
for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) { // fill global mult
- AliAODTrack* trackAOD = event->GetTrack(iTracks);
+ AliAODTrack* trackAOD = dynamic_cast<AliAODTrack*>(event->GetTrack(iTracks));
+ if(!trackAOD) AliFatal("Not a standard AOD");
if (!trackAOD) continue;
if (!(trackAOD->TestFilterBit(16))) continue;
if ((trackAOD->Pt() < .2) || (trackAOD->Pt() > 5.0) || (TMath::Abs(trackAOD->Eta()) > .8) || (trackAOD->GetTPCNcls() < 70) || (trackAOD->GetDetPid()->GetTPCsignal() < 10.0) || (trackAOD->Chi2perNDF() < 0.1)) continue;
kinkmother=kFALSE;
kinkdaughter=kFALSE;
kinkstatus = 0.;
- track = fAOD->GetTrack(itrack); mctrack = NULL;
+ track = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(itrack));
+ if(!track) AliFatal("Not a standard AOD"); mctrack = NULL;
if(!track) continue;
for(int ivx = 0; ivx < numberofmotherkink; ivx++){
// make trkIDtoEntry register (temporary)
Int_t trkIDtoEntry[100000];
for(Int_t it=0;it<aod->GetNumberOfTracks();it++) {
- AliAODTrack *track = aod->GetTrack(it);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(aod->GetTrack(it));
+ if(!track) AliFatal("Not a standard AOD");
trkIDtoEntry[track->GetID()]=it;
}
fptMax[1]=0.;
fptMax[2]=0.;
for(Int_t it=0;it<aod->GetNumberOfTracks();it++) {
- AliAODTrack *track = aod->GetTrack(it);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(aod->GetTrack(it));
+ if(!track) AliFatal("Not a standard AOD");
fptAll+=track->Pt();
fptAllSq+=track->Pt()*track->Pt();
if(track->Pt()>fptMax[0]){
}
nprim=0;
for(Int_t it=0;it<ntracks;it++) {
- AliAODTrack *track = aod->GetTrack(it);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(aod->GetTrack(it));
+ if(!track) AliFatal("Not a standard AOD");
if(track->IsPrimaryCandidate()){
if(track->Pt()>ptmin){
if (aod) ntracks = aod->GetNumberOfTracks();
for(Int_t itrack=0; itrack<ntracks; itrack++) { // loop on tacks
// ... get the track
- AliAODTrack * track = aod->GetTrack(itrack);
+ AliAODTrack * track = dynamic_cast<AliAODTrack*>(aod->GetTrack(itrack));
+ if(!track) AliFatal("Not a standard AOD");
if(TESTBIT(track->GetITSClusterMap(),2) || TESTBIT(track->GetITSClusterMap(),3) ){
skipEvent=kTRUE;
fNentries->Fill(16);
for (Int_t i=0; i<aodEvent->GetNumberOfTracks(); i++){
- AliAODTrack* aodTrack = aodEvent->GetTrack(i);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(i));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if(dstarD0pi->Charge() == aodTrack->Charge()) continue;
if((!(aodTrack->GetStatus()&AliESDtrack::kITSrefit)|| (!(aodTrack->GetStatus()&AliESDtrack::kTPCrefit)))) continue;
}
for (Int_t k=0;k<nAODtracks;k++){
- AliAODTrack* track=aod->GetTrack(k);
+ AliAODTrack* track=dynamic_cast<AliAODTrack*>(aod->GetTrack(k));
+ if(!track) AliFatal("Not a standard AOD");
if(track->GetID()<0) continue;
Int_t nclsTot=0,nclsSPD=0;
for(Int_t l=0;l<6;l++) {
if(fOnOff[0] || fOnOff[1]){
//loop on tracks in the event
for (Int_t k=0;k<ntracks;k++){
- AliAODTrack* track=aod->GetTrack(k);
+ AliAODTrack* track=dynamic_cast<AliAODTrack*>(aod->GetTrack(k));
+ if(!track) AliFatal("Not a standard AOD");
// Track selection cuts
if(track->GetID()<0) continue;
if (!mcs) return;
if (fImproveTracks) {
for(Int_t itrack=0;itrack<ev->GetNumberOfTracks();++itrack) {
- SmearTrack(ev->GetTrack(itrack),mcs);
+ AliAODTrack * trk = dynamic_cast<AliAODTrack*>(ev->GetTrack(itrack));
+ if(!trk) AliFatal("Not a standard AOD");
+ SmearTrack(trk,mcs);
}
}
// make trkIDtoEntry register (temporary)
Int_t trkIDtoEntry[100000];
for(Int_t it=0;it<aodIn->GetNumberOfTracks();it++) {
- AliAODTrack *track = aodIn->GetTrack(it);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(aodIn->GetTrack(it));
+ if(!track) AliFatal("Not a standard AOD");
trkIDtoEntry[track->GetID()]=it;
}
AliAODTrack *trk0 = (AliAODTrack*)dIn->GetDaughter(0);
AliAODTrack *trk1 = (AliAODTrack*)dIn->GetDaughter(1);
if(!trk0 || !trk1) {
- trk0=aodIn->GetTrack(trkIDtoEntry[dIn->GetProngID(0)]);
- trk1=aodIn->GetTrack(trkIDtoEntry[dIn->GetProngID(1)]);
+ trk0=dynamic_cast<AliAODTrack*>(aodIn->GetTrack(trkIDtoEntry[dIn->GetProngID(0)]));
+ trk1=dynamic_cast<AliAODTrack*>(aodIn->GetTrack(trkIDtoEntry[dIn->GetProngID(1)]));
+ if(!trk0 || !trk1) AliFatal("Not a standard AOD");
}
printf("pt of positive track: %f\n",trk0->Pt());
printf("pt of negative track: %f\n",trk1->Pt());
id = (Int_t)track->GetID();
//printf("---> %d\n",id);
if(id<0) continue; // this track is a AliAODRecoDecay
- aodTrack = (AliAODTrack*)event->GetTrack(fAODMap[id]);
+ aodTrack = dynamic_cast<AliAODTrack*>(event->GetTrack(fAODMap[id]));
+ if(!aodTrack) AliFatal("Not a standard AOD");
v->AddDaughter(aodTrack);
}
memset(fAODMap,0,sizeof(Int_t)*fAODMapSize);
for(Int_t i=0; i<aod->GetNumberOfTracks(); i++) {
- track = aod->GetTrack(i);
+ track = dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
// skip pure ITS SA tracks
if(track->GetStatus()&AliESDtrack::kITSpureSA) continue;
if(cascade) continue;
for(id=0; id<nDgs; id++) {
if (ids[id]>-1 && ids[id] < fAODMapSize) {
- track = aod->GetTrack(fAODMap[ids[id]]);
+ track = dynamic_cast<AliAODTrack*>(aod->GetTrack(fAODMap[ids[id]]));
+ if(!track) AliFatal("Not a standard AOD");
vertex->AddDaughter(track);
}
}
if(fInputAOD){
Int_t idSoftPi=(Int_t)trackPi->GetID();
if (idSoftPi > -1 && idSoftPi < fAODMapSize) {
- AliAODTrack* trackPiAOD=(AliAODTrack*)event->GetTrack(fAODMap[idSoftPi]);
+ AliAODTrack* trackPiAOD=dynamic_cast<AliAODTrack*>(event->GetTrack(fAODMap[idSoftPi]));
+ if(!trackPiAOD) AliFatal("Not a standard AOD");
tmpCascade->GetSecondaryVtx()->AddDaughter(trackPiAOD);
}
}else{
if(fInputAOD){
Int_t idBachelor=(Int_t)trackBachelor->GetID();
if (idBachelor > -1 && idBachelor < fAODMapSize) {
- AliAODTrack* trackBachelorAOD=(AliAODTrack*)event->GetTrack(fAODMap[idBachelor]);
+ AliAODTrack* trackBachelorAOD=dynamic_cast<AliAODTrack*>(event->GetTrack(fAODMap[idBachelor]));
+ if(!trackBachelorAOD) AliFatal("Not a standard AOD");
tmpCascade->GetSecondaryVtx()->AddDaughter(trackBachelorAOD);
}
}else{
if(!aod) return iCount;
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;
// 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;
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;
// 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){
for(Int_t it = 0; it < aodevt->GetNumberOfTracks(); it++){
- AliAODTrack *tr = aodevt->GetTrack(it);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>(aodevt->GetTrack(it));
+ if(!tr) AliFatal("Not a standard AOD");
if((fFilterMask > 0) && !(tr->TestFilterBit(fFilterMask))) continue;
//if((fFilterMask > 0) && !(tr->IsHybridGlobalConstrainedGlobal())) continue;
if(type==kTrackAOD){
// all rec. tracks, esd filter mask, within acceptance
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(!tr)continue;
if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask)))continue;//selecting filtermask
if(tr->Eta() < fTrackEtaMin || tr->Eta() > fTrackEtaMax) continue;
return iCount;
}
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())>fTrackRecEtaWindow)continue;
if(tr->Pt()<fMinTrackPt)continue;
return iCount;
}
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())>fTrackRecEtaWindow)continue;
if(tr->Pt()<fMinTrackPt)continue;
Float_t ptsum = 0.;
for (Int_t i = 0; i < nT; i++) {
- AliAODTrack* track = aodE->GetTrack(i);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(aodE->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
//
// Track quality cuts
if (!track->TestFilterBit(1<<4)) continue;
// 2nd correlation with principal axis
//
for (Int_t i = 0; i < nT; i++) {
- AliAODTrack* track = aodE->GetTrack(i);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(aodE->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
//
// Track quality cuts
if (!track->TestFilterBit(1<<4)) continue;
Int_t myTotalSoftMultRef = 0;
for(Int_t aodT = 0; aodT < tracksAOD; aodT++ )
{
- AliAODTrack *aodtrack = fAOD->GetTrack(aodT);
+ AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(aodT));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if(!aodtrack) continue;
aodtracketa = TMath::Abs(aodtrack->Eta());
if(aodtracketa>0.9) continue;
AliDebug(4,Form("Checking composition in Reco jets without track refs"));
for(Int_t aodT = 0; aodT < tracksAOD; aodT++ )
{
- AliAODTrack *aodtrack = fAOD->GetTrack(aodT);
+ AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(aodT));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if(!aodtrack) continue;
if(!IsTrackInsideThisJet(aodtrack, rjet, jfr)) continue;
if(!aodtrack->TestFilterBit(fFilterBit)) continue; //track filter selection
AliDebug(4,Form("Checking SCM of perpendicular cone in Reco jets"));
for(Int_t aodTperp = 0; aodTperp < tracksAOD; aodTperp++ )
{ //fPerpCone
- AliAODTrack *aodtrackperprec = fAOD->GetTrack(aodTperp);
+ AliAODTrack *aodtrackperprec = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(aodTperp));
+ if(!aodtrackperprec) AliFatal("Not a standard AOD");
if(!aodtrackperprec) continue;
if(!IsTrackInsideThisJet(aodtrackperprec, fPerpCone, jfr)) continue;
if(!aodtrackperprec->TestFilterBit(fFilterBit)) continue; //track filter selection
AliDebug(4,Form("Empty Track Refs (reco)!"));
for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
{
- AliAODTrack *aodtrack = aode->GetTrack(iTracks);
+ AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(aode->GetTrack(iTracks));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if(!aodtrack) continue;
tracketa = aodtrack->Eta();
trackphi = aodtrack->Phi();
for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
{
- AliAODTrack *aodtrack = aode->GetTrack(iTracks);
+ AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(aode->GetTrack(iTracks));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if(!aodtrack) continue;
tracketa = aodtrack->Eta();
trackphi = aodtrack->Phi();
AliDebug(4,Form("Empty Track Refs (reco)!"));
for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
{
- AliAODTrack *aodtrack = aode->GetTrack(iTracks);
+ AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(aode->GetTrack(iTracks));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if(!aodtrack) continue;
tracketa = aodtrack->Eta();
trackphi = aodtrack->Phi();
for (Int_t iTracks = 0; iTracks < ntracks; iTracks++)
{
- AliAODTrack *aodtrack = aode->GetTrack(iTracks);
+ AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(aode->GetTrack(iTracks));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if(!aodtrack) continue;
tracketa = aodtrack->Eta();
trackphi = aodtrack->Phi();
for(Int_t aodT = 0; aodT < ntracks; aodT++ )
{
- AliAODTrack *aodtrackC = aode->GetTrack(aodT);
+ AliAODTrack *aodtrackC = dynamic_cast<AliAODTrack*>(aode->GetTrack(aodT));
+ if(!aodtrackC) AliFatal("Not a standard AOD");
if(!aodtrackC) continue;
aodtracketaC = TMath::Abs(aodtrackC->Eta());
if(aodtracketaC>0.9) continue;
//Get track for analysis
AliVTrack *track = 0x0;
- AliAODTrack *aodtrack = fAOD->GetTrack(iTrack);
+ AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(iTrack));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if(!aodtrack)
continue;
if((!aodtrack->TestFilterBit(fFilterMask)) ||
AliExternalTrackParam exParam;
for (Int_t iTrack = 0; iTrack < fEvent->GetNumberOfTracks(); iTrack++) {
- AliAODTrack *aodtrack = aod->GetTrack(iTrack);
+ AliAODTrack *aodtrack = dynamic_cast<AliAODTrack*>(aod->GetTrack(iTrack));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if( !aodtrack->TestFilterMask(fFilterMask) ) {
fh1NTracksReject->Fill("noHybridTrack",1);
continue;
AliAODEvent *aod = dynamic_cast<AliAODEvent*>(InputEvent());
if (aod) {
for (Int_t iMu = 0; iMu<aod->GetNumberOfTracks(); ++iMu) {
- AliAODTrack* muonTrack = aod->GetTrack(iMu);
+ AliAODTrack* muonTrack = dynamic_cast<AliAODTrack*>(aod->GetTrack(iMu));
+ if(!muonTrack) AliFatal("Not a standard AOD");
if (!muonTrack)
continue;
if (!muonTrack->IsMuonTrack())
// 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){
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 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();
fPrimTrackArrayAss = new TObjArray();
const Int_t nTracksAODAss = fAODEvent->GetNumberOfTracks();
for (Int_t iTrack = 0; iTrack < nTracksAODAss; ++iTrack) {
- AliAODTrack *trk = fAODEvent->GetTrack(iTrack);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(iTrack));
+ if(!trk) AliFatal("Not a standard AOD");
if (trk->TestFilterBit(fAssFilterMask))
fPrimTrackArrayAss->Add(trk);
}
fPrimTrackArrayTrg = new TObjArray();
const Int_t nTracksAODTrg = fAODEvent->GetNumberOfTracks();
for (Int_t iTrack = 0; iTrack < nTracksAODTrg; ++iTrack) {
- AliAODTrack *trk = fAODEvent->GetTrack(iTrack);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(iTrack));
+ if(!trk) AliFatal("Not a standard AOD");
if (trk->IsHybridGlobalConstrainedGlobal())
fPrimTrackArrayTrg->Add(trk);
}
}
else
{
- AliAODTrack *tr = aodE->GetTrack(it);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>(aodE->GetTrack(it));
+ if(!tr) AliFatal("Not a standard AOD");
if(!tr) continue;
if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask)))continue;
label = tr->GetLabel();
}
else
{
- AliAODTrack *tr = aodE->GetTrack(IndexArray[it]);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>(aodE->GetTrack(IndexArray[it]));
+ if(!tr) AliFatal("Not a standard AOD");
if(!tr) continue;
AliAODTrack tmp(*tr);
tmp.PropagateToDCA(primVtx, bfield, 5., dca, cov);
for(int it = 0;it < aodE->GetNumberOfTracks(); it++)
{
- AliAODTrack *tr = aodE->GetTrack(it);
+ AliAODTrack *tr = dynamic_cast<AliAODTrack*>(aodE->GetTrack(it));
+ if(!tr) AliFatal("Not a standard AOD");
if(!tr) continue;
if((fFilterMask>0)&&!(tr->TestFilterBit(fFilterMask))) continue;
if(TMath::Abs(tr->Eta())>1.) continue;
//get multiplicity tpc only track cuts
for(Int_t iT = 0; iT < nAODTracks; iT++) {
- AliAODTrack* aodTrack = AODevent->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(AODevent->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if(TMath::Abs(aodTrack->Eta()) > fEtaCut)
continue;
for(Int_t iT = 0; iT < nAODTracks; iT++) {
- AliAODTrack* aodTrack = AODevent->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(AODevent->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (fTrackFilterGolden) {
// "Global track RAA analysis QM2011 + Chi2ITS<36"; bit 1024
AliAODEvent *aod = (AliAODEvent *)fRef;
if (i >= 0 && i < aod->GetNumberOfTracks()) {
- AliAODTrack *track = aod->GetTrack(i);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
if (track) {
out.SetRef(track);
out.SetGood();
// Track loop
for (Int_t i = 0; i < fAOD->GetNumberOfTracks(); i++) {
- AliAODTrack* aodtrack = fAOD->GetTrack(i);
+ AliAODTrack* aodtrack = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(i));
+ if(!aodtrack) AliFatal("Not a standard AOD");
if (!aodtrack) continue;
status=aodtrack->GetStatus();
// for(Int_t i = 0; i < eventAOD->GetNumberOfTracks(); i++) { iIndexAcceptedTracks[i] = 0; }
// for(Int_t itrack = 0; itrack < eventAOD->GetNumberOfTracks(); itrack++)
// {
-// track = eventAOD->GetTrack(itrack);
+// track = dynamic_cast<AliAODTrack*>(eventAOD->GetTrack(itrack));
+ if(!track) AliFatal("Not a standard AOD");
// if(!track) continue;
//
// GetDCA(track, eventAOD, dDCA);
for(Int_t itrack = 0; itrack < eventAOD->GetNumberOfTracks(); itrack++)
// for(Int_t itrack = 0; itrack < nTotalNumberAcceptedTracks; itrack++)
{
- track = eventAOD->GetTrack(itrack);
+ track = dynamic_cast<AliAODTrack*>(eventAOD->GetTrack(itrack));
+ if(!track) AliFatal("Not a standard AOD");
// track = eventAOD->GetTrack(iIndexAcceptedTracks[itrack]);
if(!track) continue;
for(Int_t itrack = 0; itrack < event->GetNumberOfTracks(); itrack++)
{
- tr = event->GetTrack(itrack);
+ tr = dynamic_cast<AliAODTrack*>(event->GetTrack(itrack));
+ if(!tr) AliFatal("Not a standard AOD");
if(!tr) continue;
// do some selection already
// track loop
for(Int_t i = 0; i < fAODevent->GetNumberOfTracks(); ++i)
{
- AliAODTrack* iTrack = fAODevent->GetTrack(i);
+ AliAODTrack* iTrack = dynamic_cast<AliAODTrack*>(fAODevent->GetTrack(i));
+ if(!iTrack) AliFatal("Not a standard AOD");
if(!iTrack) continue;
Double_t mass[3]={1.39570000000000000e-01,4.93676999999999977e-01,9.38271999999999995e-01};//FIXME masses to be taken from AliHelperPID
//main loop on tracks
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,kTRUE)) continue;
fPID->FillQAHistos(fHistMan, track, fTrackCuts);
Int_t Nch = 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(fCharge != 0 && track->Charge() != fCharge) continue;//if fCharge != 0 only select fCharge
if (!fTrackCuts->IsSelected(track,kTRUE)) continue; //track selection (rapidity selection NOT in the standard cuts)
if(!fFillOnlyEvents){
//main loop on tracks
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(fCharge != 0 && track->Charge() != fCharge) continue;//if fCharge != 0 only select fCharge
if (!fTrackCuts->IsSelected(track,kTRUE)) continue; //track selection (rapidity selection NOT in the standard cuts)
nTrackWithTPCrefitMultiplicity = 0;
lPrimaryTrackMultiplicity = 0;
for (Int_t itrack = 0; itrack<nTrackMultiplicity; itrack++) {
- AliAODTrack* track = lAODevent->GetTrack(itrack);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(lAODevent->GetTrack(itrack));
+ if(!track) AliFatal("Not a standard AOD");
if (track->TestFilterBit(AliAODTrack::kTrkGlobalNoDCA)) lPrimaryTrackMultiplicity++; // kTrkGlobal tight DCA cut --> mult is much lower than the one selectied with standard cuts in ESDs
if (track->IsOn(AliAODTrack::kTPCrefit)) nTrackWithTPCrefitMultiplicity++;
}
lPrimaryTrackMultiplicity = 0.;
for (Int_t itrack = 0; itrack<nTrackMultiplicity; itrack++) {
- AliAODTrack* track = lAODevent->GetTrack(itrack);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(lAODevent->GetTrack(itrack));
+ if(!track) AliFatal("Not a standard AOD");
if (track->TestFilterBit(AliAODTrack::kTrkGlobalNoDCA)) lPrimaryTrackMultiplicity++;
}
Double_t pTrig[3];
if( (step==kTriggerCheck || isTriggered) && idTrig>=0 ){
- trkTrig = (AliAODTrack*)fAOD->GetTrack(idTrig);
+ trkTrig = dynamic_cast<AliAODTrack*>(fAOD->GetTrack(idTrig));
+ if(!trkTrig) AliFatal("Not a standard AOD");
ptTrig = trkTrig->Pt();
phiTrig = trkTrig->Phi();
etaTrig = trkTrig->Eta();
Float_t resPhi = -1000.;
for (Int_t i=0; i<nTrk; i++) {
- const AliAODTrack *t = fAOD->GetTrack(i);
+ const AliAODTrack *t = dynamic_cast<const AliAODTrack*>(fAOD->GetTrack(i));
+ if(!t) AliFatal("Not a standard AOD");
if(!AcceptTrack(t)) continue;
pt=t->Pt();
eta=t->Eta();
for (Int_t i = 0; i < nTracks; i++)
{
- AliAODTrack* tr = aod->GetTrack(i);
+ AliAODTrack* tr = dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
+ if(!tr) AliFatal("Not a standard AOD");
selectedMCTracks->Add(tr);
}
// cout << "before compressing = " << selectedMCTracks->GetEntriesFast() << endl;
//cout << "before getting label -3" << endl;
for (Int_t i = 0; i < nRecTracks; i++)
{
- //AliAODTrack* tras = aod->GetTrack(i);
+ //AliAODTrack* tras = dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
AliAODTrack* tras = (AliAODTrack*)selectedMCTracks->At(i);
//cout << "before getting label -2" << endl;
//cout << " and i = " << i << endl;
selectedChargedTriggers->SetOwner(kTRUE);
for (Int_t i = 0; i < nTracks; i++)
{
- AliAODTrack* tr = aod->GetTrack(i);
+ AliAODTrack* tr = dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
+ if(!tr) AliFatal("Not a standard AOD");
if ((tr->Pt())<PtAssocMin) continue;
if (!(IsMyGoodPrimaryTrack(tr))) continue;
selectedTracks->Add(tr);
Int_t ntrk1=aod->GetNumberOfTracks();
Int_t mult=0;
for (Int_t i=0; i<ntrk1; i++) {
- AliAODTrack *t=aod->GetTrack(i);
+ AliAODTrack *t=dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
+ if(!t) AliFatal("Not a standard AOD");
if (t->IsMuonTrack()) continue;
if (!t->IsOn(AliAODTrack::kTPCrefit)) continue;
Double_t Qx2 = 0, Qy2 = 0;
Double_t Qx3 = 0, Qy3 = 0;
for(Int_t iT = 0; iT < ntrack; iT++) {
- AliAODTrack* aodTrack = aodEvent->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (!aodTrack){
continue;
nmc = mcArray->GetEntries();
for(Int_t i=0;i < ntrack;i++){ // loop on tracks
- AliAODTrack* track = aodEvent->GetTrack(i);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
AliAODMCParticle *mcp = NULL;
Int_t pdg = 0;
// start analysis K0s
for(Int_t i=0;i < ntrack;i++){ // loop on positive tracks
- AliAODTrack* KpTrack = aodEvent->GetTrack(i);
+ AliAODTrack* KpTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(i));
+ if(!KpTrack) AliFatal("Not a standard AOD");
if (!KpTrack){
continue;
if(iks > -1 && fIpiN[iks] > -1){
//for(Int_t j=0;j < ntrack;j++){ // loop on negative tracks
Int_t j = fIpiN[iks];
- AliAODTrack* KnTrack = aodEvent->GetTrack(j);
+ AliAODTrack* KnTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(j));
+ if(!KnTrack) AliFatal("Not a standard AOD");
if (!KnTrack){
continue;
// fill pion stacks
Int_t nAODTracks = fOutputAOD->GetNumberOfTracks();
for(Int_t iT = 0; iT < nAODTracks; iT++) { // loop on the tracks
- AliAODTrack* aodTrack = fOutputAOD->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(fOutputAOD->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (!aodTrack){
continue;
Int_t ntrack = fOutputAOD->GetNumberOfTracks();
for(Int_t i=0;i < ntrack;i++){ // loop on tracks
- AliAODTrack* track = fOutputAOD->GetTrack(i);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(fOutputAOD->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
if(track == trk) return i;
}
Double_t Qx2 = 0, Qy2 = 0;
Double_t Qx3 = 0, Qy3 = 0;
for(Int_t iT = 0; iT < ntrack; iT++) {
- AliAODTrack* aodTrack = aodEvent->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (!aodTrack){
continue;
nmc = mcArray->GetEntries();
for(Int_t i=0;i < ntrack;i++){ // loop on tracks
- AliAODTrack* track = aodEvent->GetTrack(i);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
AliAODMCParticle *mcp = NULL;
Int_t pdg = 0;
// start analysis Lambda
for(Int_t i=0;i < ntrack;i++){ // loop on proton candidate tracks
- AliAODTrack* KpTrack = aodEvent->GetTrack(i);
+ AliAODTrack* KpTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(i));
+ if(!KpTrack) AliFatal("Not a standard AOD");
if (!KpTrack){
continue;
if(iks > -1 && fIpN[iks] > -1){
//for(Int_t j=0;j < ntrack;j++){ // loop on negative tracks
Int_t j = fIpN[iks];
- AliAODTrack* KnTrack = aodEvent->GetTrack(j);
+ AliAODTrack* KnTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(j));
+ if(!KnTrack) AliFatal("Not a standard AOD");
if (!KnTrack){
continue;
Int_t ntrack = fOutputAOD->GetNumberOfTracks();
for(Int_t i=0;i < ntrack;i++){ // loop on tracks
- AliAODTrack* track = fOutputAOD->GetTrack(i);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(fOutputAOD->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
if(track == trk) return i;
}
Double_t Qx2 = 0, Qy2 = 0;
Double_t Qx3 = 0, Qy3 = 0;
for(Int_t iT = 0; iT < ntrack; iT++) {
- AliAODTrack* aodTrack = aodEvent->GetTrack(iT);
+ AliAODTrack* aodTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(iT));
+ if(!aodTrack) AliFatal("Not a standard AOD");
if (!aodTrack){
continue;
nmc = mcArray->GetEntries();
for(Int_t i=0;i < ntrack;i++){ // loop on tracks
- AliAODTrack* track = aodEvent->GetTrack(i);
+ AliAODTrack* track = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
AliAODMCParticle *mcp = NULL;
Int_t pdg = 0;
// start analysis phi
for(Int_t i=0;i < ntrack;i++){ // loop on positive tracks
- AliAODTrack* KpTrack = aodEvent->GetTrack(i);
+ AliAODTrack* KpTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(i));
+ if(!KpTrack) AliFatal("Not a standard AOD");
if (!KpTrack){
continue;
if(fPtKp > 4.299) fPtKp = 4.299;
for(Int_t j=0;j < ntrack;j++){ // loop on negative tracks
- AliAODTrack* KnTrack = aodEvent->GetTrack(j);
+ AliAODTrack* KnTrack = dynamic_cast<AliAODTrack*>(aodEvent->GetTrack(j));
+ if(!KnTrack) AliFatal("Not a standard AOD");
if (!KnTrack){
continue;
// header of the class itsself
#include "AliCDMesonTracks.h"
+#include "assert.h"
//------------------------------------------------------------------------------
}
for (Int_t iTrk = 0; iTrk < AODEvent->GetNumberOfTracks(); iTrk++) {
- const AliAODTrack* trk = AODEvent->GetTrack(iTrk);
+ const AliAODTrack* trk = dynamic_cast<const AliAODTrack*>(AODEvent->GetTrack(iTrk));
+ assert(trk&&"Not a standard AOD");
if (trk->TestFilterBit(bit)) {
// test whether track was selected by that filter
//Track loop
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
+ if(!trk) AliFatal("Not a standard AOD");
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
//Track loop
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
+ if(!trk) AliFatal("Not a standard AOD");
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
//Four track loop
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
MeanPt = GetMedian(TrackPt);
fHistNeventsPsi2s->Fill(6);
for(Int_t i=0; i<4; i++){
- AliAODTrack *trk = aod->GetTrack(TrackIndex[i]);
-
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(TrackIndex[i]));
+ if(!trk) AliFatal("Not a standard AOD");
+
if(trk->Pt() > MeanPt){
fRecTPCsignal[nLepton] = trk->GetTPCsignal();
qLepton[nLepton] = trk->Charge();
nGoodTracks = 0;
//Two track loop
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
if(nGoodTracks == 2){
fHistNeventsJPsi->Fill(6);
for(Int_t i=0; i<2; i++){
- AliAODTrack *trk = aod->GetTrack(TrackIndex[i]);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(TrackIndex[i]));
+ if(!trk) AliFatal("Not a standard AOD");
if(trk->Pt() > 1) nHighPt++;
fRecTPCsignal[nLepton] = trk->GetTPCsignal();
qLepton[nLepton] = trk->Charge();
//Track loop - loose cuts
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
//Two track loop
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
KFvtx->SetField(aod->GetMagneticField());
for(Int_t i=0; i<2; i++){
- AliAODTrack *trk = aod->GetTrack(TrackIndex[i]);
-
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(TrackIndex[i]));
+ if(!trk) AliFatal("Not a standard AOD");
+
Double_t dca[2] = {0.0,0.0}, cov[3] = {0.0,0.0,0.0};
AliAODTrack* trk_clone=(AliAODTrack*)trk->Clone("trk_clone");
if(!trk_clone->PropagateToDCA(fAODVertex,aod->GetMagneticField(),300.,dca,cov)) continue;
nGoodTracks = 0;
//Four track loop
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
KFvtx->SetField(aod->GetMagneticField());
for(Int_t i=0; i<4; i++){
- AliAODTrack *trk = aod->GetTrack(TrackIndex[i]);
-
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(TrackIndex[i]));
+ if(!trk) AliFatal("Not a standard AOD");
+
Double_t dca[2] = {0.0,0.0}, cov[3] = {0.0,0.0,0.0};
AliAODTrack* trk_clone=(AliAODTrack*)trk->Clone("trk_clone");
if(!trk_clone->PropagateToDCA(fAODVertex,aod->GetMagneticField(),300.,dca,cov)) continue;
//Two track loop
nGoodTracks = 0;
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
if(nGoodTracks == 2){
for(Int_t k=0; k<2; k++){
- AliAODTrack *trk = aod->GetTrack(TrackIndex[k]);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(TrackIndex[k]));
+ if(!trk) AliFatal("Not a standard AOD");
+
if(trk->Pt() > 1) nHighPt++;
fRecTPCsignal[nLepton] = trk->GetTPCsignal();
qLepton[nLepton] = trk->Charge();
//Two track loop
nGoodTracks = 0;
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
if(nGoodTracks == 2){
for(Int_t k=0; k<2; k++){
- AliAODTrack *trk = aod->GetTrack(TrackIndex[k]);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(TrackIndex[k]));
+ if(!trk) AliFatal("Not a standard AOD");
+
if(trk->Pt() > 1) nHighPt++;
fRecTPCsignal[nLepton] = trk->GetTPCsignal();
qLepton[nLepton] = trk->Charge();
//Four track loop
nGoodTracks = 0; nSpdHits = 0;
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
if(i!=4){ if(nSpdHits<2) continue;}
MeanPt = GetMedian(TrackPt);
for(Int_t k=0; k<4; k++){
- AliAODTrack *trk = aod->GetTrack(TrackIndex[k]);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(TrackIndex[k]));
+ if(!trk) AliFatal("Not a standard AOD");
+
if(trk->Pt() > MeanPt){
fRecTPCsignal[nLepton] = trk->GetTPCsignal();
qLepton[nLepton] = trk->Charge();
//Four track loop
nGoodTracks = 0; nSpdHits = 0;
for(Int_t itr=0; itr<aod ->GetNumberOfTracks(); itr++) {
- AliAODTrack *trk = aod->GetTrack(itr);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(itr));
if( !trk ) continue;
if(!(trk->TestFilterBit(1<<0))) continue;
if(nSpdHits<2) continue;
MeanPt = GetMedian(TrackPt);
for(Int_t k=0; k<4; k++){
- AliAODTrack *trk = aod->GetTrack(TrackIndex[k]);
+ AliAODTrack *trk = dynamic_cast<AliAODTrack*>(aod->GetTrack(TrackIndex[k]));
+ if(!trk) AliFatal("Not a standard AOD");
+
if(trk->Pt() > MeanPt){
fRecTPCsignal[nLepton] = trk->GetTPCsignal();
qLepton[nLepton] = trk->Charge();
Int_t tofLabel[3];
if(tracks){
for(int it = 0; it < fAODEvent->GetNumberOfTracks();++it){
- AliAODTrack *track = fAODEvent->GetTrack(it);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(it));
+ if(!track) AliFatal("Not a standard AOD");
Int_t sign = 1;
Int_t label = track->GetLabel();
}
Int_t nTracks = fAODEvent->GetNumberOfTracks();
for (Int_t nTr = 0; nTr < nTracks; nTr++) {
- AliAODTrack *track = fAODEvent->GetTrack(nTr);
+ AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(nTr));
+ if(!track) AliFatal("Not a standard AOD");
Double_t fPt = track->Pt();
if(fPt > maxPt) {
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff