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 ///////////////////////////////////////////////////////////////////////////////
19 // HLT TRD Utillities Class //
21 ///////////////////////////////////////////////////////////////////////////////
23 #include "AliHLTTRDUtils.h"
24 #include <TClonesArray.h>
25 #include "AliHLTTRDTrack.h"
26 #include "AliHLTTRDCluster.h"
27 #include "AliHLTExternalTrackParam.h"
28 #include "AliESDEvent.h"
29 #include "AliESDtrack.h"
32 ClassImp(AliHLTTRDUtils)
34 AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr, Int_t nTimeBins)
36 AliTRDcluster* cluster = 0;
37 AliHLTUInt32_t addedSize = 0;
38 // == OUTdatatype pointer
39 AliHLTTRDCluster* outPtr = (AliHLTTRDCluster*)outBlockPtr;
42 Int_t nbEntries = inClusterArray->GetEntries();
43 for (Int_t iCluster = 0; iCluster<nbEntries; iCluster++){
44 //cout << "Geting cluster #" << iCluster << endl;
46 cluster = (AliTRDcluster*)(inClusterArray->At(iCluster));
48 AliHLTTRDCluster *hltCluster = new (outPtr) AliHLTTRDCluster(cluster);
49 //cout << Form("cluster added at 0x%x (%i)\n",outPtr,outPtr);
51 addedSize += sizeof(*hltCluster);
52 outBlockPtr += sizeof(*hltCluster);
53 outPtr = (AliHLTTRDCluster*)outBlockPtr;
57 Int_t *TBptr = (Int_t*)outPtr;
60 addedSize += sizeof(*TBptr);
61 outBlockPtr += sizeof(*TBptr);
67 AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output, Int_t nTimeBins)
69 //cout << "\nWriting tracks to the Memory\n ============= \n";
71 Int_t *TBptr = (Int_t*)output;
74 AliTRDtrackV1* track = 0;
75 AliHLTUInt32_t addedSize = sizeof(*TBptr);
76 AliHLTUInt8_t* iterPtr = output+addedSize;
77 AliHLTTRDTrack* outPtr = (AliHLTTRDTrack*)iterPtr;
80 Int_t nbTracks = inTrackArray->GetEntries();
81 for (Int_t iTrack = 0; iTrack<nbTracks; iTrack++){
82 AliHLTUInt32_t trackSize=0;
84 track = (AliTRDtrackV1*)(inTrackArray->At(iTrack));
87 AliHLTTRDTrack *hltTrack = new (outPtr) AliHLTTRDTrack(track);
88 trackSize = hltTrack->GetSize();
89 addedSize += trackSize;
90 //HLTDebug("addedSize %i, trackSize %i", addedSize, trackSize);
93 outPtr = (AliHLTTRDTrack*)iterPtr;
101 * Read cluster to the TClonesArray from the memory
103 //============================================================================
104 AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
106 //HLTDebug("\nReading clusters from the Memory\n ============= \n");
107 AliHLTTRDCluster * curCluster;
108 UInt_t clusterSize = sizeof(AliHLTTRDCluster), curSize = 0;
112 *nTimeBins=*(Int_t*)(((AliHLTUInt8_t*)inputPtr)+size-sizeof(Int_t));
113 //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
115 size-=sizeof(*nTimeBins);
117 curCluster = (AliHLTTRDCluster*) inputPtr;
118 while (curSize + clusterSize <= size)
120 //HLTDebug(" fX = %f; fY = %f; fZ = %f", curCluster->fX, curCluster->fY, curCluster->fZ);
122 AliTRDcluster* curTRDCluster = new((*outArray)[i]) AliTRDcluster();
123 curCluster->ExportTRDCluster(curTRDCluster);
124 curTRDCluster->SetRPhiMethod(AliTRDcluster::kCOG);
125 //HLTDebug(" fX = %f; fY = %f; fZ = %f", curTRDCluster->GetX(), curTRDCluster->GetY(), curTRDCluster->GetZ());
126 curSize += clusterSize;
129 //cout << " current readed size is " << curSize << "/" << size << endl;
135 AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
138 *nTimeBins=*(Int_t*)inputPtr;
139 //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
142 AliHLTUInt8_t* iterPtr = ((AliHLTUInt8_t*)inputPtr)+sizeof(*nTimeBins);
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);
150 while (curSize < size)
152 hltTrack = (AliHLTTRDTrack*) iterPtr;
153 //HLTDebug("curSize %i, size %i",curSize, size);
155 trackSize = hltTrack->GetSize();
156 //HLTDebug("GetSize() %i", trackSize);
158 // hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
160 AliTRDtrackV1* curTRDTrack = new((*outArray)[counter]) AliTRDtrackV1();
161 hltTrack->ExportTRDTrack(curTRDTrack);
163 curSize += trackSize;
164 iterPtr += trackSize;
168 //CheckTrackArray(outArray);
173 AliHLTUInt32_t AliHLTTRDUtils::AddESDToOutput(const AliESDEvent* const esd, AliHLTUInt8_t* const outBlockPtr)
175 AliESDtrack* esdTrack = 0;
176 AliHLTUInt8_t* iterPtr = outBlockPtr;
178 AliHLTTracksData* trksData = new(iterPtr) AliHLTTracksData;
179 iterPtr += sizeof(AliHLTTracksData);
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]; ...
217 return iterPtr - outBlockPtr;