bugfix: corrected stimated size for emulated tracks (Theodor)
[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDUtils.cxx
1 // $Id$
2 /**************************************************************************
3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4  *                                                                        *
5  * Author: The ALICE Off-line Project.                                    *
6  * Contributors are mentioned in the code where appropriate.              *
7  *                                                                        *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          *
14  * provided "as is" without express or implied warranty.                  *
15  **************************************************************************/
16
17 ///////////////////////////////////////////////////////////////////////////////
18 //                                                                           //
19 // HLT TRD Utillities Class                                                  //
20 //                                                                           //
21 ///////////////////////////////////////////////////////////////////////////////
22
23 #include "AliHLTTRDUtils.h"
24 #include <TClonesArray.h>
25 #include "AliHLTTRDTrack.h"
26 #include "AliHLTTRDTracklet.h"
27 #include "AliHLTTRDCluster.h"
28 #include "AliHLTExternalTrackParam.h"
29 #include "AliESDEvent.h"
30 #include "AliESDtrack.h"
31 #include "AliPID.h"
32
33 ClassImp(AliHLTTRDUtils)
34
35 AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr, Int_t nTimeBins)
36 {
37   AliTRDcluster* cluster = 0;
38   AliHLTUInt32_t addedSize = 0;
39   //  == OUTdatatype pointer
40   AliHLTTRDCluster* outPtr = (AliHLTTRDCluster*)outBlockPtr;
41   
42   if (inClusterArray){
43     Int_t nbEntries  = inClusterArray->GetEntries();
44     for (Int_t iCluster = 0; iCluster<nbEntries; iCluster++){
45       //cout << "Geting cluster #" << iCluster << endl;
46       
47       cluster = (AliTRDcluster*)(inClusterArray->At(iCluster));
48
49       AliHLTTRDCluster *hltCluster = new (outPtr) AliHLTTRDCluster(cluster);
50       //cout << Form("cluster added at 0x%x (%i)\n",outPtr,outPtr);
51
52       addedSize += sizeof(*hltCluster);
53       outBlockPtr += sizeof(*hltCluster);
54       outPtr = (AliHLTTRDCluster*)outBlockPtr;
55     }
56   }
57
58   Int_t *TBptr = (Int_t*)outPtr;
59   *TBptr = nTimeBins;
60   
61   addedSize += sizeof(*TBptr);
62   outBlockPtr += sizeof(*TBptr);
63
64   return addedSize;
65   
66 }
67
68 AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output, Int_t nTimeBins)
69 {
70   //cout << "\nWriting tracks to the Memory\n ============= \n";
71
72   Int_t *TBptr = (Int_t*)output;
73   *TBptr = nTimeBins;
74
75   AliTRDtrackV1* track = 0;
76   AliHLTUInt32_t addedSize = sizeof(*TBptr);
77   AliHLTUInt8_t* iterPtr = output+addedSize;
78   AliHLTTRDTrack* outPtr = (AliHLTTRDTrack*)iterPtr;
79
80   if (inTrackArray){
81     Int_t nbTracks  = inTrackArray->GetEntries();
82     for (Int_t iTrack = 0; iTrack<nbTracks; iTrack++){
83       AliHLTUInt32_t trackSize=0;
84       
85       track = (AliTRDtrackV1*)(inTrackArray->At(iTrack));
86       //track->Print();
87       
88       AliHLTTRDTrack *hltTrack = new (outPtr) AliHLTTRDTrack(track);
89       trackSize = hltTrack->GetSize();
90       addedSize += trackSize;
91       //HLTDebug("addedSize %i, trackSize %i", addedSize, trackSize);
92       
93       iterPtr += trackSize;
94       outPtr = (AliHLTTRDTrack*)iterPtr;
95     }
96   }
97   return addedSize;
98   
99 }
100
101 /**
102  * Read cluster to the TClonesArray from the memory 
103  */
104 //============================================================================
105 AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
106 {
107   //HLTDebug("\nReading clusters from the Memory\n ============= \n");
108   AliHLTTRDCluster * curCluster;
109   UInt_t clusterSize = sizeof(AliHLTTRDCluster), curSize = 0;
110   Int_t counter=outArray->GetEntriesFast();
111
112   if(nTimeBins){
113     *nTimeBins=*(Int_t*)(((AliHLTUInt8_t*)inputPtr)+size-sizeof(Int_t));
114     //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
115   }
116   size-=sizeof(*nTimeBins);
117
118   curCluster = (AliHLTTRDCluster*) inputPtr;
119   while (curSize < size)
120     {
121       //HLTDebug(" fX = %f; fY = %f; fZ = %f", curCluster->fX, curCluster->fY, curCluster->fZ);
122
123       AliTRDcluster* curTRDCluster = new((*outArray)[counter]) AliTRDcluster();
124       curCluster->ExportTRDCluster(curTRDCluster);
125       //HLTDebug(" fX = %f; fY = %f; fZ = %f", curTRDCluster->GetX(), curTRDCluster->GetY(), curTRDCluster->GetZ());
126       curSize += clusterSize; 
127       counter++;
128       curCluster++;
129       //cout << " current readed size is " << curSize << "/" << size << endl;
130     }
131   
132   return counter;
133 }
134
135 AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
136 {
137   if(nTimeBins){
138     *nTimeBins=*(Int_t*)inputPtr;
139     //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
140   }
141
142   AliHLTUInt8_t* iterPtr = ((AliHLTUInt8_t*)inputPtr)+sizeof(*nTimeBins);
143   
144   //cout << "\nReading tracks from the Memory\n ============= \n";
145   //HLTDebug ("\nReading tracks from the Memory\n ============= \n");
146   AliHLTTRDTrack * hltTrack;
147   AliHLTUInt32_t trackSize = 0, curSize = sizeof(*nTimeBins);
148   Int_t counter=outArray->GetEntriesFast();
149   
150   while (curSize < size)
151     {
152       hltTrack = (AliHLTTRDTrack*) iterPtr;
153       //HLTDebug("curSize %i, size %i",curSize, size);
154       
155       trackSize = hltTrack->GetSize();
156       //HLTDebug("GetSize() %i", trackSize);
157
158       // hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
159
160       AliTRDtrackV1* curTRDTrack = new((*outArray)[counter]) AliTRDtrackV1();
161       hltTrack->ExportTRDTrack(curTRDTrack);
162       
163       curSize += trackSize; 
164       iterPtr += trackSize;
165       counter++;
166     }
167
168   //CheckTrackArray(outArray);
169   
170   return counter;
171 }
172
173 AliHLTUInt32_t AliHLTTRDUtils::AddESDToOutput(const AliESDEvent* const esd, AliHLTUInt8_t* const outBlockPtr)
174 {
175   AliESDtrack* esdTrack = 0;
176   AliHLTUInt8_t* iterPtr = outBlockPtr;
177
178   AliHLTTracksData* trksData = new(iterPtr) AliHLTTracksData;
179   iterPtr += sizeof(AliHLTTracksData);
180   trksData->fCount=0;
181   
182   if(esd){
183     Double_t pid[5];
184     for(Int_t i=0; i<esd->GetNumberOfTracks(); i++){
185       esdTrack=esd->GetTrack(i);
186       if(!esdTrack)continue;
187       AliHLTExternalTrackParam* trk = new(iterPtr) AliHLTExternalTrackParam;
188       iterPtr += sizeof(AliHLTExternalTrackParam);
189       trk->fAlpha = esdTrack->GetAlpha();
190       trk->fX = esdTrack->GetX();
191       trk->fY = esdTrack->GetY();
192       trk->fZ = esdTrack->GetZ();
193       trk->fSinPsi = esdTrack->GetSnp();
194       trk->fTgl = esdTrack->GetTgl();
195       trk->fq1Pt = esdTrack->GetSigned1Pt();
196       trk->fC[0] = esdTrack->GetSigmaY2();
197       trk->fC[1] = esdTrack->GetSigmaZY();
198       trk->fC[2] = esdTrack->GetSigmaZ2();
199       trk->fC[3] = esdTrack->GetSigmaSnpY();
200       trk->fC[4] = esdTrack->GetSigmaSnpZ();
201       trk->fC[5] = esdTrack->GetSigmaSnp2();
202       trk->fC[6] = esdTrack->GetSigmaTglY();
203       trk->fC[7] = esdTrack->GetSigmaTglZ();
204       trk->fC[8] = esdTrack->GetSigmaTglSnp();
205       trk->fC[9] = esdTrack->GetSigmaTgl2();
206       trk->fC[10] = esdTrack->GetSigma1PtY();
207       trk->fC[11] = esdTrack->GetSigma1PtZ();
208       trk->fC[12] = esdTrack->GetSigma1PtSnp();
209       trk->fC[13] = esdTrack->GetSigma1PtTgl();
210       trk->fC[14] = esdTrack->GetSigma1Pt2();
211       esdTrack->GetTRDpid(pid);
212       //trk->fTRDpid = pid[AliPID::kElectron]; ...
213       trk->fNPoints = 0;
214       trksData->fCount++;
215     }
216   }
217   return iterPtr - outBlockPtr;
218 }
219
220 void AliHLTTRDUtils::EmulateHLTClusters(TClonesArray* clusterArray)
221 {
222   AliHLTUInt32_t estimatedSize = (clusterArray->GetEntriesFast()+1)*sizeof(AliHLTTRDCluster);
223   AliHLTUInt8_t* pBlock = (AliHLTUInt8_t*)malloc(estimatedSize);
224   AliHLTUInt32_t size = AddClustersToOutput(clusterArray, pBlock);
225   clusterArray->Delete();
226   ReadClusters(clusterArray, pBlock, size);
227   free(pBlock);
228 }
229
230 void AliHLTTRDUtils::EmulateHLTTracks(TClonesArray* trackArray)
231 {
232   AliHLTUInt32_t estimatedSize = (trackArray->GetEntriesFast()+1)*(sizeof(AliHLTTRDTrack)+6*(sizeof(AliHLTTRDTracklet)+30*sizeof(AliHLTTRDCluster)));
233   AliHLTUInt8_t* pBlock = (AliHLTUInt8_t*)malloc(estimatedSize);
234   AliHLTUInt32_t size = AddTracksToOutput(trackArray, pBlock);
235   trackArray->Delete();
236   ReadTracks(trackArray, pBlock, size);
237   free(pBlock);
238 }