HLT/TRD/AliHLTTRDUtils.cxx

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