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 // _______________________________________________________________________________________________________
  70 AliFlatESDEvent::AliFlatESDEvent() :
  71   fContentSize(0),
  72   fMagneticField(0),
  73   fPeriodNumber(0),
  74   fRunNumber(0),
  75   fOrbitNumber(0),
  76   fTimeStamp(0),
  77   fBunchCrossNumber(0),
  78   fPrimaryVertexMask(0),
  79   fTriggerMask(0),
  80   fNTriggerClasses(0),
  81   fNPrimaryVertices(0),
  82   fNTracks(0),
  83   fNV0s(0),
  84   fTriggerPointer(0),
  85   fPrimaryVertexPointer(0),
  86   fTracksPointer(0),
  87   fV0Pointer(0)
  88 {
  89   // Default constructor
  90   fContent[0]=0;
  91 }
  92
  93 /*
  94 // _______________________________________________________________________________________________________
  95 AliFlatESDEvent::AliFlatESDEvent(AliESDEvent *esd) :
  96   fSize(0),
  97   fMagneticField(0),
  98   fPeriodNumber(0),
  99   fRunNumber(0),
 100   fOrbitNumber(0),
 101   fTimeStamp(0),
 102   fBunchCrossNumber(0),
 103   fPrimaryVertexMask(0),
 104   fTriggerMask(0),
 105   fNTriggerClasses(0),
 106   fNPrimaryVertices(0),
 107   fNTracks(0),
 108   fNV0s(0),
 109   fTriggerPointer(0),
 110   fPrimaryVertexPointer(0),
 111   fTracksPointer(0),
 112   fV0Pointer(0)
 113 {
 114   fContent[0]=0;
 115   Fill(esd);
 116 }
 117
 118 // _______________________________________________________________________________________________________
 119 AliFlatESDEvent::AliFlatESDEvent(AliESDEvent *esd, Bool_t useESDFriends) :
 120   // Constructor
 121   fPrimaryVertexMask(0),
 122   fNTracks(0),
 123   fTracksPointer(0),
 124   fNV0s(0),
 125   fV0Pointer(0),
 126   fSize(0),
 127   fMagneticField(0),
 128   fPeriodNumber(0),
 129   fRunNumber(0),
 130   fOrbitNumber(0),
 131   fBunchCrossNumber(0),
 132   fTimeStamp(0),
 133   fContent()
 134 {
 135   Fill(esd, useESDFriends);
 136 }
 137 */
 138
 139 // _______________________________________________________________________________________________________
 140 AliFlatESDEvent::~AliFlatESDEvent()
 141 {
 142   // Destructor
 143 }
 144
 145 void AliFlatESDEvent::Init()
 146 {
 147   // Init
 148
 149   fContentSize = 0;
 150   fMagneticField = 0;
 151   fPeriodNumber = 0;
 152   fRunNumber = 0;
 153   fOrbitNumber = 0;
 154   fTimeStamp = 0;
 155   fBunchCrossNumber = 0;
 156   fPrimaryVertexMask = 0;
 157   fTriggerMask = 0;
 158   fNTriggerClasses = 0;
 159   fNPrimaryVertices = 0;
 160   fNTracks = 0;
 161   fNV0s = 0;
 162   fTriggerPointer = 0;
 163   fPrimaryVertexPointer = 0;
 164   fTracksPointer = 0;
 165   fV0Pointer = 0;
 166 }
 167
 168 // _______________________________________________________________________________________________________
 169   ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t useESDFriends, Bool_t fillV0s)
 170 {
 171   // Estimate upper limit of the object size
 172   // -> Added objects have to be added here as well
 173
 174   ULong64_t size = sizeof(AliFlatESDEvent);
 175   size += 2 * sizeof( AliFlatESDVertex );
 176   size += esd->GetNumberOfTracks() * AliFlatESDTrack::EstimateSize(useESDFriends);
 177   if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0);
 178   return size;
 179 }
 180
 181 void AliFlatESDEvent::FillPrimaryVertices( const AliESDVertex *vertexSPD,
 182                                             const AliESDVertex *vertexTracks )
 183 {
 184   // fill primary vertices
 185
 186   fPrimaryVertexMask = 0;
 187   fContentSize = 0;
 188
 189   Byte_t flag = 0x1;
 190   FillPrimaryVertex(vertexSPD, flag);
 191
 192   flag = 0x2;
 193   FillPrimaryVertex(vertexTracks, flag);
 194
 195   fTracksPointer = fContentSize;
 196   fV0Pointer = fContentSize;
 197 }
 198
 199 void AliFlatESDEvent::FillPrimaryVertex(const AliESDVertex *v, Byte_t flag)
 200 {
 201
 202   // Fill primary vertex parameters
 203
 204   if (!v) return;
 205
 206   AliFlatESDVertex *vtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
 207   vtx->Set( *v );
 208   fPrimaryVertexMask |= flag;
 209   fContentSize += sizeof(AliFlatESDVertex);
 210 }
 211
 212
 213 Int_t AliFlatESDEvent::FillNextTrack( const AliESDtrack* esdTrack, AliESDfriendTrack* friendTrack)
 214 {
 215   // fill next track
 216
 217   AliFlatESDTrack *flatTrack = reinterpret_cast<AliFlatESDTrack*>(fContent+fContentSize);
 218   //new (flatTrack) AliFlatESDTrack;
 219   flatTrack->Fill(esdTrack, friendTrack);
 220   fContentSize += flatTrack->GetSize();
 221   ++fNTracks;
 222   return 0;
 223 }
 224
 225 Int_t AliFlatESDEvent::AddTriggerClass(  const char *TriggerClassName, Int_t TriggerIndex, ULong64_t MaxSize )
 226 {
 227   // add trigger class
 228   AliFlatESDTrigger *flatTrigger = reinterpret_cast<AliFlatESDTrigger*>(fContent+fContentSize);
 229   Int_t err = flatTrigger->SetTriggerClass( TriggerClassName, TriggerIndex, MaxSize );
 230   if( err==0 ){
 231     fContentSize+= flatTrigger->GetSize();
 232     fNTriggerClasses++;
 233   }
 234   return err;
 235 }
 236
 237
 238 // _______________________________________________________________________________________________________
 239 Int_t AliFlatESDEvent::FillFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t useESDFriends, const Bool_t fillV0s)
 240 {
 241   // Fill flat ESD event from normal ALiESDEvent
 242   // - Fill tracks + friends (if requested)
 243   // -> Added objects have to be added here as well
 244
 245 #ifdef xxx
 246   if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
 247
 248   Init();
 249
 250   if( !esd ) return 0;
 251
 252   Int_t err = 0;
 253   size_t freeSpace = allocatedMemorySize - GetSize();
 254
 255   // fill run info
 256   {
 257     SetTriggerMask( esd->GetTriggerMask() );
 258   }
 259
 260
 261   // Fill trigger information
 262   {
 263     size_t triggerSize = 0;
 264     int nTriggers = 0;
 265     AliFlatESDTrigger *trigger = FillTriggersStart();
 266     const AliESDRun*  esdRun = esd->GetESDRun();
 267     if( esdRun ){
 268       for( int index=0; index<AliESDRun::kNTriggerClasses; index++){
 269         const char* name = esdRun->GetTriggerClass(index);
 270         if( name && name[0]!='\0' ){
 271           err = trigger->SetTriggerClass( name, index, freeSpace );
 272           if( err!=0 ) return err;
 273           nTriggers++;
 274           freeSpace -= trigger->GetSize();
 275           triggerSize += trigger->GetSize();
 276           trigger = trigger->GetNextTrigger();
 277         }
 278       }
 279     }
 280     FillTriggersEnd( nTriggers, triggerSize );
 281   }
 282
 283   // fill primary vertices
 284
 285
 286   err = FillPrimaryVertices( freeSpace, esd->GetPrimaryVertexSPD(), esd->GetPrimaryVertexTracks() );
 287
 288   if( err!=0 ) return err;
 289
 290   freeSpace = allocatedMemorySize - GetSize();
 291
 292
 293  ULong64_t GetTriggerMask() const {return fHeader?fHeader->GetTriggerMask():0;}
 294   TString   GetFiredTriggerClasses() const {return (fESDRun&&fHeader)?fESDRun->GetFiredTriggerClasses(fHeader->GetTriggerMask()):"";}
 295   Bool_t    IsTriggerClassFired(const char *name) const {return (fESDRun&&fHeader)?fESDRun->IsTriggerClassFired(fHeader->GetTriggerMask(),name):kFALSE;}
 296
 297   const AliHLTCTPData* pCTPData=CTPData();
 298   if (pCTPData) {
 299     AliHLTUInt64_t mask=pCTPData->ActiveTriggers(trigData);
 300     for (int index=0; index<gkNCTPTriggerClasses; index++) {
 301       if ((mask&((AliHLTUInt64_t)0x1<<index)) == 0) continue;
 302       pESD->SetTriggerClass(pCTPData->Name(index), index);
 303     }
 304     pESD->SetTriggerMask(mask);
 305   }
 306
 307
 308   //allocatedMemorySize - GetSize();
 309
 310   FillTriggersEnd(nTriggers, triggerSize );
 311
 312   // -- Get ESD friends
 313   // -------------------------------------------------------
 314   Bool_t connectESDFriends = useESDFriends;
 315   AliESDfriend* esdFriend  = NULL;
 316
 317    if (connectESDFriends) {
 318     esdFriend = dynamic_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
 319     if (!esdFriend) {
 320       connectESDFriends = kFALSE;
 321       Printf("WARNING: friends not available, cluster information will not be included");
 322     }
 323     else
 324       Printf("INFO: friends are available, cluster information will be included");
 325   }
 326
 327   // -- Track loop, fill AliFlatESDTrack sub structure
 328   // -------------------------------------------------------
 329   for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) {
 330     AliESDtrack       *esdTrack    = esd->GetTrack(idxTrack);
 331     AliESDfriendTrack *friendTrack = NULL;
 332
 333     if (esdTrack) {
 334       if (connectESDFriends){
 335         friendTrack = esdFriend->GetTrack(idxTrack);
 336       }
 337       FillNextTrack( esdTrack, friendTrack);
 338     }
 339   }
 340
 341   // Fill V0s
 342
 343   fV0Pointer = fContentSize;
 344   fNV0s = 0;
 345   if( fillV0s ){
 346     for( int i=0; i < esd->GetNumberOfV0s(); i++){
 347       AliESDv0 *esdV0 = esd->GetV0( i );
 348       AliFlatESDV0 *v0 = GetNextV0Pointer();
 349       if( !v0 ) continue;
 350       v0->fNegTrackID = esdV0->GetNindex();
 351       v0->fPosTrackID = esdV0->GetNindex();
 352       StoreLastV0();
 353     }
 354   }
 355 #endif
 356   return 0;
 357 }
 358
 359 UInt_t AliFlatESDEvent::CountBits(Byte_t field, UInt_t mask) const {
 360   // Count bits in field
 361   UInt_t count = 0;
 362   UInt_t reg = 0x0;
 363
 364   reg |= field;
 365   reg &= mask;
 366
 367   for (count = 0; reg; count++)
 368     reg &= reg - 1;
 369
 370   return count;
 371 }