HLT/rec/AliHLTEsdManagerImplementation.cxx

   1 // $Id$
   2
   3 //**************************************************************************
   4 //* This file is property of and copyright by the ALICE HLT Project        *
   5 //* ALICE Experiment at CERN, All rights reserved.                         *
   6 //*                                                                        *
   7 //* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
   8 //*                  for The ALICE HLT Project.                            *
   9 //*                                                                        *
  10 //* Permission to use, copy, modify and distribute this software and its   *
  11 //* documentation strictly for non-commercial purposes is hereby granted   *
  12 //* without fee, provided that the above copyright notice appears in all   *
  13 //* copies and that both the copyright notice and this permission notice   *
  14 //* appear in the supporting documentation. The authors make no claims     *
  15 //* about the suitability of this software for any purpose. It is          *
  16 //* provided "as is" without express or implied warranty.                  *
  17 //**************************************************************************
  18
  19 /// @file   AliHLTEsdManagerImplementation.cxx
  20 /// @author Matthias Richter
  21 /// @date
  22 /// @brief  Manager for merging and writing of HLT ESDs
  23 ///         This is an implementation of the abstract interface AliHLTEsdManager
  24
  25 #include "AliHLTEsdManagerImplementation.h"
  26 #include "AliHLTComponent.h"
  27 #include "AliESDEvent.h"
  28 #include "AliHLTMessage.h"
  29 #include "AliESDEvent.h"
  30 #include "AliESDtrack.h"
  31 #include "AliESDFMD.h"
  32 #include "AliESDVZERO.h"
  33 #include "AliESDTZERO.h"
  34 #include "AliESDCaloCells.h"
  35 #include "AliMultiplicity.h"
  36 #include "AliESDACORDE.h"
  37 #include "TFile.h"
  38 #include "TTree.h"
  39 #include "TClass.h"
  40 #include "TObject.h"
  41 #include "TList.h"
  42
  43 const float kAliESDVZERODefaultTime = -1024.;
  44 const float kAliESDVZERODefaultTimeGlitch = 1e-6;
  45 const float kAliESDZDCDefaultEMEnergy = 0.;
  46 const float kAliESDZDCDefaultEMEnergyGlitch = 1e-6;
  47
  48 /** ROOT macro for the implementation of ROOT specific class methods */
  49 ClassImp(AliHLTEsdManagerImplementation)
  50
  51 AliHLTEsdManagerImplementation::AliHLTEsdManagerImplementation()
  52   :
  53   fESDs()
  54   , fDirectory()
  55   , fTreeName()
  56   , fWriteLocal(false)
  57 {
  58   // see header file for class documentation
  59   // or
  60   // refer to README to build package
  61   // or
  62   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  63
  64   CheckClassConditions();
  65 }
  66
  67 AliHLTEsdManagerImplementation::~AliHLTEsdManagerImplementation()
  68 {
  69   // see header file for class documentation
  70   for (unsigned int i=0; i<fESDs.size(); i++) {
  71     if (fESDs[i]) {
  72       delete fESDs[i];
  73     }
  74     fESDs[i]=NULL;
  75   }
  76 }
  77
  78 int AliHLTEsdManagerImplementation::SetOption(const char* option)
  79 {
  80   // see header file for class documentation
  81   int iResult=0;
  82   TString strOptions=option;
  83   TObjArray* pTokens=strOptions.Tokenize(" ");
  84   if (pTokens) {
  85     if (pTokens->GetEntriesFast()>0) {
  86       for (int n=0; n<pTokens->GetEntriesFast(); n++) {
  87         TString data=((TObjString*)pTokens->At(n))->GetString();
  88         if (data.IsNull()) continue;
  89
  90         if (data.CompareTo("-writelocal")==0) {
  91           fWriteLocal=true;
  92         } else if (data.Contains("-directory=")) {
  93           data.ReplaceAll("-directory=", "");
  94           SetDirectory(data.Data());
  95         } else if (data.Contains("-treename=")) {
  96           data.ReplaceAll("-treename=", "");
  97           fTreeName=data;
  98         } else {
  99           HLTError("unknown argument %s", data.Data());
 100           iResult=-EINVAL;
 101           break;
 102         }
 103       }
 104     }
 105     delete pTokens;
 106   }
 107   return iResult;
 108 }
 109
 110 AliHLTEsdManagerImplementation::AliHLTEsdListEntry* AliHLTEsdManagerImplementation::Find(AliHLTComponentDataType dt) const
 111 {
 112   // see header file for class documentation
 113   AliHLTEsdListEntry* pEntry=NULL;
 114   for (unsigned int i=0; i<fESDs.size(); i++) {
 115     if (fESDs[i] && *(fESDs[i])==dt) {
 116       pEntry=const_cast<AliHLTEsdListEntry*>(fESDs[i]);
 117     }
 118   }
 119   return pEntry;
 120 }
 121
 122 int AliHLTEsdManagerImplementation::WriteESD(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size,
 123                                AliHLTComponentDataType dt, AliESDEvent* tgtesd, int eventno)
 124 {
 125   // see header file for class documentation
 126   if (!pBuffer && size<=0) return -EINVAL;
 127   int iResult=0;
 128   AliHLTUInt32_t firstWord=*((AliHLTUInt32_t*)pBuffer);
 129   if (firstWord==size-sizeof(AliHLTUInt32_t)) {
 130     HLTDebug("create object from block %s size %d", AliHLTComponent::DataType2Text(dt).c_str(), size);
 131     AliHLTMessage msg(const_cast<AliHLTUInt8_t*>(pBuffer), size);
 132     TClass* objclass=msg.GetClass();
 133     TObject* pObj=msg.ReadObject(objclass);
 134     if (pObj && objclass) {
 135       HLTDebug("object %p type %s created", pObj, objclass->GetName());
 136       AliESDEvent* pESD=dynamic_cast<AliESDEvent*>(pObj);
 137       TTree* pTree=NULL;
 138       if (!pESD) {
 139         pTree=dynamic_cast<TTree*>(pObj);
 140         if (pTree) {
 141           pESD=new AliESDEvent;
 142           pESD->CreateStdContent();
 143           if (pTree->GetEntries()>0) {
 144             if (pTree->GetEntries()>1) {
 145               HLTWarning("only one entry allowed for ESD embedded into tree, data block %s contains tree with %d entires, taking first entry",
 146                          AliHLTComponent::DataType2Text(dt).c_str(), pTree->GetEntries());
 147             }
 148             pESD->ReadFromTree(pTree);
 149             pTree->GetEvent(0);
 150           }
 151         } else {
 152           HLTWarning("tree of data block %s has no events, skipping data block", AliHLTComponent::DataType2Text(dt).c_str());
 153         }
 154       }
 155       if (pESD) {
 156         AliHLTEsdListEntry* entry=Find(dt);
 157         if (!entry) {
 158           if ((entry=new AliHLTEsdListEntry(dt))!=NULL) {
 159             if (!fDirectory.IsNull()) {
 160               entry->SetDirectory(fDirectory);
 161             }
 162             if (!fTreeName.IsNull()) {
 163               entry->SetTreeName(fTreeName);
 164             }
 165             fESDs.push_back(entry);
 166           }
 167         }
 168         if (entry) {
 169           if (tgtesd) {
 170             Merge(tgtesd, pESD);
 171           }
 172
 173           // Matthias 2009-06-06: writing of individual ESD files for the different origins was a
 174           // first attempt when functionality was missing in the AliRoot framework and remained as
 175           // debugging feature. ESD merging is now implemented and data written to the hltEsd, so
 176           // the feature is now disabled by default because it causes increasing memory consumption.
 177           // Presumably not because of a memory leak but the way the internal TTree is used and kept
 178           // in memory.
 179           // Writing of local files can be optionally switched on as e.g. by the EsdCollector component.
 180           if (fWriteLocal) entry->WriteESD(pESD, eventno);
 181         } else {
 182           HLTError("internal mismatch, can not create list entry");
 183           iResult=-ENOMEM;
 184         }
 185       } else {
 186         HLTWarning("data block %s is not of class type AliESDEvent, ignoring ...", AliHLTComponent::DataType2Text(dt).c_str());
 187       }
 188       if (pTree) {
 189         // ESD has been created and must be cleaned up
 190         pESD->Reset();
 191         delete pESD;
 192         pESD=NULL;
 193       }
 194       delete pObj;
 195       pObj=NULL;
 196     } else {
 197     }
 198   }
 199   return iResult;
 200 }
 201
 202 int AliHLTEsdManagerImplementation::PadESDs(int eventno)
 203 {
 204   // see header file for class documentation
 205   int iResult=0;
 206   for (unsigned int i=0; i<fESDs.size(); i++) {
 207     if (fESDs[i]) {
 208       int res=fESDs[i]->WriteESD(NULL, eventno);
 209       if (res<0 && iResult>=0) iResult=res;
 210     }
 211   }
 212   return iResult;
 213 }
 214
 215 void AliHLTEsdManagerImplementation::SetDirectory(const char* directory)
 216 {
 217   // see header file for class documentation
 218   if (!directory) return;
 219   fDirectory=directory;
 220   for (unsigned int i=0; i<fESDs.size(); i++) {
 221     if (fESDs[i]) {
 222       fESDs[i]->SetDirectory(directory);
 223     }
 224   }
 225 }
 226
 227 TString AliHLTEsdManagerImplementation::GetFileNames(AliHLTComponentDataType dt) const
 228 {
 229   TString result;
 230   for (unsigned int i=0; i<fESDs.size(); i++) {
 231     if (fESDs[i] && *(fESDs[i])==dt) {
 232       if (!result.IsNull()) result+=" ";
 233       result+=fESDs[i]->GetFileName();
 234     }
 235   }
 236   return result;
 237 }
 238
 239 TTree* AliHLTEsdManagerImplementation::EmbedIntoTree(AliESDEvent* pESD, const char* name, const char* title)
 240 {
 241   // see header file for class documentation
 242   int iResult=0;
 243   TTree* pTree=new TTree(name, title);
 244   if (pTree) {
 245     pESD->WriteToTree(pTree);
 246     pTree->Fill();
 247     pTree->GetUserInfo()->Add(pESD);
 248   } else {
 249     iResult=-ENOMEM;
 250   }
 251
 252   if (iResult<0) {
 253     pTree->GetUserInfo()->Clear();
 254     delete pTree;
 255   }
 256
 257   return pTree;
 258 }
 259
 260 AliHLTEsdManagerImplementation::AliHLTEsdListEntry::AliHLTEsdListEntry(AliHLTComponentDataType dt)
 261   :
 262   fName(),
 263   fDirectory(),
 264   fDt(dt),
 265   fpFile(NULL),
 266   fpTree(NULL),
 267   fpEsd(NULL),
 268   fPrefix(),
 269   fTreeName("esdTree")
 270 {
 271   // see header file for class documentation
 272 }
 273
 274 AliHLTEsdManagerImplementation::AliHLTEsdListEntry::~AliHLTEsdListEntry()
 275 {
 276   // see header file for class documentation
 277   if (fpEsd) delete fpEsd;
 278   fpEsd=NULL;
 279
 280   if (fpTree) delete fpTree;
 281   fpTree=NULL;
 282
 283   if (fpFile) {
 284     fpFile->Close();
 285     delete fpFile;
 286   }
 287   fpFile=NULL;
 288 }
 289
 290 bool AliHLTEsdManagerImplementation::AliHLTEsdListEntry::operator==(AliHLTComponentDataType dt) const
 291 {
 292   // see header file for class documentation
 293   return fDt==dt;
 294 }
 295
 296 int AliHLTEsdManagerImplementation::AliHLTEsdListEntry::WriteESD(AliESDEvent* pSrcESD, int eventno)
 297 {
 298   // see header file for class documentation
 299   int iResult=0;
 300
 301   if (fName.IsNull()) {
 302     // this is the first event, create the file name
 303     fName="";
 304     if (!fDirectory.IsNull()) {
 305       fName+=fDirectory; fName+="/";
 306     }
 307     fName+="Ali"; fName+=GetPrefix();
 308     if (fDt!=kAliHLTDataTypeESDObject &&
 309         fDt!=kAliHLTDataTypeESDTree) {
 310
 311       HLTWarning("non-standard ESD type %s", AliHLTComponent::DataType2Text(fDt).c_str());
 312       TString id;
 313       id.Insert(0, fDt.fID, kAliHLTComponentDataTypefIDsize);
 314       id.Remove(TString::kTrailing, ' ');
 315       id.ToUpper();
 316       fName+="_"; fName+=id; fName+=".root";
 317     } else {
 318       fName+="ESDs.root";
 319     }
 320
 321     fpFile=new TFile(fName, "RECREATE");
 322     fpTree=new TTree(fTreeName, "Tree with HLT ESD objects");
 323     fpTree->SetDirectory(0);
 324     fpEsd=new AliESDEvent;
 325     if (fpEsd) {
 326       fpEsd->CreateStdContent();
 327       *fpEsd=*pSrcESD;
 328       if (fpTree) {
 329         fpEsd->WriteToTree(fpTree);
 330       }
 331     }
 332   }
 333
 334   if (fpFile && fpTree && fpEsd) {
 335     // synchronize and add empty events
 336     fpEsd->Reset();
 337     int nofCurrentEvents=fpTree->GetEntries();
 338     if (nofCurrentEvents<eventno) {
 339       iResult=1; // indicate tree to be written
 340       HLTDebug("adding %d empty events to file %s", eventno-nofCurrentEvents, fName.Data());
 341       for (int i=nofCurrentEvents; i<eventno; i++) {
 342         fpTree->Fill();
 343       }
 344     }
 345
 346     if (iResult>=0 && pSrcESD) {
 347       int nofObjects=fpEsd->GetList()->GetEntries();
 348       *fpEsd=*pSrcESD;
 349       if (nofObjects!=fpEsd->GetList()->GetEntries()) {
 350         // The source ESD contains object not present in the target ESD
 351         // before. Those objects will not be written to the tree since
 352         // the branch layout has been created earlier.
 353         // Create new tree with the additional branches, copy the entries
 354         // of the current tree into the new tree, and continue.
 355         TTree* pNewTree=new TTree(fTreeName, "Tree with HLT ESD objects");
 356         pNewTree->SetDirectory(0);
 357         AliESDEvent* readESD=new AliESDEvent;
 358         readESD->CreateStdContent();
 359         readESD->ReadFromTree(fpTree);
 360         fpEsd->Reset();
 361         fpEsd->WriteToTree(pNewTree);
 362         HLTDebug("cloning tree with %d entries", fpTree->GetEntries());
 363         for (int event=0; event<fpTree->GetEntries(); event++) {
 364           fpTree->GetEntry(event);
 365           *fpEsd=*readESD;
 366           pNewTree->Fill();
 367           fpEsd->Reset();
 368         }
 369         fpFile->Close();
 370         delete fpFile;
 371         delete readESD;
 372         delete fpTree;
 373         fpFile=new TFile(fName, "RECREATE");
 374         fpTree=pNewTree;
 375         *fpEsd=*pSrcESD;
 376         HLTDebug("new ESD with %d objects", fpEsd->GetList()->GetEntries());
 377       }
 378       fpTree->Fill();
 379       iResult=1; // indicate tree to be written
 380     }
 381
 382     if (iResult>0) {
 383       fpFile->cd();
 384       fpTree->GetUserInfo()->Add(fpEsd);
 385       fpTree->Write(fpTree->GetName(),TObject::kOverwrite);
 386       fpTree->GetUserInfo()->Clear();
 387     }
 388   }
 389
 390   return iResult;
 391 }
 392
 393 void AliHLTEsdManagerImplementation::AliHLTEsdListEntry::SetDirectory(const char* directory)
 394 {
 395   // see header file for class documentation
 396   if (!directory) return;
 397   if (!fName.IsNull()) {
 398     HLTWarning("ESD entry already in writing mode (%s), ignoring directory", fName.Data());
 399     return;
 400   }
 401   fDirectory=directory;
 402 }
 403
 404 const char* AliHLTEsdManagerImplementation::AliHLTEsdListEntry::GetFileName() const
 405 {
 406   // see header file for class documentation
 407   return fName.Data();
 408 }
 409
 410 const char* AliHLTEsdManagerImplementation::AliHLTEsdListEntry::GetPrefix()
 411 {
 412   // see header file for class documentation
 413   if (fPrefix.IsNull()) {
 414     fPrefix.Insert(0, fDt.fOrigin, kAliHLTComponentDataTypefOriginSize);
 415     fPrefix.Remove(TString::kTrailing, ' ');
 416     fPrefix.ToUpper();
 417     if (!fPrefix.Contains("HLT")) {
 418       fPrefix.Insert(0, "HLT");
 419     }
 420   }
 421   return fPrefix.Data();
 422 }
 423
 424 int AliHLTEsdManagerImplementation::Merge(AliESDEvent* pTgt, AliESDEvent* pSrc) const
 425 {
 426   // see header file for class documentation
 427   int iResult=0;
 428   if (!pTgt || !pSrc) return -EINVAL;
 429
 430   TIter next(pSrc->GetList());
 431   TObject* pSrcObject=NULL;
 432   static int warningCount=0;
 433   while ((pSrcObject=next())) {
 434     if(!pSrcObject->InheritsFrom("TCollection")){
 435       // simple objects
 436       // for every type of object we have to find out whether it is empty or not
 437       // objects are only copied if non-empty, otherwise valid content would be
 438       // overridden by empty objects during the merging
 439       bool copy=false;
 440       TString name=pSrcObject->GetName();
 441       if(pSrcObject->InheritsFrom("AliHLTTriggerDecision")){
 442         copy=true;
 443       } else if (pSrcObject->IsA()==AliESDRun::Class()) {
 444         AliESDRun* pESDRun=dynamic_cast<AliESDRun*>(pSrcObject);
 445         // zero might be a valid run no in simulation, so we check also whether the CTP trigger classes are set
 446         copy=(pESDRun && (pESDRun->GetRunNumber()>0 || !pESDRun->GetActiveTriggerClasses().IsNull()));
 447       } else if (pSrcObject->IsA()==AliESDHeader::Class()) {
 448         AliESDHeader* pESDHeader=dynamic_cast<AliESDHeader*>(pSrcObject);
 449         copy=(pESDHeader && pESDHeader->GetTriggerMask()!=0);
 450       } else if (pSrcObject->IsA()==AliESDVertex::Class()) {
 451         AliESDVertex* pESDVertex=dynamic_cast<AliESDVertex*>(pSrcObject);
 452         copy=(pESDVertex && pESDVertex->GetNContributors()>0);
 453       } else if (pSrcObject->IsA()==AliESDTZERO::Class()) {
 454         AliESDTZERO* pESDTZero=dynamic_cast<AliESDTZERO*>(pSrcObject);
 455         copy=(pESDTZero && (pESDTZero->GetT0zVertex()!=0.0 || pESDTZero->GetT0()!=0.0));
 456       } else if (pSrcObject->IsA()==AliESDVZERO::Class()) {
 457         AliESDVZERO* pESDVZERO=dynamic_cast<AliESDVZERO*>(pSrcObject);
 458         // object contains data if one of the times exceeds the default value
 459         copy=pESDVZERO &&
 460           (pESDVZERO->GetV0ATime() > kAliESDVZERODefaultTime+kAliESDVZERODefaultTimeGlitch ||
 461            pESDVZERO->GetV0CTime() > kAliESDVZERODefaultTime+kAliESDVZERODefaultTimeGlitch);
 462       } else if (pSrcObject->IsA()==AliESDFMD::Class()) {
 463         AliESDFMD* pESDFMD=dynamic_cast<AliESDFMD*>(pSrcObject);
 464         copy=(pESDFMD && false); // have to find an easy valid condition
 465       } else if (pSrcObject->IsA()==AliESDZDC::Class()) {
 466         AliESDZDC* pESDZDC=dynamic_cast<AliESDZDC*>(pSrcObject);
 467         // object contains data if the EM energies are different from the default value
 468         copy=pESDZDC &&
 469           (TMath::Abs(pESDZDC->GetZDCEMEnergy(0)-kAliESDZDCDefaultEMEnergy) > kAliESDZDCDefaultEMEnergyGlitch ||
 470            TMath::Abs(pESDZDC->GetZDCEMEnergy(1)-kAliESDZDCDefaultEMEnergy) > kAliESDZDCDefaultEMEnergyGlitch);
 471       } else if (pSrcObject->IsA()==AliMultiplicity::Class()) {
 472         AliMultiplicity* pMultiplicity=dynamic_cast<AliMultiplicity*>(pSrcObject);
 473         copy=(pMultiplicity && pMultiplicity->GetNumberOfTracklets()>0);
 474       } else if (pSrcObject->IsA()==AliESDCaloTrigger::Class()) {
 475         AliESDCaloTrigger* pESDCaloTrigger=dynamic_cast<AliESDCaloTrigger*>(pSrcObject);
 476         copy=(pESDCaloTrigger && false); // have to find an easy valid condition
 477       } else if (pSrcObject->IsA()==AliESDCaloCells::Class()) {
 478         AliESDCaloCells* pESDCaloCells=dynamic_cast<AliESDCaloCells*>(pSrcObject);
 479         copy=(pESDCaloCells && false); // have to find an easy valid condition
 480       } else if (pSrcObject->IsA()==AliESDACORDE::Class()) {
 481         AliESDACORDE* pESDACORDE=dynamic_cast<AliESDACORDE*>(pSrcObject);
 482         copy=(pESDACORDE && false); // have to find an easy valid condition
 483       } else if (!AliHLTESDEventHelper::IsStdContent(name)) {
 484         // this is likely to be ok as long as it is not any object of the std content.
 485         copy=true;
 486       } else {
 487         HLTError("no merging implemented for object %s, omitting", name.Data());
 488       }
 489       if (copy) {
 490         //pSrcObject->Print();
 491         TObject* pTgtObject=pTgt->FindListObject(name);
 492         if (pTgtObject) {
 493           pSrcObject->Copy(*pTgtObject);
 494         } else {
 495           pTgt->AddObject(pSrcObject->Clone());
 496         }
 497       }
 498     } else if(pSrcObject->InheritsFrom("TClonesArray")){
 499       TClonesArray* pTClA=dynamic_cast<TClonesArray*>(pSrcObject);
 500       if (pTClA!=NULL && pTClA->GetEntriesFast()>0) {
 501         TString name=pTClA->GetName();
 502         TObject* pTgtObject=pTgt->GetList()->FindObject(name);
 503         TClonesArray* pTgtArray=NULL;
 504         if (pTgtObject!=NULL && pTgtObject->InheritsFrom("TClonesArray")){
 505           pTgtArray=dynamic_cast<TClonesArray*>(pTgtObject);
 506           if (pTgtArray) {
 507             TString classType=pTClA->Class()->GetName();
 508             if (classType.CompareTo(pTgtArray->Class()->GetName())==0) {
 509               if (pTgtArray->GetEntries()==0) {
 510                 pTgtArray->ExpandCreate(pTClA->GetEntries());
 511                 for(int i=0; i<pTClA->GetEntriesFast(); ++i){
 512                   (*pTClA)[i]->Copy(*((*pTgtArray)[i]));
 513                 }
 514               } else {
 515                 if (warningCount++<10) {
 516                   HLTWarning("TClonesArray \"%s\"  in target ESD %p is already filled with %d entries",
 517                              name.Data(), pTgt, pTgtArray->GetEntries());
 518                 }
 519                 iResult=-EBUSY;
 520               }
 521             } else {
 522               if (warningCount++<10) {
 523                 HLTWarning("TClonesArray \"%s\" exists in target ESD %p, but describes incompatible class type %s instead of %s",
 524                            name.Data(), pTgt, pTgtArray->GetClass()->GetName(), pTClA->GetClass()->GetName());
 525               }
 526               iResult=-EBUSY;
 527             }
 528           } else {
 529             if (warningCount++<10) {
 530               HLTError("internal error: dynamic cast failed for object %s %p", pTgtObject->GetName(), pTgtObject);
 531             }
 532             iResult=-EBUSY;
 533           }
 534         } else if (pTgtObject) {
 535           if (warningCount++<10) {
 536             HLTWarning("object \"%s\" does already exist in target ESD %p, but is %s rather than TClonesArray"
 537                        " skipping data",
 538                        name.Data(), pTgt, pTgtObject->Class()->GetName());
 539           }
 540           iResult=-EBUSY;
 541         } else {
 542           if (warningCount++<10) {
 543             HLTWarning("object \"%s\" does not exist in target ESD %p, data can not be copied because it will be lost when filling the tree",
 544                        name.Data(), pTgt);
 545           }
 546           iResult=-ENOENT;
 547         }
 548       }
 549     }
 550   }
 551   return iResult;
 552 }
 553
 554 bool AliHLTEsdManagerImplementation::AliHLTESDEventHelper::IsStdContent(const char* key)
 555 {
 556   // check if the key denotes a std object
 557   TString needle=key;
 558   for (int i=0; i<kESDListN; i++) {
 559     if (needle.CompareTo(fgkESDListName[i])==0) return true;
 560   }
 561   return false;
 562 }
 563
 564 int AliHLTEsdManagerImplementation::CheckClassConditions() const
 565 {
 566   // this is a helper method which checks if some thing in the default
 567   // object initialization changes during the evolution of the source code
 568   // which is necessary for checking the validity of data in the object
 569
 570   // check AliESDVZERO
 571   AliESDVZERO vzerodummy;
 572   if (TMath::Abs(vzerodummy.GetV0ATime()-kAliESDVZERODefaultTime) > kAliESDVZERODefaultTimeGlitch ||
 573       TMath::Abs(vzerodummy.GetV0CTime()-kAliESDVZERODefaultTime) > kAliESDVZERODefaultTimeGlitch) {
 574     HLTWarning("initialization of AliESDVZERO has changed, default time values now %f/%f, "
 575                "revision of condition might be needed",
 576                vzerodummy.GetV0ATime(), vzerodummy.GetV0CTime());
 577   }
 578
 579   // check AliESDZDC
 580   AliESDZDC zdcdummy;
 581   if (TMath::Abs(zdcdummy.GetZDCEMEnergy(0)-kAliESDZDCDefaultEMEnergy) > kAliESDZDCDefaultEMEnergyGlitch ||
 582       TMath::Abs(zdcdummy.GetZDCEMEnergy(1)-kAliESDZDCDefaultEMEnergy) > kAliESDZDCDefaultEMEnergyGlitch) {
 583     HLTWarning("initialization of AliESDZDC has changed, default em energy values now %f/%f, "
 584                "revision of condition might be needed",
 585                zdcdummy.GetZDCEMEnergy(0), zdcdummy.GetZDCEMEnergy(1));
 586   }
 587
 588   return 0;
 589 }
 590
 591 AliESDEvent* AliHLTEsdManagerImplementation::CreateEsdEvent(bool bCreateStdContent) const
 592 {
 593   // create ESDEvent object and optionally initialize standard content
 594   AliESDEvent* pESD=new AliESDEvent;
 595   if (pESD && bCreateStdContent) pESD->CreateStdContent();
 596   return pESD;
 597 }
 598
 599 int AliHLTEsdManagerImplementation::AddObject(AliESDEvent* pESD, const TObject* pObject, const char* branchname) const
 600 {
 601   // add object to the list of ESD contributors
 602   if (!pESD || !pObject) return -EINVAL;
 603   TObject* pESDObject=pESD->FindListObject(branchname);
 604   if (pESDObject) {
 605     // copy the content to the already existing object
 606     pObject->Copy(*pESDObject);
 607   } else {
 608     // add a new object
 609     pESD->AddObject(pObject->Clone());
 610   }
 611   return 0;
 612 }
 613
 614 int AliHLTEsdManagerImplementation::ResetEsdEvent(AliESDEvent* pESD) const
 615 {
 616   // reset the specified ESD object
 617   if (!pESD) return -EINVAL;
 618   pESD->Reset();
 619   return 0;
 620 }