HLT/global/AliFlatESDEvent.cxx

   1 /* $Id$ */
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Author: The ALICE Off-line Project.                                    *
   7  * Contributors are mentioned in the code where appropriate.              *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 /**
  19  * >> Flat structure representing an ESD <<
  20  *
  21  * To be used in the online and offline calibration schema.
  22  *
  23  * Class provides interface methods for
  24  *   - Filling from AliESDEvent, but also from HLT (to be added)
  25  *   - Getter methods
  26  *
  27  * In the online case, the structure can be directly written into a shared
  28  * memory, in the offline case, the size has to be estimated first.
  29  *
  30  *
  31  * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli
  32  *
  33  * ************************************************************************
  34  * Offline usage:
  35  *
  36  *  ...
  37  *  AliESDEvent* esd = ....;
  38  *  Bool_t useESDFriends = kTRUE;
  39  *
  40  *  // -- Book memory for AliFlatESDEvent
  41  *  Byte_t *mem = new Byte_t[AliFlatESDEvent::EstimateSize(esd, useESDFriends)];
  42  *  AliFlatESDEvent *flatEsd = reinterpret_cast<AliFlatESDEvent*>(mem);
  43  *
  44  *  // -- Fill AliFlatESDEvent
  45  *  flatEsd->Fill(esd, useESDFriends);
  46  *  ...
  47  *
  48  **************************************************************************/
  49
  50 #include "AliESDEvent.h"
  51 #include "AliESDtrack.h"
  52 #include "AliESDfriend.h"
  53 #include "AliESDv0.h"
  54
  55 #include "AliFlatESDEvent.h"
  56 #include "AliFlatESDTrack.h"
  57 #include "AliFlatTPCCluster.h"
  58 #include "AliFlatExternalTrackParam.h"
  59 #include "Riostream.h"
  60
  61 #include "AliFlatESDVertex.h"
  62
  63 #include "AliFlatESDV0.h"
  64 #include "AliFlatESDTrigger.h"
  65
  66 #include "AliESDEvent.h"
  67 #include "AliESDVertex.h"
  68
  69 ClassImp(AliFlatESDEvent);
  70
  71 // _______________________________________________________________________________________________________
  72 AliFlatESDEvent::AliFlatESDEvent() :
  73   fContentSize(0),
  74   fMagneticField(0),
  75   fPeriodNumber(0),
  76   fRunNumber(0),
  77   fOrbitNumber(0),
  78   fTimeStamp(0),
  79   fBunchCrossNumber(0),
  80   fPrimaryVertexMask(0),
  81   fTriggerMask(0),
  82   fNTriggerClasses(0),
  83   fNPrimaryVertices(0),
  84   fNTracks(0),
  85   fNV0s(0),
  86   fTriggerPointer(0),
  87   fPrimaryVertexPointer(0),
  88   fTracksPointer(0),
  89   fV0Pointer(0)
  90 {
  91   // Default constructor
  92   fContent[0]=0;
  93 }
  94
  95 /*
  96 // _______________________________________________________________________________________________________
  97 AliFlatESDEvent::AliFlatESDEvent(AliESDEvent *esd) :
  98   fSize(0),
  99   fMagneticField(0),
 100   fPeriodNumber(0),
 101   fRunNumber(0),
 102   fOrbitNumber(0),
 103   fTimeStamp(0),
 104   fBunchCrossNumber(0),
 105   fPrimaryVertexMask(0),
 106   fTriggerMask(0),
 107   fNTriggerClasses(0),
 108   fNPrimaryVertices(0),
 109   fNTracks(0),
 110   fNV0s(0),
 111   fTriggerPointer(0),
 112   fPrimaryVertexPointer(0),
 113   fTracksPointer(0),
 114   fV0Pointer(0)
 115 {
 116   fContent[0]=0;
 117   Fill(esd);
 118 }
 119
 120 // _______________________________________________________________________________________________________
 121 AliFlatESDEvent::AliFlatESDEvent(AliESDEvent *esd, Bool_t useESDFriends) :
 122   // Constructor
 123   fPrimaryVertexMask(0),
 124   fNTracks(0),
 125   fTracksPointer(0),
 126   fNV0s(0),
 127   fV0Pointer(0),
 128   fSize(0),
 129   fMagneticField(0),
 130   fPeriodNumber(0),
 131   fRunNumber(0),
 132   fOrbitNumber(0),
 133   fBunchCrossNumber(0),
 134   fTimeStamp(0),
 135   fContent()
 136 {
 137   Fill(esd, useESDFriends);
 138 }
 139 */
 140
 141 // _______________________________________________________________________________________________________
 142 AliFlatESDEvent::~AliFlatESDEvent()
 143 {
 144   // Destructor
 145 }
 146
 147 void AliFlatESDEvent::Init()
 148 {
 149   // Init
 150
 151   fContentSize = 0;
 152   fMagneticField = 0;
 153   fPeriodNumber = 0;
 154   fRunNumber = 0;
 155   fOrbitNumber = 0;
 156   fTimeStamp = 0;
 157   fBunchCrossNumber = 0;
 158   fPrimaryVertexMask = 0;
 159   fTriggerMask = 0;
 160   fNTriggerClasses = 0;
 161   fNPrimaryVertices = 0;
 162   fNTracks = 0;
 163   fNV0s = 0;
 164   fTriggerPointer = 0;
 165   fPrimaryVertexPointer = 0;
 166   fTracksPointer = 0;
 167   fV0Pointer = 0;
 168 }
 169
 170 // _______________________________________________________________________________________________________
 171   ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t useESDFriends, Bool_t fillV0s)
 172 {
 173   // Estimate upper limit of the object size
 174   // -> Added objects have to be added here as well
 175
 176   ULong64_t size = sizeof(AliFlatESDEvent);
 177   size += 2 * sizeof( AliFlatESDVertex );
 178   size += esd->GetNumberOfTracks() * AliFlatESDTrack::EstimateSize(useESDFriends);
 179   if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0);
 180   return size;
 181 }
 182
 183 void AliFlatESDEvent::FillPrimaryVertices( const AliESDVertex *vertexSPD,
 184                                             const AliESDVertex *vertexTracks )
 185 {
 186   // fill primary vertices
 187
 188   fPrimaryVertexMask = 0;
 189   fContentSize = 0;
 190
 191   Byte_t flag = 0x1;
 192   FillPrimaryVertex(vertexSPD, flag);
 193
 194   flag = 0x2;
 195   FillPrimaryVertex(vertexTracks, flag);
 196
 197   fTracksPointer = fContentSize;
 198   fV0Pointer = fContentSize;
 199 }
 200
 201 void AliFlatESDEvent::FillPrimaryVertex(const AliESDVertex *v, Byte_t flag)
 202 {
 203
 204   // Fill primary vertex parameters
 205
 206   if (!v) return;
 207
 208   AliFlatESDVertex *vtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
 209   vtx->Set( *v );
 210   fPrimaryVertexMask |= flag;
 211   fContentSize += sizeof(AliFlatESDVertex);
 212 }
 213
 214
 215 Int_t AliFlatESDEvent::FillNextTrack( const AliESDtrack* esdTrack, AliESDfriendTrack* friendTrack)
 216 {
 217   // fill next track
 218
 219   AliFlatESDTrack *flatTrack = reinterpret_cast<AliFlatESDTrack*>(fContent+fContentSize);
 220   //new (flatTrack) AliFlatESDTrack;
 221   flatTrack->Fill(esdTrack, friendTrack);
 222   fContentSize += flatTrack->GetSize();
 223   ++fNTracks;
 224   return 0;
 225 }
 226
 227 Int_t AliFlatESDEvent::AddTriggerClass(  const char *TriggerClassName, Int_t TriggerIndex, ULong64_t MaxSize )
 228 {
 229   // add trigger class
 230   AliFlatESDTrigger *flatTrigger = reinterpret_cast<AliFlatESDTrigger*>(fContent+fContentSize);
 231   Int_t err = flatTrigger->SetTriggerClass( TriggerClassName, TriggerIndex, MaxSize );
 232   if( err==0 ){
 233     fContentSize+= flatTrigger->GetSize();
 234     fNTriggerClasses++;
 235   }
 236   return err;
 237 }
 238
 239
 240 // _______________________________________________________________________________________________________
 241 Int_t AliFlatESDEvent::FillFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t useESDFriends, const Bool_t fillV0s)
 242 {
 243   // Fill flat ESD event from normal ALiESDEvent
 244   // - Fill tracks + friends (if requested)
 245   // -> Added objects have to be added here as well
 246
 247 #ifdef xxx
 248   if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
 249
 250   Init();
 251
 252   if( !esd ) return 0;
 253
 254   Int_t err = 0;
 255   size_t freeSpace = allocatedMemorySize - GetSize();
 256
 257   // fill run info
 258   {
 259     SetTriggerMask( esd->GetTriggerMask() );
 260   }
 261
 262
 263   // Fill trigger information
 264   {
 265     size_t triggerSize = 0;
 266     int nTriggers = 0;
 267     AliFlatESDTrigger *trigger = FillTriggersStart();
 268     const AliESDRun*  esdRun = esd->GetESDRun();
 269     if( esdRun ){
 270       for( int index=0; index<AliESDRun::kNTriggerClasses; index++){
 271         const char* name = esdRun->GetTriggerClass(index);
 272         if( name && name[0]!='\0' ){
 273           err = trigger->SetTriggerClass( name, index, freeSpace );
 274           if( err!=0 ) return err;
 275           nTriggers++;
 276           freeSpace -= trigger->GetSize();
 277           triggerSize += trigger->GetSize();
 278           trigger = trigger->GetNextTrigger();
 279         }
 280       }
 281     }
 282     FillTriggersEnd( nTriggers, triggerSize );
 283   }
 284
 285   // fill primary vertices
 286
 287
 288   err = FillPrimaryVertices( freeSpace, esd->GetPrimaryVertexSPD(), esd->GetPrimaryVertexTracks() );
 289
 290   if( err!=0 ) return err;
 291
 292   freeSpace = allocatedMemorySize - GetSize();
 293
 294
 295  ULong64_t GetTriggerMask() const {return fHeader?fHeader->GetTriggerMask():0;}
 296   TString   GetFiredTriggerClasses() const {return (fESDRun&&fHeader)?fESDRun->GetFiredTriggerClasses(fHeader->GetTriggerMask()):"";}
 297   Bool_t    IsTriggerClassFired(const char *name) const {return (fESDRun&&fHeader)?fESDRun->IsTriggerClassFired(fHeader->GetTriggerMask(),name):kFALSE;}
 298
 299   const AliHLTCTPData* pCTPData=CTPData();
 300   if (pCTPData) {
 301     AliHLTUInt64_t mask=pCTPData->ActiveTriggers(trigData);
 302     for (int index=0; index<gkNCTPTriggerClasses; index++) {
 303       if ((mask&((AliHLTUInt64_t)0x1<<index)) == 0) continue;
 304       pESD->SetTriggerClass(pCTPData->Name(index), index);
 305     }
 306     pESD->SetTriggerMask(mask);
 307   }
 308
 309
 310   //allocatedMemorySize - GetSize();
 311
 312   FillTriggersEnd(nTriggers, triggerSize );
 313
 314   // -- Get ESD friends
 315   // -------------------------------------------------------
 316   Bool_t connectESDFriends = useESDFriends;
 317   AliESDfriend* esdFriend  = NULL;
 318
 319    if (connectESDFriends) {
 320     esdFriend = dynamic_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
 321     if (!esdFriend) {
 322       connectESDFriends = kFALSE;
 323       Printf("WARNING: friends not available, cluster information will not be included");
 324     }
 325     else
 326       Printf("INFO: friends are available, cluster information will be included");
 327   }
 328
 329   // -- Track loop, fill AliFlatESDTrack sub structure
 330   // -------------------------------------------------------
 331   for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) {
 332     AliESDtrack       *esdTrack    = esd->GetTrack(idxTrack);
 333     AliESDfriendTrack *friendTrack = NULL;
 334
 335     if (esdTrack) {
 336       if (connectESDFriends){
 337         friendTrack = esdFriend->GetTrack(idxTrack);
 338       }
 339       FillNextTrack( esdTrack, friendTrack);
 340     }
 341   }
 342
 343   // Fill V0s
 344
 345   fV0Pointer = fContentSize;
 346   fNV0s = 0;
 347   if( fillV0s ){
 348     for( int i=0; i < esd->GetNumberOfV0s(); i++){
 349       AliESDv0 *esdV0 = esd->GetV0( i );
 350       AliFlatESDV0 *v0 = GetNextV0Pointer();
 351       if( !v0 ) continue;
 352       v0->fNegTrackID = esdV0->GetNindex();
 353       v0->fPosTrackID = esdV0->GetNindex();
 354       StoreLastV0();
 355     }
 356   }
 357 #endif
 358   return 0;
 359 }
 360
 361 UInt_t AliFlatESDEvent::CountBits(Byte_t field, UInt_t mask) const {
 362   // Count bits in field
 363   UInt_t count = 0;
 364   UInt_t reg = 0x0;
 365
 366   reg |= field;
 367   reg &= mask;
 368
 369   for (count = 0; reg; count++)
 370     reg &= reg - 1;
 371
 372   return count;
 373 }