#include "AliESDFMD.h"
#include "AliESD.h"
#include "AliESDMuonTrack.h"
+#include "AliESDMuonCluster.h"
+#include "AliESDMuonPad.h"
#include "AliESDPmdTrack.h"
#include "AliESDTrdTrack.h"
#include "AliESDVertex.h"
#include "AliESDcascade.h"
#include "AliESDPmdTrack.h"
+#include "AliESDTrdTrigger.h"
#include "AliESDTrdTrack.h"
#include "AliESDTrdTracklet.h"
#include "AliESDVertex.h"
#include "AliESDACORDE.h"
#include "AliESDHLTDecision.h"
#include "AliCentrality.h"
+#include "AliESDCosmicTrack.h"
+#ifdef MFT_UPGRADE
+#include "AliESDMFT.h"
+#endif
#include "AliEventplane.h"
+
ClassImp(AliESDEvent)
"TrkPileupVertices",
"Tracks",
"MuonTracks",
+ "MuonClusters",
+ "MuonPads",
"PmdTracks",
+ "AliESDTrdTrigger",
"TrdTracks",
"TrdTracklets",
"V0s",
"PHOSCells",
"AliRawDataErrorLogs",
"AliESDACORDE",
- "AliTOFHeader"};
+ "AliTOFHeader",
+ "CosmicTracks"
+ #ifdef MFT_UPGRADE
+// , "AliESDMFT"
+ #endif
+ };
//______________________________________________________________________________
AliESDEvent::AliESDEvent():
fPHOSTrigger(0),
fEMCALTrigger(0),
fESDACORDE(0),
+ fTrdTrigger(0),
fSPDPileupVertices(0),
fTrkPileupVertices(0),
fTracks(0),
fMuonTracks(0),
+ fMuonClusters(0),
+ fMuonPads(0),
fPmdTracks(0),
fTrdTracks(0),
fTrdTracklets(0),
fKinks(0),
fCaloClusters(0),
fEMCALCells(0), fPHOSCells(0),
+ fCosmicTracks(0),
fErrorLogs(0),
+ fOldMuonStructure(kFALSE),
fESDOld(0),
fESDFriendOld(0),
fConnected(kFALSE),
fUseOwnList(kFALSE),
fTOFHeader(0),
fCentrality(0),
- fEventplane(0)
+ fEventplane(0),
+ fDetectorStatus(0xFFFFFFFF)
+ #ifdef MFT_UPGRADE
+// , fESDMFT(0)
+ #endif
{
}
//______________________________________________________________________________
fPHOSTrigger(new AliESDCaloTrigger(*esd.fPHOSTrigger)),
fEMCALTrigger(new AliESDCaloTrigger(*esd.fEMCALTrigger)),
fESDACORDE(new AliESDACORDE(*esd.fESDACORDE)),
+ fTrdTrigger(new AliESDTrdTrigger(*esd.fTrdTrigger)),
fSPDPileupVertices(new TClonesArray(*esd.fSPDPileupVertices)),
fTrkPileupVertices(new TClonesArray(*esd.fTrkPileupVertices)),
fTracks(new TClonesArray(*esd.fTracks)),
fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
+ fMuonClusters(new TClonesArray(*esd.fMuonClusters)),
+ fMuonPads(new TClonesArray(*esd.fMuonPads)),
fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
fTrdTracklets(new TClonesArray(*esd.fTrdTracklets)),
fCaloClusters(new TClonesArray(*esd.fCaloClusters)),
fEMCALCells(new AliESDCaloCells(*esd.fEMCALCells)),
fPHOSCells(new AliESDCaloCells(*esd.fPHOSCells)),
+ fCosmicTracks(new TClonesArray(*esd.fCosmicTracks)),
fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
+ fOldMuonStructure(esd.fOldMuonStructure),
fESDOld(esd.fESDOld ? new AliESD(*esd.fESDOld) : 0),
fESDFriendOld(esd.fESDFriendOld ? new AliESDfriend(*esd.fESDFriendOld) : 0),
fConnected(esd.fConnected),
fUseOwnList(esd.fUseOwnList),
fTOFHeader(new AliTOFHeader(*esd.fTOFHeader)),
fCentrality(new AliCentrality(*esd.fCentrality)),
- fEventplane(new AliEventplane(*esd.fEventplane))
+ fEventplane(new AliEventplane(*esd.fEventplane)),
+ fDetectorStatus(esd.fDetectorStatus)
+ #ifdef MFT_UPGRADE
+// , fESDMFT(new AliESDMFT(*esd.fESDMFT))
+ #endif
+
+
{
+ printf("copying ESD event...\n"); // AU
// CKB init in the constructor list and only add here ...
AddObject(fESDRun);
AddObject(fHeader);
AddObject(fSPDMult);
AddObject(fPHOSTrigger);
AddObject(fEMCALTrigger);
+ AddObject(fTrdTrigger);
AddObject(fSPDPileupVertices);
AddObject(fTrkPileupVertices);
AddObject(fTracks);
AddObject(fCaloClusters);
AddObject(fEMCALCells);
AddObject(fPHOSCells);
+ AddObject(fCosmicTracks);
AddObject(fErrorLogs);
AddObject(fESDACORDE);
AddObject(fTOFHeader);
-
+ AddObject(fMuonClusters);
+ AddObject(fMuonPads);
+ #ifdef MFT_UPGRADE
+// AddObject(fESDMFT);
+ #endif
GetStdContent();
}
else if(its->InheritsFrom("TClonesArray")){
// Create or expand the tclonesarray pointers
// so we can directly copy to the object
- TClonesArray *its_tca = (TClonesArray*)its;
- TClonesArray *mine_tca = (TClonesArray*)mine;
+ TClonesArray *itstca = (TClonesArray*)its;
+ TClonesArray *minetca = (TClonesArray*)mine;
// this leaves the capacity of the TClonesArray the same
// except for a factor of 2 increase when size > capacity
// does not release any memory occupied by the tca
- mine_tca->ExpandCreate(its_tca->GetEntriesFast());
- for(int i = 0;i < its_tca->GetEntriesFast();++i){
+ minetca->ExpandCreate(itstca->GetEntriesFast());
+ for(int i = 0;i < itstca->GetEntriesFast();++i){
// copy
- TObject *mine_tca_obj = mine_tca->At(i);
- TObject *its_tca_obj = its_tca->At(i);
+ TObject *minetcaobj = minetca->At(i);
+ TObject *itstcaobj = itstca->At(i);
// no need to delete first
// pointers within the class should be handled by Copy()...
// Can there be Empty slots?
- its_tca_obj->Copy(*mine_tca_obj);
+ itstcaobj->Copy(*minetcaobj);
}
}
else{
}
}
+ fOldMuonStructure = source.fOldMuonStructure;
+
fCentrality = source.fCentrality;
fEventplane = source.fEventplane;
fConnected = source.fConnected;
fUseOwnList = source.fUseOwnList;
+
+ fDetectorStatus = source.fDetectorStatus;
return *this;
}
}
Bool_t AliESDEvent::ResetWithPlacementNew(TObject *pObject){
+ //
+ // funtion to reset using the already allocated space
+ //
Long_t dtoronly = TObject::GetDtorOnly();
TClass *pClass = TClass::GetClass(pObject->ClassName());
TObject::SetDtorOnly(pObject);
new (fTOFHeader) AliTOFHeader();
//fTOFHeader->SetName(fgkESDListName[kTOFHeader]);
}
+ if (fTrdTrigger) {
+ fTrdTrigger->~AliESDTrdTrigger();
+ new (fTrdTrigger) AliESDTrdTrigger();
+ }
+ #ifdef MFT_UPGRADE
+ //if(fESDMFT){
+// fESDMFT->~AliESDMFT();
+// new (fESDMFT) AliESDMFT();
+ // }
+ #endif
+
if(fPHOSTrigger)fPHOSTrigger->DeAllocate();
if(fEMCALTrigger)fEMCALTrigger->DeAllocate();
if(fSPDPileupVertices)fSPDPileupVertices->Delete();
if(fTrkPileupVertices)fTrkPileupVertices->Delete();
if(fTracks)fTracks->Delete();
- if(fMuonTracks)fMuonTracks->Delete();
+ if(fMuonTracks)fMuonTracks->Clear("C");
+ if(fMuonClusters)fMuonClusters->Clear("C");
+ if(fMuonPads)fMuonPads->Clear("C");
if(fPmdTracks)fPmdTracks->Delete();
if(fTrdTracks)fTrdTracks->Delete();
if(fTrdTracklets)fTrdTracklets->Delete();
if(fCaloClusters)fCaloClusters->Delete();
if(fPHOSCells)fPHOSCells->DeleteContainer();
if(fEMCALCells)fEMCALCells->DeleteContainer();
+ if(fCosmicTracks)fCosmicTracks->Delete();
if(fErrorLogs) fErrorLogs->Delete();
// don't reset fconnected fConnected and the list
printf(" CaloClusters %d\n", GetNumberOfCaloClusters());
printf(" FMD %s\n", (fESDFMD ? "yes" : "no"));
printf(" VZERO %s\n", (fESDVZERO ? "yes" : "no"));
+ printf(" muClusters %d\n", fMuonClusters ? fMuonClusters->GetEntriesFast() : 0);
+ printf(" muPad %d\n", fMuonPads ? fMuonPads->GetEntriesFast() : 0);
+ if (fCosmicTracks) printf(" Cosmics %d\n", GetNumberOfCosmicTracks());
+ #ifdef MFT_UPGRADE
+ //printf(" MFT %s\n", (fESDMFT ? "yes" : "no"));
+ #endif
+
+
TObject* pHLTDecision=GetHLTTriggerDecision();
printf("HLT trigger decision: %s\n", pHLTDecision?pHLTDecision->GetOption():"not available");
if (pHLTDecision) pHLTDecision->Print("compact");
for (Int_t i=0; i<ntrk; i++) {
const AliESDfriendTrack *f=ev->GetTrack(i);
+ if (!f) {AliFatal(Form("NULL pointer for ESD track %d",i));}
GetTrack(i)->SetFriendTrack(f);
}
}
if (rm==last) return kTRUE;
AliESDtrack *t=GetTrack(last);
+ if (!t) {AliFatal(Form("NULL pointer for ESD track %d",last));}
t->SetID(rm);
new (a[rm]) AliESDtrack(*t);
delete a.RemoveAt(last);
Int_t nTracks=GetNumberOfTracks();
for (Int_t i=nTracks-1; i>=0; i--) {
AliESDtrack *track=GetTrack(i);
+ if (!track) {AliFatal(Form("NULL pointer for ESD track %d",i));}
Float_t xy,z; track->GetImpactParameters(xy,z);
if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
if (RemoveTrack(i)) rc=kTRUE;
return track;
}
- void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t)
+//______________________________________________________________________________
+Bool_t AliESDEvent::MoveMuonObjects()
+{
+ // move MUON clusters and pads to the new ESD structure in needed.
+ // to ensure backward compatibility
+
+ if (!fOldMuonStructure) return kTRUE;
+
+ if (!fMuonTracks || !fMuonClusters || !fMuonPads) return kFALSE;
+
+ Bool_t reset = kTRUE;
+ Bool_t containTrackerData = kFALSE;
+ for (Int_t i = 0; i < fMuonTracks->GetEntriesFast(); i++) {
+
+ AliESDMuonTrack *track = (AliESDMuonTrack*) fMuonTracks->UncheckedAt(i);
+
+ if (track->ContainTrackerData()) containTrackerData = kTRUE;
+ else continue;
+
+ if (!track->IsOldTrack()) continue;
+
+ // remove objects connected to previous event if needed
+ if (reset) {
+ if (fMuonClusters->GetEntriesFast() > 0) fMuonClusters->Clear("C");
+ if (fMuonPads->GetEntriesFast() > 0) fMuonPads->Clear("C");
+ reset = kFALSE;
+ }
+
+ track->MoveClustersToESD(*this);
+
+ }
+
+ // remove objects connected to previous event if needed
+ if (!containTrackerData) {
+ if (fMuonClusters->GetEntriesFast() > 0) fMuonClusters->Clear("C");
+ if (fMuonPads->GetEntriesFast() > 0) fMuonPads->Clear("C");
+ }
+
+ return kTRUE;
+}
+
+//______________________________________________________________________________
+AliESDMuonTrack* AliESDEvent::GetMuonTrack(Int_t i)
+{
+ // get the MUON track at the position i in the internal array of track
+ if (!fMuonTracks) return 0x0;
+ if (!MoveMuonObjects()) return 0x0;
+ AliESDMuonTrack *track = (AliESDMuonTrack*) fMuonTracks->UncheckedAt(i);
+ track->SetESDEvent(this);
+ return track;
+}
+
+//______________________________________________________________________________
+void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t)
+{
+ // add a MUON track
+ TClonesArray &fmu = *fMuonTracks;
+ AliESDMuonTrack *track = new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
+ track->MoveClustersToESD(*this);
+}
+
+//______________________________________________________________________________
+AliESDMuonTrack* AliESDEvent::NewMuonTrack()
+{
+ // create a new MUON track at the end of the internal array of track
+ TClonesArray &fmu = *fMuonTracks;
+ return new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack();
+}
+
+//______________________________________________________________________________
+Int_t AliESDEvent::GetNumberOfMuonClusters()
+{
+ // get the number of MUON clusters
+ if (!fMuonClusters) return 0;
+ if (!MoveMuonObjects()) return 0;
+ return fMuonClusters->GetEntriesFast();
+}
+
+//______________________________________________________________________________
+AliESDMuonCluster* AliESDEvent::GetMuonCluster(Int_t i)
{
- TClonesArray &fmu = *fMuonTracks;
- new(fmu[fMuonTracks->GetEntriesFast()]) AliESDMuonTrack(*t);
+ // get the MUON cluster at the position i in the internal array of cluster
+ if (!fMuonClusters) return 0x0;
+ if (!MoveMuonObjects()) return 0x0;
+ return (AliESDMuonCluster*) fMuonClusters->UncheckedAt(i);
+}
+
+//______________________________________________________________________________
+AliESDMuonCluster* AliESDEvent::FindMuonCluster(UInt_t clusterId)
+{
+ // find the MUON cluster with this Id in the internal array of cluster
+ if (!fMuonClusters) return 0x0;
+ if (!MoveMuonObjects()) return 0x0;
+ for (Int_t i = 0; i < fMuonClusters->GetEntriesFast(); i++) {
+ AliESDMuonCluster *cluster = (AliESDMuonCluster*) fMuonClusters->UncheckedAt(i);
+ if (cluster->GetUniqueID() == clusterId) return cluster;
+ }
+ return 0x0;
+}
+
+//______________________________________________________________________________
+AliESDMuonCluster* AliESDEvent::NewMuonCluster()
+{
+ // create a new MUON cluster at the end of the internal array of cluster
+ TClonesArray &fmu = *fMuonClusters;
+ return new(fmu[fMuonClusters->GetEntriesFast()]) AliESDMuonCluster();
+}
+
+//______________________________________________________________________________
+Int_t AliESDEvent::GetNumberOfMuonPads()
+{
+ // get the number of MUON pads
+ if (!fMuonPads) return 0;
+ if (!MoveMuonObjects()) return 0;
+ return fMuonPads->GetEntriesFast();
+}
+
+//______________________________________________________________________________
+AliESDMuonPad* AliESDEvent::GetMuonPad(Int_t i)
+{
+ // get the MUON pad at the position i in the internal array of pad
+ if (!fMuonPads) return 0x0;
+ if (!MoveMuonObjects()) return 0x0;
+ return (AliESDMuonPad*) fMuonPads->UncheckedAt(i);
+}
+
+//______________________________________________________________________________
+AliESDMuonPad* AliESDEvent::FindMuonPad(UInt_t padId)
+{
+ // find the MUON pad with this Id in the internal array of pad
+ if (!fMuonPads) return 0x0;
+ if (!MoveMuonObjects()) return 0x0;
+ for (Int_t i = 0; i < fMuonPads->GetEntriesFast(); i++) {
+ AliESDMuonPad *pad = (AliESDMuonPad*) fMuonPads->UncheckedAt(i);
+ if (pad->GetUniqueID() == padId) return pad;
+ }
+ return 0x0;
+}
+
+//______________________________________________________________________________
+AliESDMuonPad* AliESDEvent::NewMuonPad()
+{
+ // create a new MUON pad at the end of the internal array of pad
+ TClonesArray &fmu = *fMuonPads;
+ return new(fmu[fMuonPads->GetEntriesFast()]) AliESDMuonPad();
}
void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t)
new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
}
+void AliESDEvent::SetTrdTrigger(const AliESDTrdTrigger *t)
+{
+ *fTrdTrigger = *t;
+}
+
void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t)
{
TClonesArray &ftrd = *fTrdTracks;
new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
}
+void AliESDEvent::AddCosmicTrack(const AliESDCosmicTrack *t)
+{
+ TClonesArray &ft = *fCosmicTracks;
+ new(ft[fCosmicTracks->GetEntriesFast()]) AliESDCosmicTrack(*t);
+}
+
Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c)
{
new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
}
-void AliESDEvent::SetZDCData(AliESDZDC * obj)
+void AliESDEvent::SetZDCData(const AliESDZDC * obj)
{
// use already allocated space
if(fESDZDC)
}
}
-void AliESDEvent::SetVZEROData(AliESDVZERO * obj)
+void AliESDEvent::SetVZEROData(const AliESDVZERO * obj)
{
// use already allocated space
if(fESDVZERO)
*fESDVZERO = *obj;
}
-void AliESDEvent::SetTZEROData(AliESDTZERO * obj)
+void AliESDEvent::SetTZEROData(const AliESDTZERO * obj)
{
// use already allocated space
if(fESDTZERO)
*fESDTZERO = *obj;
}
+#ifdef MFT_UPGRADE
+//void AliESDEvent::SetMFTData(AliESDMFT * obj)
+//{
+// if(fESDMFT)
+// *fESDMFT = *obj;
+//}
+#endif
+
void AliESDEvent::SetACORDEData(AliESDACORDE * obj)
{
if(fESDACORDE)
for (Int_t i=0; i<ntrk; i++) {
AliESDtrack *t=GetTrack(i);
+ if (!t) {AliFatal(Form("NULL pointer for ESD track %d",i));}
const AliESDfriendTrack *f=t->GetFriendTrack();
ev->AddTrack(f);
fTrkPileupVertices = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrkPileupVertices]);
fTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTracks]);
fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
+ fMuonClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonClusters]);
+ fMuonPads = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonPads]);
fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
+ fTrdTrigger = (AliESDTrdTrigger*)fESDObjects->FindObject(fgkESDListName[kTrdTrigger]);
fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
fTrdTracklets = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracklets]);
fV0s = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kV0s]);
fErrorLogs = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kErrorLogs]);
fESDACORDE = (AliESDACORDE*)fESDObjects->FindObject(fgkESDListName[kESDACORDE]);
fTOFHeader = (AliTOFHeader*)fESDObjects->FindObject(fgkESDListName[kTOFHeader]);
+ fCosmicTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCosmicTracks]);
+ #ifdef MFT_UPGRADE
+ // fESDMFT = (AliESDMFT*)fESDObjects->FindObject(fgkESDListName[kESDMFT]);
+ #endif
}
void AliESDEvent::SetStdNames(){
AddObject(new TClonesArray("AliESDVertex",0));
AddObject(new TClonesArray("AliESDtrack",0));
AddObject(new TClonesArray("AliESDMuonTrack",0));
+ AddObject(new TClonesArray("AliESDMuonCluster",0));
+ AddObject(new TClonesArray("AliESDMuonPad",0));
AddObject(new TClonesArray("AliESDPmdTrack",0));
+ AddObject(new AliESDTrdTrigger());
AddObject(new TClonesArray("AliESDTrdTrack",0));
AddObject(new TClonesArray("AliESDTrdTracklet",0));
AddObject(new TClonesArray("AliESDv0",0));
AddObject(new TClonesArray("AliRawDataErrorLog",0));
AddObject(new AliESDACORDE());
AddObject(new AliTOFHeader());
-
+ AddObject(new TClonesArray("AliESDCosmicTrack",0));
+ #ifdef MFT_UPGRADE
+ //AddObject(new AliESDMFT());
+ #endif
+
// check the order of the indices against enum...
// set names
GetStdContent();
}
+void AliESDEvent::CompleteStdContent()
+{
+ // create missing standard objects and add them to the TList of objects
+
+ // add new MUON containers if missing (for backward compatibility)
+ if (!fESDObjects->FindObject(fgkESDListName[kMuonClusters])) {
+ TClonesArray* muonClusters = new TClonesArray("AliESDMuonCluster",0);
+ muonClusters->SetName(fgkESDListName[kMuonClusters]);
+ fESDObjects->AddAt(muonClusters, kMuonClusters);
+ fESDObjects->SetOwner(kTRUE);
+ }
+ if (!fESDObjects->FindObject(fgkESDListName[kMuonPads])) {
+ TClonesArray* muonPads = new TClonesArray("AliESDMuonPad",0);
+ muonPads->SetName(fgkESDListName[kMuonPads]);
+ fESDObjects->AddAt(muonPads, kMuonPads);
+ fESDObjects->SetOwner(kTRUE);
+ }
+}
+
TObject* AliESDEvent::FindListObject(const char *name) const {
//
// Find object with name "name" in the list of branches
// if we find the "ESD" branch on the tree we do have the old structure
if(tree->GetBranch("ESD")) {
+ fOldMuonStructure = kFALSE;
char ** address = (char **)(tree->GetBranch("ESD")->GetAddress());
// do we have the friend branch
TBranch * esdFB = tree->GetBranch("ESDfriend.");
fESDObjects->Delete();
fESDObjects = connectedList;
GetStdContent();
+ fOldMuonStructure = fESDObjects->TestBit(BIT(23));
fConnected = true;
return;
}
// in principle
// we only need new things in the list if we do no already have it..
// TODO just add new entries
+ CompleteStdContent();
if(fESDObjects->GetEntries()<kESDListN){
AliWarning(Form("AliESDEvent::ReadFromTree() TList contains less than the standard contents %d < %d \n",
fESDObjects->GetEntries(),kESDListN));
}
// set the branch addresses
+ fOldMuonStructure = kFALSE;
TIter next(fESDObjects);
TNamed *el;
while((el=(TNamed*)next())){
}
else{
AliWarning(Form("AliESDEvent::ReadFromTree() No Branch found with Name %s or %s.",bname.Data(),bname.Data()));
+ if (bname == fgkESDListName[kMuonClusters]) {
+ fOldMuonStructure = kTRUE;
+ }
}
}
// must not delete it
fESDObjects->SetOwner(kTRUE);
fESDObjects->SetName("ESDObjectsConnectedToTree");
+ fESDObjects->SetBit(BIT(23), fOldMuonStructure);
// we are not owner of the list objects
// must not delete it
tree->GetUserInfo()->Add(fESDObjects);
// we can't get the list from the user data, create standard content
// and set it by hand (no ESDfriend at the moment
CreateStdContent();
+ fOldMuonStructure = kFALSE;
TIter next(fESDObjects);
TNamed *el;
while((el=(TNamed*)next())){
if(br){
tree->SetBranchAddress(Form("%s.",bname.Data()),fESDObjects->GetObjectRef(el));
}
+ else if (bname == fgkESDListName[kMuonClusters]) {
+ fOldMuonStructure = kTRUE;
+ }
}
}
GetStdContent();
for(int i = 0;i<fESDOld->GetNumberOfCaloClusters();i++){
AddCaloCluster(fESDOld->GetCaloCluster(i));
}
+
+ #ifdef MFT_UPGRADE
+ // MFT
+// if (fESDOld->GetMFTData()) SetMFTData(fESDOld->GetMFTData());
+ #endif
}// if fesdold
}
// trITSSApure : using ITS standalone tracks + tracklets from clusters not used by tracks
// if useDCAFlag is true: account for the ESDtrack flag marking the tracks with large DCA
// if useV0Flag is true: account for the ESDtrack flag marking conversion and K0's V0s
+
+ AliWarning("This obsolete method will be eliminated soon. Use AliESDtrackCuts::GetReferenceMultiplicity");
+
tracklets = trITSSApure = trITSTPC = 0;
int ntr = fSPDMult ? fSPDMult->GetNumberOfTracklets() : 0;
//
ntr = GetNumberOfTracks();
for (int itr=ntr;itr--;) {
AliESDtrack *t = GetTrack(itr);
+ if (!t) {AliFatal(Form("NULL pointer for ESD track %d",itr));}
if (TMath::Abs(t->Eta())>eta) continue;
if (!t->IsOn(AliESDtrack::kITSin)) continue;
if (useDCAFlag && t->IsOn(AliESDtrack::kMultSec)) continue;
if (!fEventplane) fEventplane = new AliEventplane();
return fEventplane;
}
+
+Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const
+{
+ // Get VZERO Multiplicity for channel i
+ // Themethod uses the equalization factors
+ // stored in the ESD-run object in order to
+ // get equal multiplicities within a VZERO rins (1/8 of VZERO)
+ if (!fESDVZERO || !fESDRun) return -1;
+
+ Int_t ring = i/8;
+ Float_t factorSum = 0;
+ for(Int_t j = 8*ring; j < (8*ring+8); ++j) {
+ factorSum += fESDRun->GetVZEROEqFactors(j);
+ }
+ Float_t factor = fESDRun->GetVZEROEqFactors(i)*8./factorSum;
+
+ return (fESDVZERO->GetMultiplicity(i)/factor);
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff