#include <TROOT.h>
#include <TTree.h>
#include <TFolder.h>
#include <TFriendElement.h>
#include <TProcessID.h>
#include <TCollection.h>
#include "Riostream.h"
#include "AliAODEvent.h"
#include "AliAODHeader.h"
#include "AliAODTrack.h"
#include "AliAODDimuon.h"
#include "AliAODTrdTrack.h"
ClassImp(AliAODEvent)
const char* AliAODEvent::fAODListName[kAODListN] = {"header",
"tracks",
"vertices",
"v0s",
"cascades",
"tracklets",
"jets",
"emcalCells",
"phosCells",
"caloClusters",
"emcalTrigger",
"phosTrigger",
"fmdClusters",
"pmdClusters",
"hmpidRings",
"dimuons",
"AliAODTZERO",
"AliAODVZERO",
"AliAODZDC",
"AliTOFHeader",
"trdTracks"
};
AliAODEvent::AliAODEvent() :
AliVEvent(),
fAODObjects(0),
fAODFolder(0),
fConnected(kFALSE),
fTracksConnected(kFALSE),
fHeader(0),
fTracks(0),
fVertices(0),
fV0s(0),
fCascades(0),
fTracklets(0),
fJets(0),
fEmcalCells(0),
fPhosCells(0),
fCaloClusters(0),
fEMCALTrigger(0),
fPHOSTrigger(0),
fFmdClusters(0),
fPmdClusters(0),
fHMPIDrings(0),
fDimuons(0),
fAODTZERO(0),
fAODVZERO(0),
fAODZDC(0),
fTOFHeader(0),
fTrdTracks(0)
{
if (TClass::IsCallingNew() != TClass::kDummyNew) fAODObjects = new TList();
}
AliAODEvent::AliAODEvent(const AliAODEvent& aod):
AliVEvent(aod),
fAODObjects(new TList()),
fAODFolder(0),
fConnected(kFALSE),
fTracksConnected(kFALSE),
fHeader(0),
fTracks(new TClonesArray(*aod.fTracks)),
fVertices(new TClonesArray(*aod.fVertices)),
fV0s(new TClonesArray(*aod.fV0s)),
fCascades(new TClonesArray(*aod.fCascades)),
fTracklets(new AliAODTracklets(*aod.fTracklets)),
fJets(new TClonesArray(*aod.fJets)),
fEmcalCells(new AliAODCaloCells(*aod.fEmcalCells)),
fPhosCells(new AliAODCaloCells(*aod.fPhosCells)),
fCaloClusters(new TClonesArray(*aod.fCaloClusters)),
fEMCALTrigger(new AliAODCaloTrigger(*aod.fEMCALTrigger)),
fPHOSTrigger(new AliAODCaloTrigger(*aod.fPHOSTrigger)),
fFmdClusters(new TClonesArray(*aod.fFmdClusters)),
fPmdClusters(new TClonesArray(*aod.fPmdClusters)),
fHMPIDrings(new TClonesArray(*aod.fHMPIDrings)),
fDimuons(new TClonesArray(*aod.fDimuons)),
fAODTZERO(new AliAODTZERO(*aod.fAODTZERO)),
fAODVZERO(new AliAODVZERO(*aod.fAODVZERO)),
fAODZDC(new AliAODZDC(*aod.fAODZDC)),
fTOFHeader(new AliTOFHeader(*aod.fTOFHeader)),
fTrdTracks(new TClonesArray(*aod.fTrdTracks))
{
AddHeader(fHeader);
AddObject(fHeader);
AddObject(fTracks);
AddObject(fVertices);
AddObject(fV0s);
AddObject(fCascades);
AddObject(fTracklets);
AddObject(fJets);
AddObject(fEmcalCells);
AddObject(fPhosCells);
AddObject(fCaloClusters);
AddObject(fEMCALTrigger);
AddObject(fPHOSTrigger);
AddObject(fFmdClusters);
AddObject(fPmdClusters);
AddObject(fHMPIDrings);
AddObject(fDimuons);
AddObject(fAODTZERO);
AddObject(fAODVZERO);
AddObject(fAODZDC);
AddObject(fTOFHeader);
AddObject(fTrdTracks);
fConnected = aod.fConnected;
ConnectTracks();
GetStdContent();
CreateStdFolders();
}
AliAODEvent & AliAODEvent::operator=(const AliAODEvent& aod) {
if(&aod == this) return *this;
AliVEvent::operator=(aod);
if((fAODObjects->GetSize()==0)&&(aod.fAODObjects->GetSize()>=kAODListN)){
CreateStdContent();
}
TIter next(aod.GetList());
TObject *its = 0;
TString name;
while ((its = next())) {
name = its->GetName();
TObject *mine = fAODObjects->FindObject(name);
if(!mine) {
TClass* pClass=TClass::GetClass(its->ClassName());
if (!pClass) {
AliWarning(Form("Can not find class description for entry %s (%s)\n",
its->ClassName(), name.Data()));
continue;
}
mine=(TObject*)pClass->New();
if(!mine){
AliWarning(Form("%s:%d Could not find %s for copying \n",
(char*)__FILE__,__LINE__,name.Data()));
continue;
}
if(mine->InheritsFrom("TNamed")) {
((TNamed*)mine)->SetName(name);
} else if(mine->InheritsFrom("TCollection")){
if(mine->InheritsFrom("TClonesArray")) {
TClonesArray *itscl = dynamic_cast<TClonesArray*>(its);
if (!itscl) {
AliWarning(Form("Class description for entry %s (%s) not TClonesArray\n",
its->ClassName(), name.Data()));
continue;
}
dynamic_cast<TClonesArray*>(mine)->SetClass(itscl->GetClass(), itscl->GetSize());
}
dynamic_cast<TCollection*>(mine)->SetName(name);
}
AliDebug(1, Form("adding object %s of type %s", mine->GetName(), mine->ClassName()));
AddObject(mine);
}
if(!its->InheritsFrom("TCollection")){
its->Copy(*mine);
} else if (its->InheritsFrom("TClonesArray")) {
TClonesArray *its_tca = (TClonesArray*)its;
TClonesArray *mine_tca = (TClonesArray*)mine;
Int_t its_entries = its_tca->GetEntriesFast();
mine_tca->ExpandCreate(its_entries);
for(int i=0; i<its_entries; i++){
TObject *mine_tca_obj = mine_tca->At(i);
TObject *its_tca_obj = its_tca->At(i);
its_tca_obj->Copy(*mine_tca_obj);
}
} else {
AliWarning(Form("%s:%d cannot copy TCollection \n",
(char*)__FILE__,__LINE__));
}
}
fConnected = aod.fConnected;
fTracksConnected = kFALSE;
ConnectTracks();
return *this;
}
AliAODEvent::~AliAODEvent()
{
delete fAODFolder;
fAODFolder = 0;
if(!fConnected) {
delete fAODObjects;
}
}
void AliAODEvent::AddObject(TObject* obj)
{
if ( !fAODObjects->FindObject(obj) )
{
fAODObjects->AddLast(obj);
}
}
Int_t AliAODEvent::AddTrack(const AliAODTrack* trk)
{
AliAODTrack *track = new((*fTracks)[fTracks->GetEntriesFast()]) AliAODTrack(*trk);
track->SetAODEvent(this);
return fTracks->GetEntriesFast()-1;
}
void AliAODEvent::RemoveObject(TObject* obj)
{
fAODObjects->Remove(obj);
}
TObject *AliAODEvent::FindListObject(const char *objName) const
{
return fAODObjects->FindObject(objName);
}
void AliAODEvent::CreateStdContent()
{
AddObject(new AliAODHeader());
AddObject(new TClonesArray("AliAODTrack", 0));
AddObject(new TClonesArray("AliAODVertex", 0));
AddObject(new TClonesArray("AliAODv0", 0));
AddObject(new TClonesArray("AliAODcascade", 0));
AddObject(new AliAODTracklets());
AddObject(new TClonesArray("AliAODJet", 0));
AddObject(new AliAODCaloCells());
AddObject(new AliAODCaloCells());
AddObject(new TClonesArray("AliAODCaloCluster", 0));
AddObject(new AliAODCaloTrigger());
AddObject(new AliAODCaloTrigger());
AddObject(new TClonesArray("AliAODFmdCluster", 0));
AddObject(new TClonesArray("AliAODPmdCluster", 0));
AddObject(new TClonesArray("AliAODHMPIDrings", 0));
AddObject(new TClonesArray("AliAODDimuon", 0));
AddObject(new AliAODTZERO());
AddObject(new AliAODVZERO());
AddObject(new AliAODZDC());
AddObject(new AliTOFHeader());
AddObject(new TClonesArray("AliAODTrdTrack", 0));
SetStdNames();
GetStdContent();
CreateStdFolders();
return;
}
void AliAODEvent::MakeEntriesReferencable()
{
TIter next(fAODObjects);
TObject* obj;
while ((obj = next()))
{
if(obj->InheritsFrom("TCollection"))
{
AssignIDtoCollection((TCollection*)obj);
}
}
}
void AliAODEvent::SetStdNames()
{
if(fAODObjects->GetEntries()==kAODListN){
for(int i = 0;i < fAODObjects->GetEntries();i++){
TObject *fObj = fAODObjects->At(i);
if(fObj->InheritsFrom("TNamed")){
((TNamed*)fObj)->SetName(fAODListName[i]);
}
else if(fObj->InheritsFrom("TClonesArray")){
((TClonesArray*)fObj)->SetName(fAODListName[i]);
}
}
}
else{
printf("%s:%d SetStdNames() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
}
}
void AliAODEvent::CreateStdFolders()
{
if(fAODFolder)delete fAODFolder;
fAODFolder = gROOT->GetRootFolder()->AddFolder("AOD", "AOD");
if(fAODObjects->GetEntries()==kAODListN){
for(int i = 0;i < fAODObjects->GetEntries();i++){
TObject *fObj = fAODObjects->At(i);
if(fObj->InheritsFrom("TClonesArray")){
fAODFolder->AddFolder(fAODListName[i], fAODListName[i], (TCollection*) fObj);
} else {
fAODFolder->AddFolder(fAODListName[i], fAODListName[i], 0);
}
}
}
else{
printf("%s:%d CreateStdFolders() Wrong number of Std Entries \n",(char*)__FILE__,__LINE__);
}
}
void AliAODEvent::GetStdContent()
{
fHeader = (AliVAODHeader*)fAODObjects->FindObject("header");
fTracks = (TClonesArray*)fAODObjects->FindObject("tracks");
fVertices = (TClonesArray*)fAODObjects->FindObject("vertices");
fV0s = (TClonesArray*)fAODObjects->FindObject("v0s");
fCascades = (TClonesArray*)fAODObjects->FindObject("cascades");
fTracklets = (AliAODTracklets*)fAODObjects->FindObject("tracklets");
fJets = (TClonesArray*)fAODObjects->FindObject("jets");
fEmcalCells = (AliAODCaloCells*)fAODObjects->FindObject("emcalCells");
fPhosCells = (AliAODCaloCells*)fAODObjects->FindObject("phosCells");
fCaloClusters = (TClonesArray*)fAODObjects->FindObject("caloClusters");
fEMCALTrigger = (AliAODCaloTrigger*)fAODObjects->FindObject("emcalTrigger");
fPHOSTrigger = (AliAODCaloTrigger*)fAODObjects->FindObject("phosTrigger");
fFmdClusters = (TClonesArray*)fAODObjects->FindObject("fmdClusters");
fPmdClusters = (TClonesArray*)fAODObjects->FindObject("pmdClusters");
fHMPIDrings = (TClonesArray*)fAODObjects->FindObject("hmpidRings");
fDimuons = (TClonesArray*)fAODObjects->FindObject("dimuons");
fAODTZERO = (AliAODTZERO*)fAODObjects->FindObject("AliAODTZERO");
fAODVZERO = (AliAODVZERO*)fAODObjects->FindObject("AliAODVZERO");
fAODZDC = (AliAODZDC*)fAODObjects->FindObject("AliAODZDC");
fTOFHeader = (AliTOFHeader*)fAODObjects->FindObject("AliTOFHeader");
fTrdTracks = (TClonesArray*)fAODObjects->FindObject("trdTracks");
}
void AliAODEvent::ResetStd(Int_t trkArrSize,
Int_t vtxArrSize,
Int_t v0ArrSize,
Int_t cascadeArrSize,
Int_t jetSize,
Int_t caloClusSize,
Int_t fmdClusSize,
Int_t pmdClusSize,
Int_t hmpidRingsSize,
Int_t dimuonArrSize,
Int_t nTrdTracks
)
{
fTracksConnected = kFALSE;
if (fTracks) {
fTracks->Delete();
if (trkArrSize > fTracks->GetSize())
fTracks->Expand(trkArrSize);
}
if (fVertices) {
fVertices->Delete();
if (vtxArrSize > fVertices->GetSize())
fVertices->Expand(vtxArrSize);
}
if (fV0s) {
fV0s->Delete();
if (v0ArrSize > fV0s->GetSize())
fV0s->Expand(v0ArrSize);
}
if (fCascades) {
fCascades->Delete();
if (cascadeArrSize > fCascades->GetSize())
fCascades->Expand(cascadeArrSize);
}
if (fJets) {
fJets->Delete();
if (jetSize > fJets->GetSize())
fJets->Expand(jetSize);
}
if (fCaloClusters) {
fCaloClusters->Delete();
if (caloClusSize > fCaloClusters->GetSize())
fCaloClusters->Expand(caloClusSize);
}
if (fFmdClusters) {
fFmdClusters->Delete();
if (fmdClusSize > fFmdClusters->GetSize())
fFmdClusters->Expand(fmdClusSize);
}
if (fPmdClusters) {
fPmdClusters->Delete();
if (pmdClusSize > fPmdClusters->GetSize())
fPmdClusters->Expand(pmdClusSize);
}
if (fHMPIDrings) {
fHMPIDrings->Delete();
if (hmpidRingsSize > fHMPIDrings->GetSize())
fHMPIDrings->Expand(hmpidRingsSize);
}
if (fDimuons) {
fDimuons->Delete();
if (dimuonArrSize > fDimuons->GetSize())
fDimuons->Expand(dimuonArrSize);
}
if (fTrdTracks) {
fTrdTracks->Delete();
if (nTrdTracks > fTrdTracks->GetSize())
fTrdTracks->Expand(nTrdTracks);
}
if (fTracklets)
fTracklets->DeleteContainer();
if (fPhosCells)
fPhosCells->DeleteContainer();
if (fEmcalCells)
fEmcalCells->DeleteContainer();
if (fEMCALTrigger)
fEMCALTrigger->DeAllocate();
if (fPHOSTrigger)
fPHOSTrigger->DeAllocate();
}
void AliAODEvent::ClearStd()
{
if (fHeader){
if(fHeader->InheritsFrom("AliAODHeader")){
fHeader ->Clear();
}
else {
AliVHeader * head = 0;
head = dynamic_cast<AliVHeader*>((TObject*)fHeader);
if(head) head->Clear();
}
}
fTracksConnected = kFALSE;
if (fTracks)
fTracks ->Delete();
if (fVertices)
fVertices ->Delete();
if (fV0s)
fV0s ->Delete();
if (fCascades)
fCascades ->Delete();
if (fTracklets)
fTracklets ->DeleteContainer();
if (fJets)
fJets ->Delete();
if (fEmcalCells)
fEmcalCells ->DeleteContainer();
if (fPhosCells)
fPhosCells ->DeleteContainer();
if (fCaloClusters)
fCaloClusters ->Delete();
if (fFmdClusters)
fFmdClusters ->Clear();
if (fPmdClusters)
fPmdClusters ->Clear();
if (fHMPIDrings)
fHMPIDrings ->Clear();
if (fDimuons)
fDimuons ->Clear();
if (fTrdTracks)
fTrdTracks ->Clear();
if (fEMCALTrigger)
fEMCALTrigger->DeAllocate();
if (fPHOSTrigger)
fPHOSTrigger->DeAllocate();
}
Int_t AliAODEvent::GetPHOSClusters(TRefArray *clusters) const
{
clusters->Clear();
AliAODCaloCluster *cl = 0;
Bool_t first = kTRUE;
for (Int_t i = 0; i < GetNumberOfCaloClusters() ; i++) {
if ( (cl = GetCaloCluster(i)) ) {
if (cl->IsPHOS()){
if(first) {
new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl));
first=kFALSE;
}
clusters->Add(cl);
}
}
}
return clusters->GetEntriesFast();
}
Int_t AliAODEvent::GetEMCALClusters(TRefArray *clusters) const
{
clusters->Clear();
AliAODCaloCluster *cl = 0;
Bool_t first = kTRUE;
for (Int_t i = 0; i < GetNumberOfCaloClusters(); i++) {
if ( (cl = GetCaloCluster(i)) ) {
if (cl->IsEMCAL()){
if(first) {
new (clusters) TRefArray(TProcessID::GetProcessWithUID(cl));
first=kFALSE;
}
clusters->Add(cl);
}
}
}
return clusters->GetEntriesFast();
}
Int_t AliAODEvent::GetMuonTracks(TRefArray *muonTracks) const
{
muonTracks->Clear();
AliAODTrack *track = 0;
for (Int_t iTrack = 0; iTrack < GetNumberOfTracks(); iTrack++) {
track = dynamic_cast<AliAODTrack*>(GetTrack(iTrack));
if(!track) AliFatal("Not a standard AOD");
if (track->IsMuonTrack()) {
muonTracks->Add(track);
}
}
return muonTracks->GetEntriesFast();
}
Int_t AliAODEvent::GetNumberOfMuonTracks() const
{
Int_t nMuonTracks=0;
if(!dynamic_cast<AliAODTrack*>(GetTrack(0))) {
AliError("Not a standard AOD");
return 0;
}
for (Int_t iTrack = 0; iTrack < GetNumberOfTracks(); iTrack++) {
if (((AliAODTrack*)GetTrack(iTrack))->IsMuonTrack()) {
nMuonTracks++;
}
}
return nMuonTracks;
}
Int_t AliAODEvent::GetMuonGlobalTracks(TRefArray *muonGlobalTracks) const
{
muonGlobalTracks->Clear();
AliAODTrack *track = 0;
for (Int_t iTrack = 0; iTrack < GetNumberOfTracks(); iTrack++) {
track = dynamic_cast<AliAODTrack*>(GetTrack(iTrack));
if(!track) AliFatal("Not a standard AOD");
if (track->IsMuonGlobalTrack()) {
muonGlobalTracks->Add(track);
}
}
return muonGlobalTracks->GetEntriesFast();
}
Int_t AliAODEvent::GetNumberOfMuonGlobalTracks() const
{
Int_t nMuonGlobalTracks=0;
if(!dynamic_cast<AliAODTrack*>(GetTrack(0))) {
AliError("Not a standard AOD");
return 0;
}
for (Int_t iTrack = 0; iTrack < GetNumberOfTracks(); iTrack++) {
if (((AliAODTrack*)GetTrack(iTrack))->IsMuonGlobalTrack()) {
nMuonGlobalTracks++;
}
}
return nMuonGlobalTracks;
}
void AliAODEvent::ReadFromTree(TTree *tree, Option_t* opt )
{
if(!tree){
AliWarning("Zero Pointer to Tree \n");
return;
}
if(!tree->GetTree())tree->LoadTree(0);
AliAODEvent *aodEvent = 0;
aodEvent = (AliAODEvent*)tree->GetTree()->GetUserInfo()->FindObject("AliAODEvent");
if(aodEvent){
aodEvent->SetConnected();
TList* connectedList = (TList*) (tree->GetUserInfo()->FindObject("AODObjectsConnectedToTree"));
if (connectedList && (!strcmp(opt, "reconnect"))) {
if (fAODObjects != connectedList) {
delete fAODObjects;
fAODObjects = connectedList;
}
GetStdContent();
fConnected = kTRUE;
return;
}
fAODObjects = (TList*)aodEvent->GetList();
fAODObjects->SetOwner(kTRUE);
if(fAODObjects->GetEntries()<kAODListN)
{
AliWarning(Form("AliAODEvent::ReadFromTree() TList contains less than the standard contents %d < %d"
" That might be fine though (at least for filtered AODs)",fAODObjects->GetEntries(),kAODListN));
}
TList* friendL = tree->GetTree()->GetListOfFriends();
if (friendL)
{
TIter next(friendL);
TFriendElement* fe;
while ((fe = (TFriendElement*)next())){
aodEvent = (AliAODEvent*)(fe->GetTree()->GetUserInfo()->FindObject("AliAODEvent"));
if (!aodEvent) {
printf("No UserInfo on tree \n");
} else {
TList* objL = (TList*)aodEvent->GetList();
printf("Get list of object from tree %d !!\n", objL->GetEntries());
TIter nextobject(objL);
TObject* obj = 0;
while((obj = nextobject()))
{
printf("Adding object from friend %s !\n", obj->GetName());
fAODObjects->Add(obj);
}
}
}
}
TIter next(fAODObjects);
TNamed *el;
while((el=(TNamed*)next())){
TString bname(el->GetName());
TBranch *br = tree->GetTree()->GetBranch(bname.Data());
if(br){
tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
} else {
br = tree->GetBranch(Form("%s.",bname.Data()));
if(br){
tree->SetBranchAddress(Form("%s.",bname.Data()),fAODObjects->GetObjectRef(el));
}
else{
printf("%s %d AliAODEvent::ReadFromTree() No Branch found with Name %s. \n",
(char*)__FILE__,__LINE__,bname.Data());
}
}
}
GetStdContent();
fAODObjects->SetOwner(kTRUE);
fAODObjects->SetName("AODObjectsConnectedToTree");
tree->GetUserInfo()->Add(fAODObjects);
fConnected = kTRUE;
}
else {
CreateStdContent();
TIter next(fAODObjects);
TNamed *el;
while((el=(TNamed*)next())){
TString bname(el->GetName());
tree->SetBranchAddress(bname.Data(),fAODObjects->GetObjectRef(el));
}
GetStdContent();
fAODObjects->SetOwner(kTRUE);
}
}
Int_t AliAODEvent::GetNumberOfPileupVerticesSPD() const{
Int_t nVertices=GetNumberOfVertices();
Int_t nPileupVertices=0;
for(Int_t iVert=0; iVert<nVertices; iVert++){
AliAODVertex *v=GetVertex(iVert);
if(v->GetType()==AliAODVertex::kPileupSPD) nPileupVertices++;
}
return nPileupVertices;
}
Int_t AliAODEvent::GetNumberOfPileupVerticesTracks() const{
Int_t nVertices=GetNumberOfVertices();
Int_t nPileupVertices=0;
for(Int_t iVert=0; iVert<nVertices; iVert++){
AliAODVertex *v=GetVertex(iVert);
if(v->GetType()==AliAODVertex::kPileupTracks) nPileupVertices++;
}
return nPileupVertices;
}
AliAODVertex* AliAODEvent::GetPrimaryVertexSPD() const{
Int_t nVertices=GetNumberOfVertices();
for(Int_t iVert=0; iVert<nVertices; iVert++){
AliAODVertex *v=GetVertex(iVert);
if(v->GetType()==AliAODVertex::kMainSPD) return v;
}
return 0;
}
AliAODVertex* AliAODEvent::GetPrimaryVertexTPC() const{
Int_t nVertices=GetNumberOfVertices();
for(Int_t iVert=0; iVert<nVertices; iVert++){
AliAODVertex *v=GetVertex(iVert);
if(v->GetType()==AliAODVertex::kMainTPC) return v;
}
return 0;
}
AliAODVertex* AliAODEvent::GetPileupVertexSPD(Int_t iV) const{
Int_t nVertices=GetNumberOfVertices();
Int_t counter=0;
for(Int_t iVert=0; iVert<nVertices; iVert++){
AliAODVertex *v=GetVertex(iVert);
if(v->GetType()==AliAODVertex::kPileupSPD){
if(counter==iV) return v;
++counter;
}
}
return 0;
}
AliAODVertex* AliAODEvent::GetPileupVertexTracks(Int_t iV) const{
Int_t nVertices=GetNumberOfVertices();
Int_t counter=0;
for(Int_t iVert=0; iVert<nVertices; iVert++){
AliAODVertex *v=GetVertex(iVert);
if(v->GetType()==AliAODVertex::kPileupTracks){
if(counter==iV) return v;
++counter;
}
}
return 0;
}
Bool_t AliAODEvent::IsPileupFromSPD(Int_t minContributors,
Double_t minZdist,
Double_t nSigmaZdist,
Double_t nSigmaDiamXY,
Double_t nSigmaDiamZ) const{
AliAODVertex *mainV=GetPrimaryVertexSPD();
if(!mainV) return kFALSE;
Int_t nc1=mainV->GetNContributors();
if(nc1<1) return kFALSE;
Int_t nPileVert=GetNumberOfPileupVerticesSPD();
if(nPileVert==0) return kFALSE;
Int_t nVertices=GetNumberOfVertices();
for(Int_t iVert=0; iVert<nVertices; iVert++){
AliAODVertex *pv=GetVertex(iVert);
if(pv->GetType()!=AliAODVertex::kPileupSPD) continue;
Int_t nc2=pv->GetNContributors();
if(nc2>=minContributors){
Double_t z1=mainV->GetZ();
Double_t z2=pv->GetZ();
Double_t distZ=TMath::Abs(z2-z1);
Double_t distZdiam=TMath::Abs(z2-GetDiamondZ());
Double_t cutZdiam=nSigmaDiamZ*TMath::Sqrt(GetSigma2DiamondZ());
if(GetSigma2DiamondZ()<0.0001)cutZdiam=99999.;
if(distZ>minZdist && distZdiam<cutZdiam){
Double_t x2=pv->GetX();
Double_t y2=pv->GetY();
Double_t distXdiam=TMath::Abs(x2-GetDiamondX());
Double_t distYdiam=TMath::Abs(y2-GetDiamondY());
Double_t cov1[6],cov2[6];
mainV->GetCovarianceMatrix(cov1);
pv->GetCovarianceMatrix(cov2);
Double_t errxDist=TMath::Sqrt(cov2[0]+GetSigma2DiamondX());
Double_t erryDist=TMath::Sqrt(cov2[2]+GetSigma2DiamondY());
Double_t errzDist=TMath::Sqrt(cov1[5]+cov2[5]);
Double_t cutXdiam=nSigmaDiamXY*errxDist;
if(GetSigma2DiamondX()<0.0001)cutXdiam=99999.;
Double_t cutYdiam=nSigmaDiamXY*erryDist;
if(GetSigma2DiamondY()<0.0001)cutYdiam=99999.;
if( (distXdiam<cutXdiam) && (distYdiam<cutYdiam) && (distZ>nSigmaZdist*errzDist) ){
return kTRUE;
}
}
}
}
return kFALSE;
}
void AliAODEvent::Print(Option_t *) const
{
TIter next(fAODObjects);
TNamed *el;
Printf(">>>>> AOD Content <<<<<");
while((el=(TNamed*)next())){
Printf(">> %s ",el->GetName());
}
Printf(">>>>> <<<<<");
return;
}
void AliAODEvent::AssignIDtoCollection(const TCollection* col)
{
TIter next(col);
TObject* obj;
while ((obj = next()))
TProcessID::AssignID(obj);
}
Bool_t AliAODEvent::IsPileupFromSPDInMultBins() const {
Int_t nTracklets=GetTracklets()->GetNumberOfTracklets();
if(nTracklets<20) return IsPileupFromSPD(3,0.8);
else if(nTracklets<50) return IsPileupFromSPD(4,0.8);
else return IsPileupFromSPD(5,0.8);
}
void AliAODEvent::Reset()
{
ClearStd();
if(fAODObjects->GetSize()>kAODListN){
for(int i = kAODListN;i < fAODObjects->GetSize();++i){
TObject *pObject = fAODObjects->At(i);
if(pObject->InheritsFrom(TClonesArray::Class())){
((TClonesArray*)pObject)->Delete();
}
else if(!pObject->InheritsFrom(TCollection::Class())){
TClass *pClass = TClass::GetClass(pObject->ClassName());
if (pClass && pClass->GetListOfMethods()->FindObject("Clear")) {
AliDebug(1, Form("Clear for object %s class %s", pObject->GetName(), pObject->ClassName()));
pObject->Clear();
}
else {
AliDebug(1, Form("ResetWithPlacementNew for object %s class %s", pObject->GetName(), pObject->ClassName()));
Long_t dtoronly = TObject::GetDtorOnly();
TObject::SetDtorOnly(pObject);
delete pObject;
pClass->New(pObject);
TObject::SetDtorOnly((void*)dtoronly);
}
}
else{
AliWarning(Form("No reset for %s \n",
pObject->ClassName()));
}
}
}
}
Float_t AliAODEvent::GetVZEROEqMultiplicity(Int_t i) const
{
if (!fAODVZERO || !fHeader) return -1;
Int_t ring = i/8;
Float_t factorSum = 0;
for(Int_t j = 8*ring; j < (8*ring+8); ++j) {
factorSum += fHeader->GetVZEROEqFactors(j);
}
Float_t factor = fHeader->GetVZEROEqFactors(i)*8./factorSum;
return (fAODVZERO->GetMultiplicity(i)/factor);
}
void AliAODEvent::SetTOFHeader(const AliTOFHeader *header)
{
if (fTOFHeader) {
*fTOFHeader=*header;
}
else {
fTOFHeader = new AliTOFHeader(*header);
}
}
AliAODHMPIDrings *AliAODEvent::GetHMPIDringForTrackID(Int_t trackID) const
{
if(GetHMPIDrings())
{
for(Int_t ien = 0 ; ien < GetNHMPIDrings(); ien++)
{
if( GetHMPIDring(ien)->GetHmpTrkID() == trackID ) return GetHMPIDring(ien);
}
}
return 0;
}
Int_t AliAODEvent::GetNHMPIDrings() const
{
if ( fHMPIDrings) return fHMPIDrings->GetEntriesFast();
else return -1;
}
AliAODHMPIDrings *AliAODEvent::GetHMPIDring(Int_t nRings) const
{
if(fHMPIDrings) {
if( (AliAODHMPIDrings*)fHMPIDrings->UncheckedAt(nRings) ) {
return (AliAODHMPIDrings*)fHMPIDrings->UncheckedAt(nRings);
}
else return 0x0;
}
else return 0x0;
}
AliAODTrdTrack& AliAODEvent::AddTrdTrack(const AliVTrdTrack *track) {
return *(new ((*fTrdTracks)[fTrdTracks->GetEntriesFast()]) AliAODTrdTrack(*track));
}
void AliAODEvent::ConnectTracks() {
if (fTracksConnected || !fTracks || !fTracks->GetEntriesFast()) return;
AliAODTrack *track = 0;
track = dynamic_cast<AliAODTrack*>(GetTrack(0));
if(!track) {
AliWarning("Not an AliAODTrack, this is not a standard AOD");
return;
}
TIter next(fTracks);
while ((track=(AliAODTrack*)next())) track->SetAODEvent(this);
fTracksConnected = kTRUE;
}
AliVEvent::EDataLayoutType AliAODEvent::GetDataLayoutType() const {return AliVEvent::kAOD;}