HLT/rec/test/testAliHLTEsdManager.C

   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   testAliHLTEsdManager.C
  20     @author Matthias Richter
  21     @date
  22     @brief  Test macro/program for the AliHLTEsdManager class
  23  */
  24
  25 #ifndef __CINT__
  26 #include "TFile.h"
  27 #include "TDatime.h"
  28 #include "TRandom.h"
  29 #include "TArrayI.h"
  30 #include "TSystem.h"
  31 #include "TTree.h"
  32 #include "TFile.h"
  33 #include "AliESDEvent.h"
  34 #include "AliHLTDataTypes.h"
  35 #include "AliHLTComponent.h"
  36 #include "AliHLTEsdManager.h"
  37 #include "AliHLTMessage.h"
  38 #include "AliHLTSystem.h"
  39 #include <ostream>
  40 #endif //__CINT__
  41
  42 /////////////////////////////////////////////////////////////////
  43 /////////////////////////////////////////////////////////////////
  44 /////////////////////////////////////////////////////////////////
  45 //
  46 // configuration of the test program
  47 //
  48
  49 // printouts or not
  50 const bool bVerbose=false;
  51
  52
  53 /////////////////////////////////////////////////////////////////
  54 /////////////////////////////////////////////////////////////////
  55 /////////////////////////////////////////////////////////////////
  56 //
  57 // forward declarations
  58 //
  59 class AliHLTEsdManager;
  60 int GetRandom(int min, int max);
  61 int CreateAndWriteESD(AliHLTEsdManager* manager, int eventno, AliHLTComponentDataType dt, AliESDEvent* pTgt);
  62 int CheckFields(const char* file, TArrayI* fields);
  63 int CheckFields(TTree* pTree, TArrayI* fields, const char* file);
  64
  65 /////////////////////////////////////////////////////////////////
  66 /////////////////////////////////////////////////////////////////
  67 /////////////////////////////////////////////////////////////////
  68 //
  69 // compiled version and root macro are not equivalent for this unit test
  70 // The macro just tests with one data type
  71 // This is mainly due to some restrictions in CINT which can not handle
  72 // the array of data types correctly
  73 int testAliHLTEsdManager()
  74 {
  75   cout << "macro still not working with CINT, sorry!" << endl;
  76   return 0;
  77
  78   int iResult=0;
  79 #ifdef __CINT__
  80   if (gSystem->Load("libHLTrec.so")<0) {
  81     cerr << "error: error loading libHLTrec.so library" << endl;
  82     return -1;
  83   }
  84 #endif
  85
  86   AliHLTEsdManager*  pManager=AliHLTEsdManager::New();
  87   if (!pManager) {
  88     cerr << "error: can not create manager instance" << endl;
  89     return -1;
  90   }
  91   pManager->SetDirectory(gSystem->TempDirectory());
  92
  93   int nofEvents=10;
  94   AliHLTComponentDataType tpcesd;
  95   AliHLTComponent::SetDataType(tpcesd, "ESD_TREE", "TPC ");
  96   cout << AliHLTComponent::DataType2Text(tpcesd).c_str() << endl;
  97   for (int event=0; event<nofEvents && iResult>=0; event++) {
  98     cout << AliHLTComponent::DataType2Text(tpcesd).c_str() << endl;
  99     CreateAndWriteESD(pManager, event, tpcesd, NULL);
 100   }
 101
 102   AliHLTEsdManager::Delete(pManager);
 103   return iResult;
 104 }
 105
 106 /////////////////////////////////////////////////////////////////
 107 /////////////////////////////////////////////////////////////////
 108 /////////////////////////////////////////////////////////////////
 109 //
 110 int main(int /*argc*/, const char** /*argv*/)
 111 {
 112   int iResult=0;
 113   int nofEvents=10;
 114   AliHLTSystem gHLT;
 115   gHLT.SetGlobalLoggingLevel(kHLTLogDefault);
 116
 117   AliHLTEsdManager*  pManager=AliHLTEsdManager::New();
 118   if (!pManager) {
 119     cerr << "error: can not create manager instance" << endl;
 120     return -1;
 121   }
 122   pManager->SetDirectory(gSystem->TempDirectory());
 123
 124   AliHLTComponentDataType types[] = {
 125     // first entry is special, ESD is written to the global target ESD
 126     //kAliHLTDataTypeESDTree|kAliHLTDataOriginTPC,
 127     kAliHLTDataTypeESDTree|kAliHLTDataOriginTPC,
 128     kAliHLTDataTypeESDTree|kAliHLTDataOriginPHOS,
 129     kAliHLTDataTypeESDTree|kAliHLTDataOriginTRD,
 130     kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTRD,
 131     kAliHLTVoidDataType
 132   };
 133
 134   TTree* pMasterTree=new TTree("esdTree", "Tree with HLT ESD objects");
 135   pMasterTree->SetDirectory(0);
 136   AliESDEvent* pMasterESD=new AliESDEvent;
 137   pMasterESD->CreateStdContent();
 138   pMasterESD->WriteToTree(pMasterTree);
 139
 140   vector<TArrayI*> randomFields;
 141   for (int event=0; event<nofEvents && iResult>=0; event++) {
 142     pMasterESD->ResetStdContent();
 143     for (unsigned int type=0; types[type]!=kAliHLTVoidDataType && iResult>=0; type++) {
 144       if (randomFields.size()<=type) {
 145         randomFields.push_back(new TArrayI(nofEvents));
 146       }
 147       AliESDEvent* pTgt=NULL;
 148       //if (type==0) pTgt=pMasterESD;
 149       int field=CreateAndWriteESD(pManager, event, types[type], pTgt);
 150       if (field>=0) {
 151         (*randomFields[type])[event]=field;
 152       } else {
 153         iResult=-1;
 154         break;
 155       }
 156     }
 157     pMasterTree->Fill();
 158   }
 159
 160   if (iResult>=0) {
 161     pManager->PadESDs(nofEvents);
 162   }
 163
 164   for (int type=0; types[type]!=kAliHLTVoidDataType; type++) {
 165     TString filename=pManager->GetFileNames(types[type]);
 166     if (iResult>=0) {
 167       iResult=CheckFields(filename, dynamic_cast<TArrayI*>(randomFields[type]));
 168     }
 169     TString shellcmd="rm -f ";
 170     shellcmd+=filename;
 171     gSystem->Exec(shellcmd);
 172   }
 173
 174   vector<TArrayI*>::iterator element;
 175   while ((element=randomFields.end())!=randomFields.begin()) {
 176     element--;
 177     if (*element) delete *element;
 178     randomFields.pop_back();
 179   }
 180
 181   delete pMasterESD;
 182   AliHLTEsdManager::Delete(pManager);
 183
 184   return iResult;
 185 }
 186
 187 Bool_t seedSet=kFALSE;
 188
 189 /**
 190  * Get a random number in the given range.
 191  */
 192 int GetRandom(int min, int max)
 193 {
 194   if (max-min<2) return min;
 195   static TRandom rand;
 196   if (!seedSet) {
 197     TDatime dt;
 198     rand.SetSeed(dt.Get());
 199     seedSet=kTRUE;
 200   }
 201   return rand.Integer(max-min);
 202 }
 203
 204 /**
 205  * Creates a dummy ESD object and sets the magnetic field to a random number.
 206  * The ESD is streamed via AliHLTMessage and processed by the AliHLTEsdmanager.
 207  * @return 0 no ESD created, >0 random number of the magnetic field,
 208  *         neg error if failed
 209  */
 210 int CreateAndWriteESD(AliHLTEsdManager* pManager, int eventno, AliHLTComponentDataType dt, AliESDEvent* pTgt)
 211 {
 212   int iResult=0;
 213   int magField=0;
 214   if (!pManager) {
 215     cerr << "error: missing manager instance" << endl;
 216     return -1;
 217   }
 218   const char* message="";
 219   if ((GetRandom(0,10)%3)==0) {
 220     message=": adding ESD for block ";
 221     TTree* pTree=new TTree;
 222     AliESDEvent* pESD=new AliESDEvent;
 223     pESD->CreateStdContent();
 224     magField=GetRandom(1, 1000);
 225     pESD->SetMagneticField(magField);
 226     pESD->WriteToTree(pTree);
 227     pTree->Fill();
 228     pTree->GetUserInfo()->Add(pESD);
 229     AliHLTMessage msg(kMESS_OBJECT);
 230     msg.WriteObject(pTree);
 231     Int_t iMsgLength=msg.Length();
 232     if (iMsgLength>0) {
 233       msg.SetLength(); // sets the length to the first (reserved) word
 234       iResult=pManager->WriteESD((AliHLTUInt8_t*)msg.Buffer(), iMsgLength, dt, pTgt, eventno);
 235     }
 236     pTree->GetUserInfo()->Clear();
 237     delete pTree;
 238     delete pESD;
 239   } else {
 240     message=": omitting block       ";
 241   }
 242   if (iResult>=0) iResult=magField;
 243   if (bVerbose) cout << "event " << eventno << message << AliHLTComponent::DataType2Text(dt).c_str() << ": " << iResult << endl;
 244   return iResult;
 245 }
 246
 247 /**
 248  * Read the ESD from the file and compare with the
 249  * random field values previously set to the ESDs
 250  */
 251 int CheckFields(const char* file, TArrayI* fields)
 252 {
 253   if (!file || !fields) {
 254     cerr << "error: invalid parameters" << endl;
 255     return 0;
 256   }
 257   TFile esdfile(file);
 258   if (!esdfile.IsZombie()) {
 259     TTree* pTree=NULL;
 260     esdfile.GetObject("esdTree", pTree);
 261     if (pTree) {
 262       int res=CheckFields(pTree, fields, file);
 263       if (res<0) return res;
 264     } else {
 265       cerr << "error: can not find esdTree in file " << file << endl;
 266     }
 267   } else {
 268     cerr << "error: can not open file " << file << endl;
 269     return -1;
 270   }
 271   cout << "checking: " << file << " ok" << endl;
 272   return 0;
 273 }
 274
 275 /**
 276  * Compare ESD from tree with the
 277  * random field values previously set to the ESDs
 278  */
 279 int CheckFields(TTree* pTree, TArrayI* fields, const char* file)
 280 {
 281   if (fields->GetSize()!=pTree->GetEntries()) {
 282     cerr << "error: event number mismatch in file " << file << " : expected " << fields->GetSize() << "  found " << pTree->GetEntries() << endl;
 283     return -1;
 284   }
 285   AliESDEvent* pESD=new AliESDEvent;
 286   pESD->ReadFromTree(pTree);
 287   for (int event=0; event<pTree->GetEntries(); event++) {
 288     pTree->GetEvent(event);
 289     if (fields->At(event)!=pESD->GetMagneticField()) {
 290       cerr << "error: magnetic field mismatch in file " << file << " event " << event << ": expected " << fields->At(event) << "  found " << pESD->GetMagneticField() << endl;
 291       return -1;
 292     }
 293   }
 294
 295   delete pESD;
 296   return 0;
 297 }