**************************************************************************/
#include "AliEveEventManager.h"
+#include "AliEveEventSelector.h"
#include "AliEveMacroExecutor.h"
#include <TEveManager.h>
+#include <TEveViewer.h>
#include <AliRunLoader.h>
#include <AliRun.h>
+#include <AliESDRun.h>
#include <AliESDEvent.h>
#include <AliESDfriend.h>
+#include <AliAODEvent.h>
+
#include <AliDAQ.h>
#include <AliRawEventHeaderBase.h>
#include <AliRawReaderRoot.h>
#include <AliRawReaderFile.h>
#include <AliRawReaderDate.h>
-#include <AliMagFMaps.h>
+#include <AliMagF.h>
#include <AliCDBManager.h>
#include <AliCDBStorage.h>
+#include <AliGRPObject.h>
#include <AliHeader.h>
#include <AliGeomManager.h>
+#include <AliGRPManager.h>
+#include <AliSysInfo.h>
#include <TFile.h>
#include <TTree.h>
#include <TGeoManager.h>
+#include <TGeoGlobalMagField.h>
#include <TSystem.h>
#include <TTimeStamp.h>
+#include <TPRegexp.h>
+#include <TError.h>
+#include <TEnv.h>
//==============================================================================
//==============================================================================
//______________________________________________________________________________
//
// Provides interface for loading and navigating standard AliRoot data
-// (AliRunLoader), ESDs and RAW.
+// (AliRunLoader), ESD, AOD and RAW.
+//
+// ESDfriend is attached automatically, if the file is found.
+//
+// AODfriends are not attached automatically as there are several
+// possible files involved. To have a specific AODfriend attached, call
+// static method
+// AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
+// before initializing the event-manager.
//
// Also provides interface to magnetic-field and geometry. Mostly
// intended as wrappers over standard AliRoot functionality for
Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
Bool_t AliEveEventManager::fgAssertESD = kFALSE;
+Bool_t AliEveEventManager::fgAssertAOD = kFALSE;
Bool_t AliEveEventManager::fgAssertRaw = kFALSE;
TString AliEveEventManager::fgESDFileName("AliESDs.root");
+TString AliEveEventManager::fgAODFileName("AliAOD.root");
TString AliEveEventManager::fgRawFileName("raw.root");
-TString AliEveEventManager::fgCdbUri("local://$ALICE_ROOT");
+TString AliEveEventManager::fgCdbUri;
-AliMagF* AliEveEventManager::fgMagField = 0;
+TList* AliEveEventManager::fgAODfriends = 0;
+
+Bool_t AliEveEventManager::fgGRPLoaded = kFALSE;
+AliMagF* AliEveEventManager::fgMagField = 0;
+Bool_t AliEveEventManager::fgUniformField = kFALSE;
AliEveEventManager* AliEveEventManager::fgMaster = 0;
AliEveEventManager* AliEveEventManager::fgCurrent = 0;
fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
fExecutor = new AliEveMacroExecutor;
+
+ fTransients = new TEveElementList("Transients", "Transient per-event elements.");
+ fTransients->IncDenyDestroy();
+ gEve->AddToListTree(fTransients, kFALSE);
+
+ fTransientLists = new TEveElementList("Transient Lists", "Containers of transient elements.");
+ fTransientLists->IncDenyDestroy();
+ gEve->AddToListTree(fTransientLists, kFALSE);
+
+ fPEventSelector = new AliEveEventSelector(this);
}
AliEveEventManager::AliEveEventManager(const TString& name) :
fRunLoader (0),
fESDFile (0), fESDTree (0), fESD (0),
fESDfriend (0), fESDfriendExists(kFALSE),
+ fAODFile (0), fAODTree (0), fAOD (0),
fRawReader (0),
fAutoLoad (kFALSE), fAutoLoadTime (5.), fAutoLoadTimer(0),
fIsOpen (kFALSE), fHasEvent (kFALSE), fExternalCtrl (kFALSE),
- fSelectOnTriggerType(kFALSE), fTriggerType(""),
- fExecutor (0),
+ fExecutor (0), fTransients(0), fTransientLists(0),
+ fPEventSelector(0),
fSubManagers (0),
fAutoLoadTimerRunning(kFALSE)
{
fRunLoader (0),
fESDFile (0), fESDTree (0), fESD (0),
fESDfriend (0), fESDfriendExists(kFALSE),
+ fAODFile (0), fAODTree (0), fAOD (0),
fRawReader (0),
fAutoLoad (kFALSE), fAutoLoadTime (5), fAutoLoadTimer(0),
fIsOpen (kFALSE), fHasEvent (kFALSE), fExternalCtrl (kFALSE),
- fSelectOnTriggerType(kFALSE), fTriggerType(""),
- fExecutor (0),
+ fExecutor (0), fTransients(0), fTransientLists(0),
+ fPEventSelector(0),
fSubManagers (0),
fAutoLoadTimerRunning(kFALSE)
{
{
Close();
}
+
+ fTransients->DecDenyDestroy();
+ fTransients->Destroy();
+
+ fTransientLists->DecDenyDestroy();
+ fTransientLists->Destroy();
}
/******************************************************************************/
if ( ! esd.IsNull()) fgESDFileName = esd;
}
+void AliEveEventManager::SetAODFileName(const TString& aod)
+{
+ // Set file-name for opening AOD, default "AliAOD.root".
+
+ if ( ! aod.IsNull()) fgAODFileName = aod;
+}
+
+void AliEveEventManager::AddAODfriend(const TString& friendFileName)
+{
+ // Add new AOD friend file-name to be attached when opening AOD.
+ // This should include '.root', as in 'AliAOD.VertexingHF.root'.
+
+ if (fgAODfriends == 0)
+ {
+ fgAODfriends = new TList;
+ fgAODfriends->SetOwner(kTRUE);
+ }
+ if (fgAODfriends->FindObject(friendFileName) == 0)
+ {
+ fgAODfriends->Add(new TObjString(friendFileName));
+ }
+}
+
void AliEveEventManager::SetRawFileName(const TString& raw)
{
// Set file-name for opening of raw-data, default "raw.root"
void AliEveEventManager::SetCdbUri(const TString& cdb)
{
- // Set path to CDB, default "local://$ALICE_ROOT".
+ // Set path to CDB, there is no default.
if ( ! cdb.IsNull()) fgCdbUri = cdb;
}
-void AliEveEventManager::SetAssertElements(Bool_t assertRunloader,
- Bool_t assertEsd,
- Bool_t assertRaw)
+void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
+ Bool_t assertAod, Bool_t assertRaw)
{
// Set global flags that detrmine which parts of the event-data must
// be present when the event is opened.
fgAssertRunLoader = assertRunloader;
fgAssertESD = assertEsd;
+ fgAssertAOD = assertAod;
fgAssertRaw = assertRaw;
}
}
}
+ // Open AOD and registered friends
+
+ TString aodPath(Form("%s/%s", fPath.Data(), fgAODFileName.Data()));
+ if ((fAODFile = TFile::Open(aodPath)))
+ {
+ fAOD = new AliAODEvent();
+ fAODTree = (TTree*) fAODFile->Get("aodTree");
+ if (fAODTree != 0)
+ {
+ // Check if AODfriends exist and attach them.
+ TIter friends(fgAODfriends);
+ TObjString *name;
+ while ((name = (TObjString*) friends()) != 0)
+ {
+ TString p(Form("%s/%s", fPath.Data(), name->GetName()));
+ if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
+ {
+ fAODTree->AddFriend("aodTree", name->GetName());
+ }
+ }
+
+ fAOD->ReadFromTree(fAODTree);
+
+ if (fAODTree->GetEntry(0) <= 0)
+ {
+ delete fAODFile; fAODFile = 0;
+ delete fAOD; fAOD = 0;
+ Warning(kEH, "failed getting the first entry from addTree.");
+ }
+ else
+ {
+ if (runNo < 0)
+ runNo = fAOD->GetRunNumber();
+ }
+ }
+ else // aodtree == 0
+ {
+ delete fAODFile; fAODFile = 0;
+ delete fAOD; fAOD = 0;
+ Warning(kEH, "failed getting the aodTree.");
+ }
+ }
+ else // aod not readable
+ {
+ Warning(kEH, "can not read AOD file '%s'.", aodPath.Data());
+ }
+ if (fAODTree == 0)
+ {
+ if (fgAssertAOD)
+ {
+ throw (kEH + "AOD not initialized. Its precence was requested.");
+ } else {
+ Warning(kEH, "AOD not initialized.");
+ }
+ }
+
// Open RunLoader from galice.root
TString gaPath(Form("%s/galice.root", fPath.Data()));
// If i use open directly, we get fatal.
// Is AccessPathName check ok for xrootd / alien? Yes, not for http.
- if (gSystem->AccessPathName(gaPath, kReadPermission) == kFALSE)
- {
+ // Seems not to work for alien anymore.
+ TFile *gafile = TFile::Open(gaPath);
+ if (gafile)
+ {
+ gafile->Close();
+ delete gafile;
+ // if (gSystem->AccessPathName(gaPath, kReadPermission) == kFALSE)
+ // {
fRunLoader = AliRunLoader::Open(gaPath, GetName());
if (fRunLoader)
{
}
}
+ // Initialize OCDB ... only in master event-manager
+
if (this == fgMaster)
{
AliCDBManager* cdb = AliCDBManager::Instance();
}
else
{
- cdb->SetDefaultStorage(fgCdbUri);
+ if (fgCdbUri.IsNull())
+ {
+ gEnv->SetValue("Root.Stacktrace", "no");
+ Fatal("Open()", "OCDB path was not specified.");
+ }
+
+ // Handle some special cases for MC (should be in OCDBManager).
+ if (fgCdbUri == "mcideal://")
+ cdb->SetDefaultStorage("MC", "Ideal");
+ else if (fgCdbUri == "mcresidual://")
+ cdb->SetDefaultStorage("MC", "Residual");
+ else if (fgCdbUri == "mcfull://")
+ cdb->SetDefaultStorage("MC", "Full");
+ else if (fgCdbUri == "local://") {
+ fgCdbUri = "local://$ALICE_ROOT/OCDB";
+ cdb->SetDefaultStorage(fgCdbUri);
+ } else
+ cdb->SetDefaultStorage(fgCdbUri);
if (cdb->IsDefaultStorageSet() == kFALSE)
- throw (kEH + "CDB initialization failed.");
+ throw kEH + "CDB initialization failed for '" + fgCdbUri + "'.";
+ }
+
+ if (fgCdbUri.BeginsWith("local://"))
+ {
+ TString grp = "GRP/GRP/Data";
+ TString grppath = fPath + "/" + grp;
+ if (gSystem->AccessPathName(grppath, kReadPermission) == kFALSE)
+ {
+ if (cdb->GetSpecificStorage(grp))
+ {
+ Warning(kEH, "Local GRP exists, but the specific storage is already set.");
+ }
+ else
+ {
+ Info(kEH, "Setting CDB specific-storage for GRP from event directory.");
+ TString lpath("local://");
+ lpath += fPath;
+ cdb->SetSpecificStorage(grp, lpath);
+ }
+ }
}
cdb->SetRun(runNo);
}
fIsOpen = kTRUE;
}
-void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd)
+void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf)
{
- // Set an event from an external source
- // The method is used in the online visualisation
+ // Set an event from an external source.
+ // The method is used in the online visualisation.
+ // AOD is not supported.
static const TEveException kEH("AliEveEventManager::SetEvent ");
fRunLoader = runLoader;
fRawReader = rawReader;
fESD = esd;
+ fESDfriend = esdf;
+ fAOD = 0;
fEventId++;
fHasEvent = kTRUE;
// fESDTree->Refresh();
return fESDTree->GetEntries() - 1;
}
+ else if (fAODTree)
+ {
+ return fAODTree->GetEntries() - 1;
+ }
else if (fRunLoader)
{
return fRunLoader->GetNumberOfEvents() - 1;
}
else
{
- throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
+ throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
}
}
if (event < 0)
event = fESDTree->GetEntries() + event;
}
+ else if (fAODTree)
+ {
+ maxEvent = fAODTree->GetEntries() - 1;
+ if (event < 0)
+ event = fAODTree->GetEntries() + event;
+ }
else if (fRunLoader)
{
maxEvent = fRunLoader->GetNumberOfEvents() - 1;
event, 0, maxEvent));
}
+ TString sysInfoHeader;
+ sysInfoHeader.Form("AliEveEventManager::GotoEvent(%d) - ", event);
+ AliSysInfo::AddStamp(sysInfoHeader + "Start");
+
TEveManager::TRedrawDisabler rd(gEve);
gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
// !!! MT this is somewhat brutal; at least optionally, one could be
// a bit gentler, checking for objs owning their external refs and having
// additinal parents.
+ gEve->GetViewers()->DeleteAnnotations();
+ fTransients->DestroyElements();
+ for (TEveElement::List_i i = fTransientLists->BeginChildren();
+ i != fTransientLists->EndChildren(); ++i)
+ {
+ (*i)->DestroyElements();
+ }
DestroyElements();
+ AliSysInfo::AddStamp(sysInfoHeader + "PostDestroy");
+
if (fESDTree) {
if (fESDTree->GetEntry(event) <= 0)
throw (kEH + "failed getting required event from ESD.");
fESD->SetESDfriend(fESDfriend);
}
+ if (fAODTree) {
+ if (fAODTree->GetEntry(event) <= 0)
+ throw (kEH + "failed getting required event from AOD.");
+ }
+
if (fRunLoader) {
if (fRunLoader->GetEvent(event) != 0)
throw (kEH + "failed getting required event.");
ElementChanged();
}
+ AliSysInfo::AddStamp(sysInfoHeader + "PostLoadEvent");
+
AfterNewEventLoaded();
+
+ AliSysInfo::AddStamp(sysInfoHeader + "PostUserActions");
}
void AliEveEventManager::NextEvent()
}
else
{
- Int_t nexteventbytrigger=0;
- if (fSelectOnTriggerType)
+ Int_t nextevent=0;
+ if (fPEventSelector->FindNext(nextevent))
{
- if (FindNextByTrigger(nexteventbytrigger)) //if not found do nothing
- GotoEvent(nexteventbytrigger);
+ GotoEvent(nextevent);
}
- else if (fEventId < GetMaxEventId(kTRUE))
- GotoEvent(fEventId + 1);
- else
- GotoEvent(0);
}
}
{
throw (kEH + "Event-loop is under external control.");
}
- Int_t nexteventbytrigger=0;
- if (fSelectOnTriggerType)
+ Int_t nextevent=0;
+ if (fPEventSelector->FindPrev(nextevent))
{
- if (FindPrevByTrigger(nexteventbytrigger))
- GotoEvent(nexteventbytrigger);
+ GotoEvent(nextevent);
}
- else
- GotoEvent(fEventId - 1);
}
void AliEveEventManager::Close()
delete fESDFile; fESDFile = 0;
}
+ if (fAODTree) {
+ delete fAOD; fAOD = 0;
+
+ delete fAODTree; fAODTree = 0;
+ delete fAODFile; fAODFile = 0;
+ }
+
if (fRunLoader) {
delete fRunLoader; fRunLoader = 0;
}
return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
}
+Bool_t AliEveEventManager::HasAOD()
+{
+ // Check if AliESDEvent is initialized.
+
+ return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
+}
+
Bool_t AliEveEventManager::HasRawReader()
{
// Check if raw-reader is initialized.
return fgCurrent->fESDfriend;
}
+AliAODEvent* AliEveEventManager::AssertAOD()
+{
+ // Make sure AliAODEvent is initialized and return it.
+ // Throws exception in case AOD is not available.
+ // Static utility for macros.
+
+ static const TEveException kEH("AliEveEventManager::AssertAOD ");
+
+ if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
+ throw (kEH + "ALICE event not ready.");
+ if (fgCurrent->fAOD == 0)
+ throw (kEH + "AliAOD not initialised.");
+ return fgCurrent->fAOD;
+}
+
AliRawReader* AliEveEventManager::AssertRawReader()
{
// Make sure raw-reader is initialized and return it.
return fgCurrent->fRawReader;
}
-AliMagF* AliEveEventManager::AssertMagField()
-{
- // Make sure AliMagF is initialized and returns it.
- // Run-loader must be initialized to get the correct magnetic field!
- // Throws exception in case magnetic field is not available.
- // Static utility for macros.
+//==============================================================================
- // !!!! This should be fixed ... get field also in some other way,
- // not only via run-loader.
+AliMagF* AliEveEventManager::AssertMagField()
+{
+ // Make sure AliMagF is initialized and returns it.
+ // Throws exception in case magnetic field is not available.
+ // Static utility for macros.
- static const TEveException kEH("AliEveEventManager::AssertMagField ");
+ static const TEveException kEH("AliEveEventManager::AssertMagField ");
+
+ if (fgMagField)
+ return fgMagField;
- if (fgMagField == 0)
+ if (TGeoGlobalMagField::Instance()->GetField())
{
- if (fgMaster && fgMaster->fRunLoader && fgMaster->fRunLoader->GetAliRun())
- {
- ::Info(kEH, "Retrieving magnetic field from AliRun.");
- fgMagField = fgMaster->fRunLoader->GetAliRun()->Field();
- }
- else
- {
- ::Warning(kEH, "Instantiating default magnetic field (5kG).");
- fgMagField = new AliMagFMaps("Maps","Maps", 1, 1., 10., AliMagFMaps::k5kG);
- }
+ fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
+ if (fgMagField == 0)
+ throw kEH + "Global field set, but it is not AliMagF.";
+ return fgMagField;
+ }
+
+ if (!fgGRPLoaded)
+ {
+ InitGRP();
}
- return fgMagField;
+
+ if (TGeoGlobalMagField::Instance()->GetField())
+ {
+ fgMagField = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
+ if (fgMagField == 0)
+ throw kEH + "Global field set, but it is not AliMagF.";
+ }
+ else
+ {
+ throw kEH + "Could not initialize magnetic field.";
+ }
+
+ return fgMagField;
}
TGeoManager* AliEveEventManager::AssertGeometry()
return fgCurrent;
}
+void AliEveEventManager::RegisterTransient(TEveElement* element)
+{
+ GetCurrent()->fTransients->AddElement(element);
+}
+
+void AliEveEventManager::RegisterTransientList(TEveElement* element)
+{
+ GetCurrent()->fTransientLists->AddElement(element);
+}
+
//------------------------------------------------------------------------------
// Autoloading of events
//------------------------------------------------------------------------------
}
}
+void AliEveEventManager::SetTrigSel(Int_t trig)
+{
+ static const TEveException kEH("AliEveEventManager::SetTrigSel ");
+
+ if (!fRawReader)
+ {
+ Warning(kEH, "No Raw-reader exists. Ignoring the call.");
+ return;
+ }
+ else
+ {
+ ULong64_t trigMask = 0;
+ if (trig >= 0) trigMask = (1ull << trig);
+ Info(kEH,"Trigger selection: 0x%llx",trigMask);
+ fRawReader->SelectEvents(-1,trigMask,NULL);
+ }
+}
+
void AliEveEventManager::StartAutoLoadTimer()
{
// Start the auto-load timer.
StartAutoLoadTimer();
}
-
-//------------------------------------------------------------------------------
-// Event selection by trigger
-//------------------------------------------------------------------------------
-
-Bool_t AliEveEventManager::FindNextByTrigger(Int_t& event)
-{
- // Find next event that matches the trigger.
- // If a matching event is not found, we loop around and eventually
- // end up at the same event.
-
- static const TEveException kEH("AliEveEventManager::FindNextByTrigger ");
-
- if (!fESDTree) return kFALSE;
- TString firedtrclasses;
- for (Int_t i = fEventId+1; i<GetMaxEventId(kTRUE)+1; i++)
- {
- if (fESDTree->GetEntry(i) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- firedtrclasses = fESD->GetFiredTriggerClasses();
- if (firedtrclasses.Contains(fTriggerType))
- {
- event=i;
- return kTRUE;
- }
- }
- for (Int_t i = 0; i<fEventId+1; i++)
- {
- if (fESDTree->GetEntry(i) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- firedtrclasses = fESD->GetFiredTriggerClasses();
- if (firedtrclasses.Contains(fTriggerType))
- {
- event=i;
- return kTRUE;
- }
- }
- return kFALSE;
-}
-
-Bool_t AliEveEventManager::FindPrevByTrigger(Int_t& event)
-{
- // Find previous event that matches the trigger.
-
- static const TEveException kEH("AliEveEventManager::FindPrevByTrigger ");
-
- if (!fESDTree) return kFALSE;
- TString firedtrclasses;
- for (Int_t i = fEventId-1; i>=0; i--)
- {
- if (fESDTree->GetEntry(i) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- firedtrclasses = fESD->GetFiredTriggerClasses();
- if (firedtrclasses.Contains(fTriggerType))
- {
- event=i;
- return kTRUE;
- }
- }
- for (Int_t i = GetMaxEventId(kTRUE); i>fEventId-1; i--)
- {
- if (fESDTree->GetEntry(i) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- firedtrclasses = fESD->GetFiredTriggerClasses();
- if (firedtrclasses.Contains(fTriggerType))
- {
- event=i;
- return kTRUE;
- }
- }
- return kFALSE;
-}
-
-
//------------------------------------------------------------------------------
// Post event-loading functions
//------------------------------------------------------------------------------
TIter next(fSubManagers);
while ((fgCurrent = dynamic_cast<AliEveEventManager*>(next())) != 0)
{
- // gEve->SetCurrentEvent(fgCurrent);
+ gEve->SetCurrentEvent(fgCurrent);
try
{
fgCurrent->GotoEvent(fEventId);
}
}
fgCurrent = fgMaster;
- // gEve->SetCurrentEvent(fgMaster);
+ gEve->SetCurrentEvent(fgMaster);
}
}
return rawInfo + "\n" + esdInfo;
}
+
+
+//==============================================================================
+// Reading of GRP and MagneticField.
+// This is a reap-off from reconstruction ... should really be a common
+// code to do this somewhere in STEER.
+//==============================================================================
+
+Bool_t AliEveEventManager::InitGRP()
+{
+ //------------------------------------
+ // Initialization of the GRP entry
+ //------------------------------------
+
+ static const TEveException kEH("AliEveEventManager::InitGRP ");
+
+ AliGRPManager grpMgr;
+ if (!grpMgr.ReadGRPEntry()) {
+ return kFALSE;
+ }
+ fgGRPLoaded = kTRUE;
+ if (!grpMgr.SetMagField()) {
+ throw kEH + "Setting of field failed!";
+ }
+
+ //*** Get the diamond profiles from OCDB
+ // Eventually useful.
+
+ /*
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
+ if (entry) {
+ fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ } else {
+ ::Error(kEH, "No SPD diamond profile found in OCDB!");
+ }
+
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
+ if (entry) {
+ fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ } else {
+ ::Error(kEH, "No diamond profile found in OCDB!");
+ }
+
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
+ if (entry) {
+ fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ } else {
+ ::Error(kEH, "No TPC diamond profile found in OCDB!");
+ }
+ */
+
+ return kTRUE;
+}