When Pt is bad defined (ex. no field), the multiple scattering effect is calculated...
[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliHLTTPCCASliceOutput.cxx
1 // @(#) $Id$
2 // **************************************************************************
3 // This file is property of and copyright by the ALICE HLT Project          *
4 // ALICE Experiment at CERN, All rights reserved.                           *
5 //                                                                          *
6 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 //                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
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
20 #include "AliHLTTPCCASliceOutput.h"
21 #include "MemoryAssignmentHelpers.h"
22
23
24 GPUhd() int AliHLTTPCCASliceOutput::EstimateSize( int nOfTracks, int nOfTrackClusters )
25 {
26   // calculate the amount of memory [bytes] needed for the event
27
28   const int kClusterDataSize = sizeof(  int ) + sizeof( unsigned short ) + sizeof( float2 ) + sizeof( float ) + sizeof( UChar_t ) + sizeof( UChar_t );
29
30   return sizeof( AliHLTTPCCASliceOutput ) + sizeof( AliHLTTPCCASliceTrack )*nOfTracks + kClusterDataSize*nOfTrackClusters;
31 }
32
33 #ifndef HLTCA_GPUCODE
34
35 template<typename T> inline void AssignNoAlignment( T *&dst, char *&mem, int count )
36 {
37   // assign memory to the pointer dst
38   dst = ( T* ) mem;
39   mem = ( char * )( dst + count );
40 }
41
42 void AliHLTTPCCASliceOutput::SetPointers(int nTracks, int nTrackClusters, const outputControlStruct* outputControl)
43 {
44   // set all pointers
45         if (nTracks == -1) nTracks = fNTracks;
46         if (nTrackClusters == -1) nTrackClusters = fNTrackClusters;
47
48   char *mem = fMemory;
49
50   if (outputControl == NULL || outputControl->fDefaultOutput)
51   {
52           AssignNoAlignment( fTracks,            mem, nTracks );
53           AssignNoAlignment( fClusterUnpackedYZ, mem, nTrackClusters );
54           AssignNoAlignment( fClusterUnpackedX,  mem, nTrackClusters );
55           AssignNoAlignment( fClusterId,         mem, nTrackClusters );
56           AssignNoAlignment( fClusterPackedYZ,   mem, nTrackClusters );
57           AssignNoAlignment( fClusterRow,        mem, nTrackClusters );
58           AssignNoAlignment( fClusterPackedAmp,  mem, nTrackClusters );
59   }
60
61   if (outputControl == NULL || outputControl->fObsoleteOutput)
62   {
63           // memory for output tracks
64           AssignMemory( fOutTracks, mem, nTracks );
65           // arrays for track hits
66           AssignMemory( fOutTrackHits, mem, nTrackClusters );
67   }
68   if ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput) > fMemorySize)
69   {
70           fMemorySize = NULL;
71           //printf("\nINTERNAL ERROR IN AliHLTTPCCASliceOutput MEMORY MANAGEMENT req: %d avail: %d\n", (int) ((size_t) (mem - fMemory) + sizeof(AliHLTTPCCASliceOutput)), (int) fMemorySize);
72   }
73 }
74
75 void AliHLTTPCCASliceOutput::Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits, outputControlStruct* outputControl)
76 {
77         //Allocate All memory needed for slice output
78   const int memsize = (outputControl->fDefaultOutput ? EstimateSize(nTracks, nTrackHits) : sizeof(AliHLTTPCCASliceOutput)) +
79           (outputControl->fObsoleteOutput? (nTracks * sizeof(AliHLTTPCCAOutTrack) + nTrackHits * sizeof(int)) : 0);
80   if (outputControl->fOutputPtr)
81   {
82           if (outputControl->fOutputMaxSize < memsize)
83           {
84                   ptrOutput = NULL;
85                   return;
86           }
87         ptrOutput = (AliHLTTPCCASliceOutput*) outputControl->fOutputPtr;
88         outputControl->fOutputPtr += memsize;
89         outputControl->fOutputMaxSize -= memsize;
90   }
91   else
92   {
93     if (ptrOutput) free(ptrOutput);
94         ptrOutput = (AliHLTTPCCASliceOutput*) malloc(memsize);
95   }
96   ptrOutput->SetMemorySize(memsize);
97   ptrOutput->SetPointers(nTracks, nTrackHits, outputControl); // set pointers
98 }
99 #endif