+// $Id$
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
#include "AliHLTTRDUtils.h"
#include <TClonesArray.h>
#include "AliHLTTRDTrack.h"
+#include "AliHLTTRDTracklet.h"
#include "AliHLTTRDCluster.h"
+#include "AliHLTExternalTrackParam.h"
+#include "AliESDEvent.h"
+#include "AliESDtrack.h"
+#include "AliPID.h"
-AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr)
+ClassImp(AliHLTTRDUtils)
+
+AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr, Int_t nTimeBins)
{
AliTRDcluster* cluster = 0;
AliHLTUInt32_t addedSize = 0;
// == OUTdatatype pointer
- AliHLTTRDCluster * outPtr = (AliHLTTRDCluster*)outBlockPtr;
+ AliHLTTRDCluster* outPtr = (AliHLTTRDCluster*)outBlockPtr;
if (inClusterArray){
Int_t nbEntries = inClusterArray->GetEntries();
for (Int_t iCluster = 0; iCluster<nbEntries; iCluster++){
//cout << "Geting cluster #" << iCluster << endl;
- UInt_t blockSize=0;
- cluster = dynamic_cast<AliTRDcluster*>(inClusterArray->At(iCluster));
+ cluster = (AliTRDcluster*)(inClusterArray->At(iCluster));
AliHLTTRDCluster *hltCluster = new (outPtr) AliHLTTRDCluster(cluster);
//cout << Form("cluster added at 0x%x (%i)\n",outPtr,outPtr);
- blockSize = sizeof(*hltCluster);
-
- addedSize += blockSize;
- outBlockPtr += blockSize;
+ addedSize += sizeof(*hltCluster);
+ outBlockPtr += sizeof(*hltCluster);
outPtr = (AliHLTTRDCluster*)outBlockPtr;
}
}
+
+ Int_t *TBptr = (Int_t*)outPtr;
+ *TBptr = nTimeBins;
+
+ addedSize += sizeof(*TBptr);
+ outBlockPtr += sizeof(*TBptr);
+
return addedSize;
}
-AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output)
+AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output, Int_t nTimeBins)
{
- cout << "\nWriting tracks to the Memory\n ============= \n";
+ //cout << "\nWriting tracks to the Memory\n ============= \n";
+
+ Int_t *TBptr = (Int_t*)output;
+ *TBptr = nTimeBins;
+
AliTRDtrackV1* track = 0;
- AliHLTUInt32_t addedSize = 0;
- AliHLTUInt8_t *iterPtr = output;
- AliHLTTRDTrack * outPtr = (AliHLTTRDTrack*)iterPtr;
-
+ AliHLTUInt32_t addedSize = sizeof(*TBptr);
+ AliHLTUInt8_t* iterPtr = output+addedSize;
+ AliHLTTRDTrack* outPtr = (AliHLTTRDTrack*)iterPtr;
+
if (inTrackArray){
Int_t nbTracks = inTrackArray->GetEntries();
for (Int_t iTrack = 0; iTrack<nbTracks; iTrack++){
AliHLTUInt32_t trackSize=0;
- track = dynamic_cast<AliTRDtrackV1*>(inTrackArray->At(iTrack));
+ track = (AliTRDtrackV1*)(inTrackArray->At(iTrack));
//track->Print();
AliHLTTRDTrack *hltTrack = new (outPtr) AliHLTTRDTrack(track);
trackSize = hltTrack->GetSize();
addedSize += trackSize;
- HLTDebug("addedSize %i, trackSize %i", addedSize, trackSize);
+ //HLTDebug("addedSize %i, trackSize %i", addedSize, trackSize);
iterPtr += trackSize;
outPtr = (AliHLTTRDTrack*)iterPtr;
* Read cluster to the TClonesArray from the memory
*/
//============================================================================
-AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
+AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
{
//HLTDebug("\nReading clusters from the Memory\n ============= \n");
AliHLTTRDCluster * curCluster;
UInt_t clusterSize = sizeof(AliHLTTRDCluster), curSize = 0;
- Int_t i=0;
-
+ Int_t counter=outArray->GetEntriesFast();
+
+ if(nTimeBins){
+ *nTimeBins=*(Int_t*)(((AliHLTUInt8_t*)inputPtr)+size-sizeof(Int_t));
+ //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
+ }
+ size-=sizeof(*nTimeBins);
+
curCluster = (AliHLTTRDCluster*) inputPtr;
- while (curSize + clusterSize <= size)
+ while (curSize < size)
{
- // HLTDebug(" fX = %f; fY = %f; fZ = %f", curCluster->fX, curCluster->fY, curCluster->fZ);
+ //HLTDebug(" fX = %f; fY = %f; fZ = %f", curCluster->fX, curCluster->fY, curCluster->fZ);
- AliTRDcluster* curTRDCluster = new((*outArray)[i]) AliTRDcluster();
+ AliTRDcluster* curTRDCluster = new((*outArray)[counter]) AliTRDcluster();
curCluster->ExportTRDCluster(curTRDCluster);
- // HLTDebug(" fX = %f; fY = %f; fZ = %f", curTRDCluster->GetX(), curTRDCluster->GetY(), curTRDCluster->GetZ());
+ //HLTDebug(" fX = %f; fY = %f; fZ = %f", curTRDCluster->GetX(), curTRDCluster->GetY(), curTRDCluster->GetZ());
curSize += clusterSize;
- i++;
+ counter++;
curCluster++;
//cout << " current readed size is " << curSize << "/" << size << endl;
}
- return i;
+ return counter;
}
-AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
+AliHLTUInt32_t AliHLTTRDUtils::ReadTracks(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
{
- AliHLTUInt8_t* iterPtr = (AliHLTUInt8_t* )inputPtr;
+ if(nTimeBins){
+ *nTimeBins=*(Int_t*)inputPtr;
+ //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
+ }
+
+ AliHLTUInt8_t* iterPtr = ((AliHLTUInt8_t*)inputPtr)+sizeof(*nTimeBins);
//cout << "\nReading tracks from the Memory\n ============= \n";
- HLTDebug ("\nReading tracks from the Memory\n ============= \n");
+ //HLTDebug ("\nReading tracks from the Memory\n ============= \n");
AliHLTTRDTrack * hltTrack;
- AliHLTUInt32_t trackSize = 0, curSize = 0;
- Int_t counter=0;
+ AliHLTUInt32_t trackSize = 0, curSize = sizeof(*nTimeBins);
+ Int_t counter=outArray->GetEntriesFast();
while (curSize < size)
{
hltTrack = (AliHLTTRDTrack*) iterPtr;
- HLTDebug("curSize %i, size %i",curSize, size);
+ //HLTDebug("curSize %i, size %i",curSize, size);
trackSize = hltTrack->GetSize();
- HLTDebug("GetSize() %i", trackSize);
+ //HLTDebug("GetSize() %i", trackSize);
- hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
+ // hltTrack->ReadTrackletsFromMemory(iterPtr + sizeof(AliHLTTRDTrack));
AliTRDtrackV1* curTRDTrack = new((*outArray)[counter]) AliTRDtrackV1();
hltTrack->ExportTRDTrack(curTRDTrack);
return counter;
}
+AliHLTUInt32_t AliHLTTRDUtils::AddESDToOutput(const AliESDEvent* const esd, AliHLTUInt8_t* const outBlockPtr)
+{
+ AliESDtrack* esdTrack = 0;
+ AliHLTUInt8_t* iterPtr = outBlockPtr;
+
+ AliHLTTracksData* trksData = new(iterPtr) AliHLTTracksData;
+ iterPtr += sizeof(AliHLTTracksData);
+ trksData->fCount=0;
+
+ if(esd){
+ Double_t pid[5];
+ for(Int_t i=0; i<esd->GetNumberOfTracks(); i++){
+ esdTrack=esd->GetTrack(i);
+ if(!esdTrack)continue;
+ AliHLTExternalTrackParam* trk = new(iterPtr) AliHLTExternalTrackParam;
+ iterPtr += sizeof(AliHLTExternalTrackParam);
+ trk->fAlpha = esdTrack->GetAlpha();
+ trk->fX = esdTrack->GetX();
+ trk->fY = esdTrack->GetY();
+ trk->fZ = esdTrack->GetZ();
+ trk->fSinPsi = esdTrack->GetSnp();
+ trk->fTgl = esdTrack->GetTgl();
+ trk->fq1Pt = esdTrack->GetSigned1Pt();
+ trk->fC[0] = esdTrack->GetSigmaY2();
+ trk->fC[1] = esdTrack->GetSigmaZY();
+ trk->fC[2] = esdTrack->GetSigmaZ2();
+ trk->fC[3] = esdTrack->GetSigmaSnpY();
+ trk->fC[4] = esdTrack->GetSigmaSnpZ();
+ trk->fC[5] = esdTrack->GetSigmaSnp2();
+ trk->fC[6] = esdTrack->GetSigmaTglY();
+ trk->fC[7] = esdTrack->GetSigmaTglZ();
+ trk->fC[8] = esdTrack->GetSigmaTglSnp();
+ trk->fC[9] = esdTrack->GetSigmaTgl2();
+ trk->fC[10] = esdTrack->GetSigma1PtY();
+ trk->fC[11] = esdTrack->GetSigma1PtZ();
+ trk->fC[12] = esdTrack->GetSigma1PtSnp();
+ trk->fC[13] = esdTrack->GetSigma1PtTgl();
+ trk->fC[14] = esdTrack->GetSigma1Pt2();
+ esdTrack->GetTRDpid(pid);
+ //trk->fTRDpid = pid[AliPID::kElectron]; ...
+ trk->fNPoints = 0;
+ trksData->fCount++;
+ }
+ }
+ return iterPtr - outBlockPtr;
+}
+
+void AliHLTTRDUtils::EmulateHLTClusters(TClonesArray* clusterArray)
+{
+ AliHLTUInt32_t estimatedSize = (clusterArray->GetEntriesFast()+1)*sizeof(AliHLTTRDCluster);
+ AliHLTUInt8_t* pBlock = (AliHLTUInt8_t*)malloc(estimatedSize);
+ AliHLTUInt32_t size = AddClustersToOutput(clusterArray, pBlock);
+ clusterArray->Delete();
+ ReadClusters(clusterArray, pBlock, size);
+ free(pBlock);
+}
+
+void AliHLTTRDUtils::EmulateHLTTracks(TClonesArray* trackArray)
+{
+ AliHLTUInt32_t estimatedSize = (trackArray->GetEntriesFast()+1)*(sizeof(AliHLTTRDTrack)+6*(sizeof(AliHLTTRDTracklet)+30*sizeof(AliHLTTRDCluster)));
+ AliHLTUInt8_t* pBlock = (AliHLTUInt8_t*)malloc(estimatedSize);
+ AliHLTUInt32_t size = AddTracksToOutput(trackArray, pBlock);
+ trackArray->Delete();
+ ReadTracks(trackArray, pBlock, size);
+ free(pBlock);
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff