flat friend update
authorsgorbuno <Sergey.Gorbunov@cern.ch>
Mon, 22 Sep 2014 19:10:57 +0000 (21:10 +0200)
committersgorbuno <Sergey.Gorbunov@cern.ch>
Mon, 22 Sep 2014 19:10:57 +0000 (21:10 +0200)
14 files changed:
HLT/global/AliFlatESDEvent.cxx
HLT/global/AliFlatESDFriend.cxx
HLT/global/AliFlatESDFriend.h
HLT/global/AliFlatESDFriendTrack.cxx
HLT/global/AliFlatESDFriendTrack.h
HLT/global/AliFlatESDTrack.h
HLT/global/AliFlatESDTrigger.h
HLT/global/AliFlatESDV0.h
HLT/global/AliFlatESDVertex.h
HLT/global/AliFlatExternalTrackParam.h
HLT/global/AliFlatTPCCluster.h
HLT/global/AliFlatTPCseed.cxx
HLT/global/AliFlatTPCseed.h
STEER/STEERBase/AliVfriendEvent.h

index f452b99..a6bd777 100644 (file)
@@ -96,34 +96,12 @@ AliFlatESDEvent::AliFlatESDEvent()
   fContent[0]=0;
 }
 
-
+#pragma GCC diagnostic ignored "-Weffc++" 
 AliFlatESDEvent::AliFlatESDEvent( AliVConstructorReinitialisationFlag /*f*/ ) 
-//  :
-//  fContentSize(fContentSize),
-//  fMagneticField(fMagneticField),
-//  fPeriodNumber(fPeriodNumber),
-//  fRunNumber(fRunNumber),
-//  fOrbitNumber(fOrbitNumber),
-//  fTimeStamp(fTimeStamp),
-//  fEventSpecie(fEventSpecie),
-//  fBunchCrossNumber(fBunchCrossNumber),
-//  fPrimaryVertexMask(fPrimaryVertexMask),
-//  fTriggerMask(fTriggerMask),
-//  fTriggerMaskNext50(fTriggerMaskNext50),
-//  fNTriggerClasses(fNTriggerClasses),
-//  fNPrimaryVertices(fNPrimaryVertices),
-//  fNTracks(fNTracks),
-//  fNV0s(fNV0s),
-//  fTriggerPointer(fTriggerPointer),
-//  fPrimaryVertexTracksPointer(fPrimaryVertexTracksPointer),
-//  fPrimaryVertexSPDPointer(fPrimaryVertexSPDPointer),
-//  fTrackTablePointer(fTrackTablePointer),
-//  fTracksPointer(fTracksPointer),
-//  fV0Pointer(fV0Pointer),
-//  fFriendEvent(NULL)
+  :
+ fFriendEvent(NULL)
 {
   // Constructor for reinitialisation of vtable
-
   
   // Reinitialise trigger information  
   {
@@ -163,6 +141,7 @@ AliFlatESDEvent::AliFlatESDEvent( AliVConstructorReinitialisationFlag /*f*/ )
     }
   }
 }
+#pragma GCC diagnostic warning "-Weffc++" 
 
 
 TString AliFlatESDEvent::GetFiredTriggerClasses() const 
index ac68d2b..5e3bd93 100644 (file)
 #include "AliESDfriend.h"
 
 // _______________________________________________________________________________________________________
-AliFlatESDFriend::AliFlatESDFriend() :
-  fContentSize(0),
-  fBitFlags(0),
-  fNTracks(0),
-  fNTrackEntries(0),
-  fTrackTablePointer(0),
-  fTracksPointer(0)
-{
-  // Default constructor
-  Reset();
-}
 
-void AliFlatESDFriend::Reset() 
-{
-  fBitFlags = 0;
-  fNTracks = 0;
-  fNTrackEntries = 0; 
-  fTrackTablePointer = 0;
-  fTracksPointer = 0;
-  for( int i=0; i<72; i++ ){
-    fNclustersTPC[i]=0;
-    fNclustersTPCused[i]=0;
-  }
-  // We set size of the fContent array such, that it reaches the end of the AliFlatESDFriend structure. 
-  // To be sure that actual GetSize() is always >= size of the structure. 
-  // First, it makes the memory alignment better. Second, just for a case..
-  fContentSize = sizeof(AliFlatESDFriend) - (fContent - reinterpret_cast<const Byte_t*>(this));
-  for( UInt_t i=0; i<fContentSize; i++ ) fContent[i]=0;
-}
-// _______________________________________________________________________________________________________
-AliFlatESDFriend::AliFlatESDFriend(AliVConstructorReinitialisationFlag f)
-:
-AliVfriendEvent()
-//  fContentSize(),
-//  fBitFlags(),
-//  fNTracks(),
-//  fNTrackEntries(),
-//  fTrackTablePointer(),
-//  fTracksPointer()
-{
-  //special constructor, used to restore the vtable pointer
-  //uses the special dummy constructors of contained objects
 
-  // the vtable pointer for this AliFlatESDFriend object is already reset when this constructor is called
-  // we should only initialise vtable pointers for all contained objects
 
-  if(f == AliVReinitialize){   
-    for( int i=0; i<fNTracks; i++ ){
-      AliFlatESDFriendTrack  *tr = GetFlatTrackNonConst(i);
-      if( tr ) tr->Reinitialize();
-    }
-  }
-  else{
-    AliFlatESDFriend();
-  }
-}
+
+
 
 void AliFlatESDFriend::Ls() const
 {
@@ -106,6 +54,7 @@ void AliFlatESDFriend::Ls() const
 
 
 // _______________________________________________________________________________________________________
+
 Int_t AliFlatESDFriend::SetFromESDfriend( const size_t allocatedMemorySize, const AliESDfriend *esdFriend )
 {
   // Fill flat ESD friend from ALiESDfriend
index 6eb0da4..48b6fd7 100644 (file)
@@ -69,6 +69,11 @@ public:
     if( i<0 || i>fNTracks || table[i]<0 ) return NULL;
     return reinterpret_cast<const AliFlatESDFriendTrack*>( fContent + table[i] );
   }
+  const AliFlatESDFriendTrack  *GetFlatTrackEntry( Int_t i ) const { 
+    if( i<0 || i>fNTrackEntries ) return NULL;
+    return reinterpret_cast<const AliFlatESDFriendTrack*>( fContent + i );
+  }
 
   // -- Size methods
 
@@ -86,6 +91,11 @@ private:
     return reinterpret_cast<AliFlatESDFriendTrack*>( fContent + table[i] );
   }
 
+  AliFlatESDFriendTrack  *GetFlatTrackEntryNonConst( Int_t i ){ 
+    if( i<0 || i>fNTrackEntries ) return NULL;
+    return reinterpret_cast< AliFlatESDFriendTrack*>( fContent + i );
+  }
+
   size_t fContentSize;     // Size of fContent
   UInt_t fBitFlags; // bit flags
   Int_t fNTracks;                   // Number of tracks in vector
@@ -106,6 +116,51 @@ private:
 };
 
 
+inline AliFlatESDFriend::AliFlatESDFriend() 
+:
+  fContentSize(0),
+  fBitFlags(0),
+  fNTracks(0),
+  fNTrackEntries(0),
+  fTrackTablePointer(0),
+  fTracksPointer(0)
+{
+  // Default constructor
+  Reset();
+}
+
+inline void AliFlatESDFriend::Reset() 
+{
+  fBitFlags = 0;
+  fNTracks = 0;
+  fNTrackEntries = 0; 
+  fTrackTablePointer = 0;
+  fTracksPointer = 0;
+  for( int i=0; i<72; i++ ){
+    fNclustersTPC[i]=0;
+    fNclustersTPCused[i]=0;
+  }
+  // We set size of the fContent array such, that it reaches the end of the AliFlatESDFriend structure. 
+  // To be sure that actual GetSize() is always >= size of the structure. 
+  // First, it makes the memory alignment better. Second, just for a case..
+  fContentSize = sizeof(AliFlatESDFriend) - (fContent - reinterpret_cast<const Byte_t*>(this));
+  for( UInt_t i=0; i<fContentSize; i++ ) fContent[i]=0;
+}
+#pragma GCC diagnostic ignored "-Weffc++" 
+inline AliFlatESDFriend::AliFlatESDFriend(AliVConstructorReinitialisationFlag f)
+:
+  AliVfriendEvent(f)
+{
+  //special constructor, used to restore the vtable pointer
+  for( int i=0; i<fNTrackEntries; i++ ){
+    AliFlatESDFriendTrack  *tr = GetFlatTrackEntryNonConst(i);
+    if( tr ) tr->Reinitialize();
+  }
+}
+#pragma GCC diagnostic warning "-Weffc++" 
+
+
 inline Int_t AliFlatESDFriend::SetTracksStart( AliFlatESDFriendTrack* &t, Long64_t* &table, Int_t nTracks, size_t freeMem)
 {
   fNTracks = 0;
index 53f0425..0367608 100644 (file)
  AliFlatESDFriendTrack::AliFlatESDFriendTrack()
 :
  AliVfriendTrack()
-// ,fContentSize(0),
-// fTPCOutPointer(-1),
-// fITSOutPointer(-1),
-// fTRDInPointer(-1),
-// fTPCseedPointer(-1),
-// fBitFlags(0)
+ ,fContentSize(0),
+ fTPCOutPointer(-1),
+ fITSOutPointer(-1),
+ fTRDInPointer(-1),
+ fTPCseedPointer(-1),
+ fBitFlags(0)
 {
   // Default constructor
   fContent[0]=0;
 }
 
+#pragma GCC diagnostic ignored "-Weffc++" 
 AliFlatESDFriendTrack::AliFlatESDFriendTrack( AliVConstructorReinitialisationFlag f ) 
-:
-AliVfriendTrack( f )
-// ,fContentSize(fContentSize),
-// fTPCOutPointer(fTPCOutPointer),
-// fITSOutPointer(fITSOutPointer),
-// fTRDInPointer(fTRDInPointer),
-// fTPCseedPointer(fTPCseedPointer),
-// fBitFlags(fBitFlags)
+  :
+  AliVfriendTrack( f )
 {
   // constructor for reinitialisation of vtable
+  if( fTPCseedPointer >= 0 ){
+    AliFlatTPCseed *fp = reinterpret_cast< AliFlatTPCseed* >( fContent + fTPCseedPointer );
+    fp->Reinitialize();
+  }
 }
+#pragma GCC diagnostic warning "-Weffc++" 
 
 void AliFlatESDFriendTrack::Reset()
 {
index f0957ee..3abc333 100644 (file)
 
 #include "Rtypes.h"
 
-#include "AliFlatTPCCluster.h"
 #include "AliVfriendTrack.h"
 #include "AliVMisc.h"
-#include "AliFlatExternalTrackParam.h"
 #include "AliFlatTPCseed.h"
 
 class AliESDtrack;
@@ -105,10 +103,11 @@ class AliFlatESDFriendTrack :public AliVfriendTrack
   
   Byte_t fContent[1];                  // Variale size object, which contains all data
 
-  ClassDef(AliFlatESDFriendTrack, 0)
+  //ClassDef(AliFlatESDFriendTrack, 0)
 
 };
 
+/*
 inline Int_t AliFlatESDFriendTrack::GetTrackParam( Long64_t ptr, AliExternalTrackParam &param ) const
 {
   if( ptr<0 ) return -1;
@@ -144,5 +143,5 @@ inline Int_t AliFlatESDFriendTrack::GetTPCseed( AliTPCseed &s ) const
   fp->GetTPCseed( &s );
   return 0;
 }
-
+*/
 #endif
index 847c668..985b480 100644 (file)
@@ -176,15 +176,14 @@ inline AliFlatESDTrack::AliFlatESDTrack() :
   // Default constructor
 }
 
-inline AliFlatESDTrack::AliFlatESDTrack( AliVConstructorReinitialisationFlag )
-//  :
-//  fTrackParamMask(fTrackParamMask ),
-//  fNTPCClusters( fNTPCClusters ),
-//  fNITSClusters( fNITSClusters ),
-//  fContentSize( fContentSize )
+#pragma GCC diagnostic ignored "-Weffc++" 
+inline AliFlatESDTrack::AliFlatESDTrack( AliVConstructorReinitialisationFlag f )
+ :
+ AliVTrack(f)
 {
   // Constructor for reinitialisation of vtable
 }
+#pragma GCC diagnostic warning "-Weffc++" 
 
 inline UInt_t AliFlatESDTrack::CountBits(Byte_t field, UInt_t mask) {
   // Count bits in field
index 68157ba..31c4b9b 100644 (file)
@@ -87,14 +87,10 @@ inline AliFlatESDTrigger::~AliFlatESDTrigger()
   // Destructor  
 }
 
-inline AliFlatESDTrigger::AliFlatESDTrigger( AliVConstructorReinitialisationFlag ) 
-//  :
-//  fContentSize(fContentSize),
-//  fTriggerIndex(fTriggerIndex)
-{
-  // do nothing
-}
+#pragma GCC diagnostic ignored "-Weffc++" 
+inline AliFlatESDTrigger::AliFlatESDTrigger( AliVConstructorReinitialisationFlag ) {} // do nothing
+#pragma GCC diagnostic warning "-Weffc++" 
+
 inline Int_t AliFlatESDTrigger::SetTriggerClass(  const char *TriggerClassName, Int_t TriggerIndex, ULong64_t MaxSize )
 {
   // Set trigger class, returns non-zero when the memory needed exeeeds MaxSize
index 02f5b84..b776675 100644 (file)
@@ -22,9 +22,7 @@ class AliFlatESDV0
   ~AliFlatESDV0(){}
  
   // constructor and method for reinitialisation of virtual table
-  AliFlatESDV0( AliVConstructorReinitialisationFlag )
-  //  : fNegTrackID(fNegTrackID), fPosTrackID(fPosTrackID) 
-  {}
+  AliFlatESDV0( AliVConstructorReinitialisationFlag );
   void Reinitialize() const {} // no virtual table - do nothing
  
   //--
@@ -51,4 +49,8 @@ class AliFlatESDV0
   Int_t fPosTrackID;
 };
 
+#pragma GCC diagnostic ignored "-Weffc++" 
+inline AliFlatESDV0::AliFlatESDV0( AliVConstructorReinitialisationFlag ){} 
+#pragma GCC diagnostic warning "-Weffc++" 
+
 #endif
index 7cbf2ac..74b3ab6 100644 (file)
@@ -109,15 +109,9 @@ fChi2(0)
   for( int i=0; i<6; i++) fCov[i] = -9999;
 }
 
-inline AliFlatESDVertex::AliFlatESDVertex( AliVConstructorReinitialisationFlag )
-//: 
-//fNContributors(fNContributors), 
-//fChi2(fChi2)
-{
-  // do nothing
-  for( int i=0; i<3; i++) fPosition[i] = fPosition[i];
-  for( int i=0; i<6; i++) fCov[i] = fCov[i];
-}
+#pragma GCC diagnostic ignored "-Weffc++" 
+inline AliFlatESDVertex::AliFlatESDVertex( AliVConstructorReinitialisationFlag ){}  // do nothing
+#pragma GCC diagnostic warning "-Weffc++" 
 
 inline void AliFlatESDVertex::SetFromESDVertex(const AliESDVertex &v )
 {
index 7df4941..9cea8c0 100644 (file)
 #include "Rtypes.h"
 #include "AliExternalTrackParam.h"
 
-struct AliFlatExternalTrackParam
+class AliFlatExternalTrackParam
 {
-  Float_t fAlpha;     // azimuthal angle of reference frame
-  Float_t fX;         // x: radial distance
-  Float_t fY;         // local Y-coordinate of a track (cm)
-  Float_t fZ;         // local Z-coordinate of a track (cm)
-  Float_t fSnp;       // local sine of the track momentum azimuthal angle
-  Float_t fTgl;       // tangent of the track momentum dip angle
-  Float_t fSigned1Pt; // 1/pt (1/(GeV/c))
-  Float_t fC[15];     // covariance matrix
+ public:
+
+  AliFlatExternalTrackParam();
+  ~AliFlatExternalTrackParam() {}
 
+  // constructor and method for reinitialisation of virtual table
+  AliFlatExternalTrackParam( AliVConstructorReinitialisationFlag );
+  void Reinitialize() { new (this) AliFlatExternalTrackParam( AliVReinitialize ); }
   void SetAlpha(Float_t alpha)             {fAlpha = alpha;}
   void SetX(Float_t x)                     {fX = x;}
   void SetY(Float_t y)                     {fY = y;}
@@ -47,9 +47,35 @@ struct AliFlatExternalTrackParam
   }
   void GetExternalTrackParam( AliExternalTrackParam &p ) const;
   void SetExternalTrackParam( const AliExternalTrackParam *p );
+
+ private:
+
+  Float_t fAlpha;     // azimuthal angle of reference frame
+  Float_t fX;         // x: radial distance
+  Float_t fY;         // local Y-coordinate of a track (cm)
+  Float_t fZ;         // local Z-coordinate of a track (cm)
+  Float_t fSnp;       // local sine of the track momentum azimuthal angle
+  Float_t fTgl;       // tangent of the track momentum dip angle
+  Float_t fSigned1Pt; // 1/pt (1/(GeV/c))
+  Float_t fC[15];     // covariance matrix
 };
 
-typedef struct AliFlatExternalTrackParam AliFlatExternalTrackParam;
+inline AliFlatExternalTrackParam::AliFlatExternalTrackParam()
+ :
+ fAlpha(0),  
+ fX(0),                                 
+ fY(0),
+ fZ(0),
+ fSnp(0),
+ fTgl(0),
+ fSigned1Pt(0)
+{
+  for( int i=0; i<15; i++ ) fC[i]=0;
+}
+
+#pragma GCC diagnostic ignored "-Weffc++" 
+inline AliFlatExternalTrackParam::AliFlatExternalTrackParam( AliVConstructorReinitialisationFlag ){}
+#pragma GCC diagnostic warning "-Weffc++" 
 
 inline void AliFlatExternalTrackParam::GetExternalTrackParam( AliExternalTrackParam &p ) const
 {
index 2966066..c5b9c57 100644 (file)
 
 #include "Rtypes.h"
 #include "AliVMisc.h"
+#include "AliTPCclusterMI.h"
 
 class AliFlatTPCCluster
 {
   public:
 
-  AliFlatTPCCluster() : fX(0.), fY(0.), fZ(0.), fPadRow(0), fSigmaY2(0.), fSigmaZ2(0.), fCharge(0), fQMax(0) {}
+  AliFlatTPCCluster() : fX(0.), fY(0.), fZ(0.), fSector(0), fPadRow(0), fSigmaY2(0.), fSigmaZ2(0.), fCharge(0), fQMax(0) {}
+
+  AliFlatTPCCluster(AliVConstructorReinitialisationFlag ); // do nothing
+  void Reinitialize(){} // do nothing
+
   ~AliFlatTPCCluster() {}
 
   void SetX(Float_t x)             {fX = x;}
   void SetY(Float_t y)             {fY = y;}
   void SetZ(Float_t z)             {fZ = z;}
-  void SetPadRow(Short_t padrow)   {fPadRow = padrow;}
+  void SetSector(UShort_t sector)  {fSector = sector;}
+  void SetPadRow(UShort_t padrow)  {fPadRow = padrow;}
   void SetSigmaY2(Float_t sigmaY2) {fSigmaY2 = sigmaY2;}
   void SetSigmaZ2(Float_t sigmaZ2) {fSigmaZ2 = sigmaZ2;}
   void SetCharge(UShort_t charge)  {fCharge = charge;}
   void SetQMax(UShort_t qmax)      {fQMax = qmax;}
   
-  void Reinitialize(){} // do nothing
-
   Float_t  GetX()       const      {return fX;}
   Float_t  GetY()       const      {return fY;}
   Float_t  GetZ()       const      {return fZ;}
+  UShort_t GetSector()  const      {return fSector;}
   UShort_t GetPadRow()  const      {return fPadRow;}
   Float_t  GetSigmaY2() const      {return fSigmaY2;}
   Float_t  GetSigmaZ2() const      {return fSigmaZ2;}
   UShort_t GetCharge()  const      {return fCharge;}
   UShort_t GetQMax()    const      {return fQMax;}
 
+  void SetTPCCluster( const AliTPCclusterMI *c );
+  void GetTPCCluster( AliTPCclusterMI *c ) const;
 
-  static Bool_t SortClusters(const AliFlatTPCCluster &first, const AliFlatTPCCluster &second){
-    // Method to sort two clusters according to pad row
-    Int_t padrowfirst  = first.GetPadRow();  
-    Int_t padrowsecond = second.GetPadRow();
-    return (padrowfirst < padrowsecond);
-  }
-  
   private:
 
- AliFlatTPCCluster(AliVConstructorReinitialisationFlag )
- //  : fX(fX),fY(fY),fZ(fZ),fPadRow(fPadRow),fSigmaY2(fSigmaY2),fSigmaZ2(fSigmaZ2),fCharge(fCharge),fQMax(fQMax)
- {}
-
   Float_t fX;       // X coordinate in local coordinates
   Float_t fY;       // Y coordinate in local coordinates
   Float_t fZ;       // Z coordinate in local coordinates
-  UChar_t fPadRow;  // Pad row number
+  UChar_t fSector;  // TPC sector
+  UChar_t fPadRow;  // Pad row number withing the sector
   Float_t fSigmaY2; // error (former width) of the clusters
   Float_t fSigmaZ2; // error (former width) of the clusters
   UInt_t  fCharge;  // total charge of cluster
@@ -64,4 +63,35 @@ class AliFlatTPCCluster
   
 };
 
+#pragma GCC diagnostic ignored "-Weffc++" 
+inline AliFlatTPCCluster::AliFlatTPCCluster(AliVConstructorReinitialisationFlag ){}
+#pragma GCC diagnostic warning "-Weffc++" 
+
+inline void AliFlatTPCCluster::SetTPCCluster( const AliTPCclusterMI *c )
+{
+  SetX( c->GetX() );
+  SetY( c->GetY() );
+  SetZ( c->GetZ() );
+  SetSector( c->GetDetector() );
+  SetPadRow( c->GetRow() );
+  SetSigmaY2( c->GetSigmaY2() );
+  SetSigmaZ2( c->GetSigmaZ2() );
+  SetCharge( c->GetQ() );
+  SetQMax( c->GetMax() );
+}
+inline void AliFlatTPCCluster::GetTPCCluster( AliTPCclusterMI *c ) const
+{
+  if( !c ) return;
+  c->SetX( GetX() );
+  c->SetY( GetY() );
+  c->SetZ( GetZ() );
+  c->SetDetector( GetSector() );
+  c->SetRow( GetPadRow() );
+  c->SetSigmaY2( GetSigmaY2() );
+  c->SetSigmaZ2( GetSigmaZ2() );
+  c->SetQ( GetCharge() );
+  c->SetMax( GetQMax() );
+}
+
 #endif
index 82d9765..b42e8b3 100644 (file)
  **************************************************************************/
 
 #include "AliFlatTPCseed.h"
+#include "AliTPCseed.h"
+#include "AliHLTTPCTransform.h"
 #include "Riostream.h"
 
-AliFlatTPCseed::AliFlatTPCseed()
-  :
-  fContentSize(0)
-{
-  // constructor
-  fContent[0]=0;
-}
-
-void AliFlatTPCseed::Reset()
-{
-  // Reset
-}
 
 void AliFlatTPCseed::SetFromTPCseed( const AliTPCseed *p )
 {
   // initialise from AliTPCseed
 
+  Reset();
+  if( !p ) return;
+
+  fParam.SetExternalTrackParam(  p );
+  fLabel = p->GetLabel();
+  AliFlatTPCCluster *clusters = reinterpret_cast< AliFlatTPCCluster* >( fContent );  
+  for( Int_t irow=0; irow<160; irow++ ){
+    const AliTPCclusterMI *cl = p->GetClusterPointer(irow);
+    if( !cl ) continue;
+    AliFlatTPCCluster &flatCluster = clusters[fNTPCClusters];
+    flatCluster.SetTPCCluster( cl );
+    fNTPCClusters++;
+  }
 }
 
 void AliFlatTPCseed::GetTPCseed( AliTPCseed *p ) const
 {
-  // write to AliTPCseed
+   // write to AliTPCseed
+  if( !p ) return;
+  p->Reset();
+
+  AliTPCseed seed;
+
+  fParam.GetExternalTrackParam( seed );
+  seed.SetLabel(fLabel);  
+  seed.SetNumberOfClusters(fNTPCClusters);
+
+  AliTPCclusterMI clusters[fNTPCClusters];
+
+  const AliFlatTPCCluster *flatClusters = reinterpret_cast< const AliFlatTPCCluster* >( fContent );
 
+  for( Int_t ic=0; ic<fNTPCClusters; ic++){
+    const AliFlatTPCCluster &flatCluster = flatClusters[ic];    
+    flatCluster.GetTPCCluster( &(clusters[ic]) );
+    int sec = flatCluster.GetSector();
+    int row = flatCluster.GetPadRow();
+    if(sec >= 36) row = row + AliHLTTPCTransform::GetNRowLow();
+    if( row<160 ) seed.SetClusterPointer( row , &(clusters[ic]) );
+  }
+  new (p) AliTPCseed( seed, kTRUE ); // true means that p creates its own cluster objects
 }
index e44e711..5889736 100644 (file)
@@ -16,7 +16,6 @@
 #include "AliVfriendTrack.h"
 #include "AliVMisc.h"
 #include "AliFlatExternalTrackParam.h"
-#include "AliFlatTPCseed.h"
 
 class AliESDtrack;
 class AliESDfriendTrack;
@@ -44,12 +43,14 @@ class AliFlatTPCseed
   void SetFromTPCseed( const AliTPCseed *p );
   void GetTPCseed( AliTPCseed *p ) const;
 
-  
+  Int_t GetLabel() const { return fLabel; }
+  Int_t GetNClusters() const { return fNTPCClusters; }
+
   // --------------------------------------------------------------------------------
   // -- Size methods
 
   static size_t EstimateSize(){
-    return sizeof(AliFlatTPCseed) + 6*sizeof(AliFlatExternalTrackParam);
+    return sizeof(AliFlatTPCseed) + 160*sizeof(AliFlatTPCCluster);
   }
 
   size_t GetSize() const { return fContent -  reinterpret_cast<const Byte_t*>(this) + fContentSize; }
@@ -62,12 +63,46 @@ class AliFlatTPCseed
   // --------------------------------------------------------------------------------
 
   ULong64_t fContentSize;                      // Size of this object
-
+  
   // --------------------------------------------------------------------------------
   
+  AliFlatExternalTrackParam fParam;
+  Int_t fLabel;
+  Int_t fNTPCClusters;
   Byte_t fContent[1];                  // Variale size object, which contains all data
 
 };
 
+inline AliFlatTPCseed::AliFlatTPCseed()
+  :
+  fContentSize(0),
+  fParam(),
+  fLabel(-1),
+  fNTPCClusters(0)
+{
+  // constructor
+  fContent[0]=0;
+}
+
+#pragma GCC diagnostic ignored "-Weffc++" 
+inline AliFlatTPCseed::AliFlatTPCseed( AliVConstructorReinitialisationFlag  )
+{
+  // reinitialise vtable
+  fParam.Reinitialize();
+  AliFlatTPCCluster *clusters = reinterpret_cast< AliFlatTPCCluster* >( fContent );  
+  for( Int_t ic=0; ic<fNTPCClusters; ic++ ){
+    clusters[ic].Reinitialize();
+  }
+}
+#pragma GCC diagnostic warning "-Weffc++" 
+
+
+inline void AliFlatTPCseed::Reset()
+{
+  // Reset
+  fContentSize = 0;
+  fNTPCClusters = 0;
+  fLabel=-1;
+}
 
 #endif
index 32d6d62..421ba28 100644 (file)
@@ -2,6 +2,7 @@
 #define ALIVFRIENDEVENT_H
 
 #include "Rtypes.h"
+#include "AliVMisc.h"
 class AliVfriendTrack;
 
 //_____________________________________________________________________________
@@ -10,6 +11,10 @@ public:
   AliVfriendEvent() {}
   virtual ~AliVfriendEvent() {}
 
+  // constructor and method for reinitialisation of virtual table
+  AliVfriendEvent( AliVConstructorReinitialisationFlag );
+  void Reinitialize(){} // do nothing
+
   virtual Int_t GetNumberOfTracks() const = 0;
   virtual const AliVfriendTrack *GetTrack(Int_t /*i*/) const = 0;
   virtual Int_t GetEntriesInTracks() const = 0;
@@ -34,5 +39,9 @@ private:
   AliVfriendEvent& operator=(const AliVfriendEvent& esd);
 };
 
+#pragma GCC diagnostic ignored "-Weffc++" 
+inline AliVfriendEvent::AliVfriendEvent(AliVConstructorReinitialisationFlag ) {} // do nothing
+#pragma GCC diagnostic warning "-Weffc++" 
+
 #endif