added friends to compare component
[u/mrichter/AliRoot.git] / HLT / global / AliFlatESDFriend.h
1 #ifndef ALIFLATESDFRIEND_H
2 #define ALIFLATESDFRIEND_H
3
4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  * See cxx source for full Copyright notice                               *
6  * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli     */
7
8 /*
9  * See implementation file for documentation
10  */
11
12 #include "Rtypes.h"
13 #include "AliVMisc.h"
14 #include "AliVfriendEvent.h"
15 #include "AliFlatESDFriendTrack.h"
16
17
18 class AliESDfriend;
19 //class AliESDVZEROfriend;
20 //class AliESDTZEROfriend;
21
22
23 //_____________________________________________________________________________
24 class AliFlatESDFriend : public AliVfriendEvent {
25 public:
26   AliFlatESDFriend();
27   ~AliFlatESDFriend() {}
28  
29    // constructor and method for reinitialisation of virtual table
30    AliFlatESDFriend( AliVConstructorReinitialisationFlag );
31    void Reinitialize(){ new (this) AliFlatESDFriend(AliVReinitialize); }
32
33   // Implementation of virtual methods of AliVfriend
34
35   Int_t GetNumberOfTracks() const { return fNTracks; }
36   const AliVfriendTrack* GetTrack(Int_t i) const {return GetFlatTrack(i); }
37   Int_t GetEntriesInTracks() const { return fNTrackEntries; }
38  
39   //AliESDVZEROfriend *GetVZEROfriend(){ return NULL; }
40   //AliESDTZEROfriend *GetTZEROfriend(){ return NULL; }
41
42   void Ls() const;
43   void Reset();
44
45   // bit manipulation for filtering
46   void SetSkipBit(Bool_t skip){ fBitFlags = skip; }
47   Bool_t TestSkipBit() const { return (fBitFlags!=0); }
48
49   //TPC cluster occupancy
50   Int_t GetNclustersTPC(UInt_t sector) const { return (sector<72)?fNclustersTPC[sector]:0; }
51   Int_t GetNclustersTPCused(UInt_t sector) const { return (sector<72)?fNclustersTPCused[sector]:0; }
52   
53   // -- Own methods  -- 
54
55   // Set methods
56
57   Int_t SetFromESDfriend( size_t allocatedMemorySize, const AliESDfriend *esdFriend );
58     
59   void SetNclustersTPC(UInt_t sector, Int_t occupancy ) { if (sector<72) fNclustersTPC[sector]=occupancy; }
60   void SetNclustersTPCused(UInt_t sector, Int_t occupancy ) {if (sector<72) fNclustersTPCused[sector]=occupancy; }
61
62   Int_t SetTracksStart( AliFlatESDFriendTrack* &t, Long64_t* &table, Int_t nTracks, size_t freeMem );
63   void  SetTracksEnd( Int_t nTracks, Int_t nTrackEntries, size_t tracksSize );
64
65   // other methods
66
67   const AliFlatESDFriendTrack  *GetFlatTrack( Int_t i ) const { 
68     const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
69     if( i<0 || i>fNTracks || table[i]<0 ) return NULL;
70     return reinterpret_cast<const AliFlatESDFriendTrack*>( fContent + table[i] );
71   }
72  
73   const AliFlatESDFriendTrack  *GetFlatTrackEntry( Int_t i ) const { 
74     if( i<0 || i>fNTrackEntries ) return NULL;
75     return reinterpret_cast<const AliFlatESDFriendTrack*>( fContent + i );
76   }
77
78   // -- Size methods
79
80   ULong64_t  GetSize()  const { return fContent - reinterpret_cast<const Byte_t*>(this) + fContentSize; }
81
82   static ULong64_t EstimateSize(AliESDfriend* esdFriend );
83
84 private: 
85
86   AliFlatESDFriend(const AliFlatESDFriend&);
87   AliFlatESDFriend& operator=(const AliFlatESDFriend& );  
88
89   AliFlatESDFriendTrack  *GetFlatTrackNonConst( Int_t i ){ 
90     const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
91     if( i<0 || i>fNTracks || table[i]<0 ) return NULL;
92     return reinterpret_cast<AliFlatESDFriendTrack*>( fContent + table[i] );
93   }
94
95   AliFlatESDFriendTrack  *GetFlatTrackEntryNonConst( Int_t i ){ 
96     if( i<0 || i>fNTrackEntries ) return NULL;
97     return reinterpret_cast< AliFlatESDFriendTrack*>( fContent + i );
98   }
99
100   size_t fContentSize;     // Size of fContent
101   UInt_t fBitFlags; // bit flags
102   Int_t fNTracks;                   // Number of tracks in vector
103   Int_t fNTrackEntries;             // Number of non-empty track friends in vector
104   Int_t fNclustersTPC[72]; //cluster occupancy per sector per sector
105   Int_t fNclustersTPCused[72]; //number of clusters used in tracking per sector
106  
107   // Pointers to specific data in fContent
108   
109   size_t fTrackTablePointer;     // position of the first track in fContent
110   size_t fTracksPointer;         // position of the first track in fContent
111
112   // -- Variable Size Object
113
114   Byte_t fContent[1];                  // Variale size object, which contains all data
115
116   ClassDef(AliFlatESDFriend,0)
117 };
118
119
120 inline AliFlatESDFriend::AliFlatESDFriend() 
121 :
122   fContentSize(0),
123   fBitFlags(0),
124   fNTracks(0),
125   fNTrackEntries(0),
126   fTrackTablePointer(0),
127   fTracksPointer(0)
128 {
129   // Default constructor
130   Reset();
131 }
132
133 inline void AliFlatESDFriend::Reset() 
134 {
135   fBitFlags = 0;
136   fNTracks = 0;
137   fNTrackEntries = 0; 
138   fTrackTablePointer = 0;
139   fTracksPointer = 0;
140   for( int i=0; i<72; i++ ){
141     fNclustersTPC[i]=0;
142     fNclustersTPCused[i]=0;
143   }
144   // We set size of the fContent array such, that it reaches the end of the AliFlatESDFriend structure. 
145   // To be sure that actual GetSize() is always >= size of the structure. 
146   // First, it makes the memory alignment better. Second, just for a case..
147   fContentSize = sizeof(AliFlatESDFriend) - (fContent - reinterpret_cast<const Byte_t*>(this));
148   for( UInt_t i=0; i<fContentSize; i++ ) fContent[i]=0;
149 }
150  
151 #pragma GCC diagnostic ignored "-Weffc++" 
152 inline AliFlatESDFriend::AliFlatESDFriend(AliVConstructorReinitialisationFlag f)
153 :
154   AliVfriendEvent(f)
155 {
156   //special constructor, used to restore the vtable pointer
157   for( int i=0; i<fNTrackEntries; i++ ){
158     AliFlatESDFriendTrack  *tr = GetFlatTrackEntryNonConst(i);
159     if( tr ) tr->Reinitialize();
160   }
161 }
162 #pragma GCC diagnostic warning "-Weffc++" 
163
164
165 inline Int_t AliFlatESDFriend::SetTracksStart( AliFlatESDFriendTrack* &t, Long64_t* &table, Int_t nTracks, size_t freeMem)
166 {
167   fNTracks = 0;
168   fNTrackEntries = 0;
169   if( nTracks*sizeof(Long64_t)  > freeMem ) return -1;
170   fTrackTablePointer = fContentSize;
171   fContentSize += nTracks*sizeof(Long64_t);
172   fTracksPointer = fContentSize;
173   table = reinterpret_cast< Long64_t* >( fContent + fTrackTablePointer );
174   t = reinterpret_cast< AliFlatESDFriendTrack* >( fContent + fTracksPointer );
175   return 0;
176 }
177
178 inline void AliFlatESDFriend::SetTracksEnd( Int_t nTracks, Int_t nTrackEntries, size_t tracksSize )
179 {
180   if( nTracks<0 ) return;
181   Long64_t *table = reinterpret_cast< Long64_t*> (fContent + fTrackTablePointer);
182   for( int i=0; i<nTracks; i++ ) table[i]+=fTracksPointer;
183   fNTracks = nTracks;
184   fNTrackEntries = nTrackEntries;
185   fContentSize += tracksSize;
186 }
187
188 #endif