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 "AliHLTTRDCluster.h"
  27 #include "AliHLTExternalTrackParam.h"
  28 #include "AliESDEvent.h"
  29 #include "AliESDtrack.h"
  30 #include "AliPID.h"
  31
  32 ClassImp(AliHLTTRDUtils)
  33
  34 AliHLTUInt32_t AliHLTTRDUtils::AddClustersToOutput(TClonesArray* inClusterArray, AliHLTUInt8_t* outBlockPtr, Int_t nTimeBins)
  35 {
  36   AliTRDcluster* cluster = 0;
  37   AliHLTUInt32_t addedSize = 0;
  38   //  == OUTdatatype pointer
  39   AliHLTTRDCluster* outPtr = (AliHLTTRDCluster*)outBlockPtr;
  40
  41   if (inClusterArray){
  42     Int_t nbEntries  = inClusterArray->GetEntries();
  43     for (Int_t iCluster = 0; iCluster<nbEntries; iCluster++){
  44       //cout << "Geting cluster #" << iCluster << endl;
  45
  46       cluster = (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       addedSize += sizeof(*hltCluster);
  52       outBlockPtr += sizeof(*hltCluster);
  53       outPtr = (AliHLTTRDCluster*)outBlockPtr;
  54     }
  55   }
  56
  57   Int_t *TBptr = (Int_t*)outPtr;
  58   *TBptr = nTimeBins;
  59
  60   addedSize += sizeof(*TBptr);
  61   outBlockPtr += sizeof(*TBptr);
  62
  63   return addedSize;
  64
  65 }
  66
  67 AliHLTUInt32_t AliHLTTRDUtils::AddTracksToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output, Int_t nTimeBins)
  68 {
  69   //cout << "\nWriting tracks to the Memory\n ============= \n";
  70
  71   Int_t *TBptr = (Int_t*)output;
  72   *TBptr = nTimeBins;
  73
  74   AliTRDtrackV1* track = 0;
  75   AliHLTUInt32_t addedSize = sizeof(*TBptr);
  76   AliHLTUInt8_t* iterPtr = output+addedSize;
  77   AliHLTTRDTrack* outPtr = (AliHLTTRDTrack*)iterPtr;
  78
  79   if (inTrackArray){
  80     Int_t nbTracks  = inTrackArray->GetEntries();
  81     for (Int_t iTrack = 0; iTrack<nbTracks; iTrack++){
  82       AliHLTUInt32_t trackSize=0;
  83
  84       track = (AliTRDtrackV1*)(inTrackArray->At(iTrack));
  85       //track->Print();
  86
  87       AliHLTTRDTrack *hltTrack = new (outPtr) AliHLTTRDTrack(track);
  88       trackSize = hltTrack->GetSize();
  89       addedSize += trackSize;
  90       //HLTDebug("addedSize %i, trackSize %i", addedSize, trackSize);
  91
  92       iterPtr += trackSize;
  93       outPtr = (AliHLTTRDTrack*)iterPtr;
  94     }
  95   }
  96   return addedSize;
  97
  98 }
  99
 100 /**
 101  * Read cluster to the TClonesArray from the memory
 102  */
 103 //============================================================================
 104 AliHLTUInt32_t AliHLTTRDUtils::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size, Int_t* nTimeBins)
 105 {
 106   //HLTDebug("\nReading clusters from the Memory\n ============= \n");
 107   AliHLTTRDCluster * curCluster;
 108   UInt_t clusterSize = sizeof(AliHLTTRDCluster), curSize = 0;
 109   Int_t i=0;
 110
 111   if(nTimeBins){
 112     *nTimeBins=*(Int_t*)(((AliHLTUInt8_t*)inputPtr)+size-sizeof(Int_t));
 113     //HLTDebug("Reading number of time bins from input block: %d", *nTimeBins);
 114   }
 115   size-=sizeof(*nTimeBins);
 116
 117   curCluster = (AliHLTTRDCluster*) inputPtr;
 118   while (curSize + clusterSize <= size)
 119     {
 120       //HLTDebug(" fX = %f; fY = %f; fZ = %f", curCluster->fX, curCluster->fY, curCluster->fZ);
 121
 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;
 127       i++;
 128       curCluster++;
 129       //cout << " current readed size is " << curSize << "/" << size << endl;
 130     }
 131
 132   return i;
 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=0;
 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 }