2 /**************************************************************************
3 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5 * Author: The ALICE Off-line Project. *
6 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
17 // @file AliHLTTRDUtils.cxx
18 // @author Theodor Rascanu
20 // @brief Utilities needed the HLT::TRD code.
23 ///////////////////////////////////////////////////////////////////////////////
25 // HLT TRD Utilities Class //
27 ///////////////////////////////////////////////////////////////////////////////
29 #include "AliHLTTRDUtils.h"
30 #include <TClonesArray.h>
31 #include "AliHLTTRDTrack.h"
32 #include "AliHLTTRDTracklet.h"
33 #include "AliHLTTRDCluster.h"
34 #include "AliHLTExternalTrackParam.h"
35 #include "AliTRDtransform.h"
36 #include "AliESDEvent.h"
37 #include "AliESDtrack.h"
40 ClassImp(AliHLTTRDUtils)
42 AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(const TClonesArray *const inClusterArray, AliHLTUInt8_t *const outBlockPtr, Int_t nTimeBins)
44 AliTRDcluster* cluster = 0;
45 AliHLTUInt32_t addedSize = 0;
49 AliHLTTRDClustersArray* clsArr = NULL;
50 Int_t nbEntries = inClusterArray->GetEntries();
51 for (Int_t iCluster = 0; iCluster<nbEntries; iCluster++){
52 cluster = (AliTRDcluster*)(inClusterArray->At(iCluster));
53 if(lastDet!=cluster->GetDetector()){
54 lastDet=cluster->GetDetector();
55 clsArr = new(outBlockPtr+addedSize) AliHLTTRDClustersArray(lastDet);
56 addedSize += sizeof(AliHLTTRDClustersArray);
59 new (&clsArr->fCluster[clsArr->fCount]) AliHLTTRDClustersArray::cluster_type(cluster);
61 addedSize += sizeof(AliHLTTRDClustersArray::cluster_type);
65 Int_t *TBptr = (Int_t*)(outBlockPtr+addedSize);
68 addedSize += sizeof(*TBptr);
74 AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(const TClonesArray *const inTrackArray, AliHLTUInt8_t *const output, Int_t nTimeBins)
77 Int_t *TBptr = (Int_t*)output;
80 AliTRDtrackV1* track = 0;
81 AliHLTUInt32_t addedSize = sizeof(*TBptr);
84 Int_t nbTracks = inTrackArray->GetEntries();
85 for (Int_t iTrack = 0; iTrack<nbTracks; iTrack++){
86 AliHLTUInt32_t trackSize=0;
88 track = (AliTRDtrackV1*)(inTrackArray->At(iTrack));
90 AliHLTTRDTrack *hltTrack = new (output+addedSize) AliHLTTRDTrack(track);
91 trackSize = hltTrack->GetSize();
92 addedSize += trackSize;
99 AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutputAlt(const TClonesArray *const inTrackArray, AliHLTUInt8_t *const block, Int_t nTimeBins)
101 AliHLTUInt32_t addedSize = 0;
103 AliHLTUInt64_t *TBptr = (AliHLTUInt64_t*)block;
106 addedSize += sizeof(AliHLTUInt64_t);
108 if(!inTrackArray) return addedSize;
110 Int_t nbTracks = inTrackArray->GetEntriesFast();
111 for (Int_t i = 0; i<nbTracks; i++){
112 AliTRDtrackV1* inTrack = (AliTRDtrackV1*)(inTrackArray->At(i));
113 if(inTrack)addedSize+=AliHLTTRDTrack::SaveAt(block+addedSize, inTrack);
121 * Read cluster to the TClonesArray from the memory
123 //============================================================================
124 AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *const outArray, const void *const inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
126 const AliHLTUInt8_t* inPtr = (AliHLTUInt8_t*)inputPtr;
128 Int_t counter = outArray->GetEntriesFast();
131 *nTimeBins=*(Int_t*)(inPtr+size-sizeof(*nTimeBins));
133 size-=sizeof(*nTimeBins);
134 #ifndef HAVE_NOT_ALITRD_CLUSTERIZER_r42837
135 AliTRDtransform trans;
137 while (curSize < size)
139 AliHLTTRDClustersArray* clsArr = (AliHLTTRDClustersArray*)(inPtr+curSize);
140 curSize+=sizeof(AliHLTTRDClustersArray);
141 #ifndef HAVE_NOT_ALITRD_CLUSTERIZER_r42837
142 trans.SetDetector(clsArr->fDetector);
144 for(Int_t iCluster = 0; iCluster<clsArr->fCount; iCluster++){
145 AliTRDcluster* curTRDCluster = new((*outArray)[counter]) AliTRDcluster();
146 clsArr->fCluster[iCluster].ExportTRDCluster(curTRDCluster);
147 curTRDCluster->SetDetector(clsArr->fDetector);
148 #ifndef HAVE_NOT_ALITRD_CLUSTERIZER_r42837
149 trans.Transform(curTRDCluster);
151 curSize += sizeof(AliHLTTRDClustersArray::cluster_type);
159 AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *const outArray, const void *const inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
162 *nTimeBins=*(Int_t*)inputPtr;
163 //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
166 AliHLTUInt8_t* iterPtr = ((AliHLTUInt8_t*)inputPtr)+sizeof(*nTimeBins);
168 //cout << "\nReading tracks from the Memory\n ============= \n";
169 //HLTDebug ("\nReading tracks from the Memory\n ============= \n");
170 AliHLTTRDTrack * hltTrack;
171 AliHLTUInt32_t trackSize = 0, curSize = sizeof(*nTimeBins);
172 Int_t counter=outArray->GetEntriesFast();
174 while (curSize < size)
176 hltTrack = (AliHLTTRDTrack*) iterPtr;
177 //HLTDebug("curSize %i, size %i",curSize, size);
179 trackSize = hltTrack->GetSize();
180 //HLTDebug("GetSize() %i", trackSize);
182 // hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
184 AliTRDtrackV1* curTRDTrack = new((*outArray)[counter]) AliTRDtrackV1();
185 hltTrack->ExportTRDTrack(curTRDTrack);
187 curSize += trackSize;
188 iterPtr += trackSize;
192 //CheckTrackArray(outArray);
197 AliHLTUInt32_t AliHLTTRDUtils::ReadTracksAlt(TClonesArray *const outArray, const void *const inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
199 const AliHLTUInt8_t *const block = ((AliHLTUInt8_t*)inputPtr);
200 AliHLTUInt32_t readSize = 0;
203 *nTimeBins=*(AliHLTUInt64_t*)block;
204 //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
207 readSize += sizeof(AliHLTUInt64_t);
209 if(!outArray) return readSize;
211 Int_t counter=outArray->GetEntriesFast();
212 while(readSize<size){
213 AliTRDtrackV1 *const outTrack = new((*outArray)[counter]) AliTRDtrackV1;
214 readSize+=AliHLTTRDTrack::LoadFrom(outTrack, block+readSize);
222 AliHLTUInt32_t AliHLTTRDUtils::AddESDToOutput(const AliESDEvent* const esd, AliHLTUInt8_t* const outBlockPtr)
224 AliESDtrack* esdTrack = 0;
225 AliHLTUInt8_t* iterPtr = outBlockPtr;
227 AliHLTTracksData* trksData = new(iterPtr) AliHLTTracksData;
228 iterPtr += sizeof(AliHLTTracksData);
233 for(Int_t i=0; i<esd->GetNumberOfTracks(); i++){
234 esdTrack=esd->GetTrack(i);
235 if(!esdTrack)continue;
236 AliHLTExternalTrackParam* trk = new(iterPtr) AliHLTExternalTrackParam;
237 iterPtr += sizeof(AliHLTExternalTrackParam);
238 trk->fAlpha = esdTrack->GetAlpha();
239 trk->fX = esdTrack->GetX();
240 trk->fY = esdTrack->GetY();
241 trk->fZ = esdTrack->GetZ();
242 trk->fSinPsi = esdTrack->GetSnp();
243 trk->fTgl = esdTrack->GetTgl();
244 trk->fq1Pt = esdTrack->GetSigned1Pt();
245 trk->fC[0] = esdTrack->GetSigmaY2();
246 trk->fC[1] = esdTrack->GetSigmaZY();
247 trk->fC[2] = esdTrack->GetSigmaZ2();
248 trk->fC[3] = esdTrack->GetSigmaSnpY();
249 trk->fC[4] = esdTrack->GetSigmaSnpZ();
250 trk->fC[5] = esdTrack->GetSigmaSnp2();
251 trk->fC[6] = esdTrack->GetSigmaTglY();
252 trk->fC[7] = esdTrack->GetSigmaTglZ();
253 trk->fC[8] = esdTrack->GetSigmaTglSnp();
254 trk->fC[9] = esdTrack->GetSigmaTgl2();
255 trk->fC[10] = esdTrack->GetSigma1PtY();
256 trk->fC[11] = esdTrack->GetSigma1PtZ();
257 trk->fC[12] = esdTrack->GetSigma1PtSnp();
258 trk->fC[13] = esdTrack->GetSigma1PtTgl();
259 trk->fC[14] = esdTrack->GetSigma1Pt2();
260 esdTrack->GetTRDpid(pid);
261 //trk->fTRDpid = pid[AliPID::kElectron]; ...
266 return iterPtr - outBlockPtr;
269 void AliHLTTRDUtils::EmulateHLTClusters(TClonesArray* clusterArray)
271 AliHLTUInt32_t estimatedSize = (clusterArray->GetEntriesFast()+1)*sizeof(AliHLTTRDClustersArray::cluster_type);
272 AliHLTUInt8_t* pBlock = (AliHLTUInt8_t*)malloc(estimatedSize);
273 AliHLTUInt32_t size = AddClustersToOutput(clusterArray, pBlock);
274 clusterArray->Delete();
275 ReadClusters(clusterArray, pBlock, size);
279 void AliHLTTRDUtils::EmulateHLTTracks(TClonesArray* trackArray)
281 AliHLTUInt32_t estimatedSize = (trackArray->GetEntriesFast()+1)*(sizeof(AliHLTTRDTrack)+6*(sizeof(AliHLTTRDTracklet)+30*sizeof(AliHLTTRDClustersArray::cluster_type)));
282 AliHLTUInt8_t* pBlock = (AliHLTUInt8_t*)malloc(estimatedSize);
283 AliHLTUInt32_t size = AddTracksToOutput(trackArray, pBlock);
284 trackArray->Delete();
285 ReadTracks(trackArray, pBlock, size);
289 AliHLTUInt32_t AliHLTTRDUtils::GetSM(AliHLTUInt32_t spec)
291 spec = (spec&-spec); // use only least significant bit
292 spec -= 1; // as spec is now power of 2, this creates ones..
293 int count = 0; // .. which are counted