3 //**************************************************************************
4 //* This file is property of and copyright by the ALICE HLT Project *
5 //* ALICE Experiment at CERN, All rights reserved. *
7 //* Primary Authors: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no> *
8 //* for The ALICE HLT Project. *
10 //* Permission to use, copy, modify and distribute this software and its *
11 //* documentation strictly for non-commercial purposes is hereby granted *
12 //* without fee, provided that the above copyright notice appears in all *
13 //* copies and that both the copyright notice and this permission notice *
14 //* appear in the supporting documentation. The authors make no claims *
15 //* about the suitability of this software for any purpose. It is *
16 //* provided "as is" without express or implied warranty. *
17 //**************************************************************************
19 /** @file AliHLTTPCHWClusterTransformComponent.cxx
20 @author Kalliopi Kanaki
28 #include "AliHLTTPCHWClusterTransformComponent.h"
29 #include "AliHLTTPCDefinitions.h"
30 #include "AliHLTTPCTransform.h"
31 #include "AliHLTTPCSpacePointData.h"
32 #include "AliHLTTPCClusterDataFormat.h"
34 #include "AliTPCcalibDB.h"
35 #include "AliTPCTransform.h"
36 #include "AliTPCCalPad.h"
38 #include "AliCDBManager.h"
39 #include "AliCDBEntry.h"
42 #include "TObjString.h"
47 ClassImp(AliHLTTPCHWClusterTransformComponent) //ROOT macro for the implementation of ROOT specific class methods
49 const char* AliHLTTPCHWClusterTransformComponent::fgkOCDBEntryHWTransform="HLT/ConfigTPC/TPCHWClusterTransform";
51 AliHLTTPCHWClusterTransformComponent::AliHLTTPCHWClusterTransformComponent()
53 fOfflineTransform(NULL),
56 fOfflineTPCRecoParam()
58 // see header file for class documentation
60 // refer to README to build package
62 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
65 AliHLTTPCHWClusterTransformComponent::~AliHLTTPCHWClusterTransformComponent() {
66 // see header file for class documentation
69 const char* AliHLTTPCHWClusterTransformComponent::GetComponentID() {
70 // see header file for class documentation
72 return "TPCHWClusterTransform";
75 void AliHLTTPCHWClusterTransformComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
76 // see header file for class documentation
79 list.push_back( AliHLTTPCDefinitions::fgkHWClustersDataType );
82 AliHLTComponentDataType AliHLTTPCHWClusterTransformComponent::GetOutputDataType() {
83 // see header file for class documentation
85 return AliHLTTPCDefinitions::fgkClustersDataType;
88 int AliHLTTPCHWClusterTransformComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) {
89 // see header file for class documentation
92 tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType);
93 return tgtList.size();
96 void AliHLTTPCHWClusterTransformComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
97 // see header file for class documentation
99 inputMultiplier = 3.0;
102 AliHLTComponent* AliHLTTPCHWClusterTransformComponent::Spawn() {
103 // see header file for class documentation
105 return new AliHLTTPCHWClusterTransformComponent();
108 int AliHLTTPCHWClusterTransformComponent::DoInit( int argc, const char** argv ) {
109 // see header file for class documentation
111 AliTPCcalibDB* pCalib=AliTPCcalibDB::Instance();
113 !(fOfflineTransform = AliTPCcalibDB::Instance()->GetTransform())){
114 HLTError("Cannot retrieve offline transform from AliTPCcalibDB (%p)", pCalib);
117 // set the flags in the reco param
118 fOfflineTPCRecoParam.SetUseExBCorrection(1);
119 fOfflineTPCRecoParam.SetUseTOFCorrection(1);
120 fOfflineTransform->SetCurrentRecoParam(&fOfflineTPCRecoParam);
122 pCalib->SetExBField(GetBz());
125 iResult = ConfigureFromCDBTObjString(fgkOCDBEntryHWTransform);
127 if (iResult>=0 && argc>0)
128 iResult=ConfigureFromArgumentString(argc, argv);
133 int AliHLTTPCHWClusterTransformComponent::DoDeinit() {
134 // see header file for class documentation
138 int AliHLTTPCHWClusterTransformComponent::DoEvent(const AliHLTComponentEventData& evtData,
139 const AliHLTComponentBlockData* blocks,
140 AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
141 AliHLTUInt32_t& size,
142 vector<AliHLTComponentBlockData>& outputBlocks ){
143 // see header file for class documentation
145 if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){
150 const AliHLTComponentBlockData *iter = NULL;
153 AliHLTTPCClusterData* outPtr;
155 AliHLTUInt8_t* outBPtr;
156 UInt_t offset, mysize, nSize, tSize = 0;
159 outPtr = (AliHLTTPCClusterData*)outBPtr;
161 AliHLTTPCSpacePointData *spacePoints = outPtr->fSpacePoints;
163 unsigned long maxPoints = 0;
165 for(ndx=0; ndx<evtData.fBlockCnt; ndx++){
171 HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
172 evtData.fEventID, evtData.fEventID,
173 DataType2Text( iter->fDataType).c_str(),
174 DataType2Text(AliHLTTPCDefinitions::fgkHWClustersDataType).c_str());
176 if(iter->fDataType != AliHLTTPCDefinitions::fgkHWClustersDataType) continue;
178 UInt_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
179 UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
180 //UInt_t maxSlice = AliHLTTPCDefinitions::GetMaxSliceNr(*iter);
181 //UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(*iter);
183 HLTDebug("minSlice: %d, minPartition: %d", minSlice, minPartition);
185 outPtr = (AliHLTTPCClusterData*)outBPtr;
186 maxPoints = (size-tSize-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
188 AliHLTUInt32_t *buffer;
189 buffer = (AliHLTUInt32_t*)iter->fPtr;
192 //cluster fabrication
193 buffer = new AliHLTUInt32_t[14];
195 buffer[0]=0xffffffff;
196 buffer[1]=0xffffffff;
197 buffer[2]=0xffffffff;
198 buffer[3]=0xffffffff;
199 buffer[4]=0xffffffff;
200 buffer[5]=0xffffffff;
201 buffer[6]=0xffffffff;
202 buffer[7]=0xffffffff;
204 buffer[8]=0xC60002EF;
210 buffer[13]=0x80000000;
213 Int_t sector=-99, thisrow=-99;
215 // PrintDebug(buffer, 14);
217 // skip the first 8 32-bit CDH words
220 //PrintDebug(buffer, (Int_t)iter->fSize/sizeof(AliHLTUInt32_t));
222 unsigned long nAddedClusters = 0;
224 for(UInt_t nWords=0; nWords<(iter->fSize/sizeof(AliHLTUInt32_t)); nWords+=5){
225 // for(UInt_t nWords=0; nWords<5; nWords+=5){
227 // check if bit 31 and 30 of the 32-bit word is 11 -> cluster (10 is RCU trailer)
228 AliHLTUInt32_t bit3130 = (buffer[nWords]>>30); // shift 30 to the right
231 if(bit3130 == 0x3){ //beginning of a cluster
233 //PrintDebug(&buffer[nWords], 5);
235 if(nAddedClusters>=maxPoints){
236 HLTWarning("No more space to add clusters, exiting!");
241 AliHLTTPCSpacePointData cluster = { 0.,0.,0.,0,0,0.,0.,0,0,kFALSE,0 };
244 AliHLTUInt32_t rowCharge = buffer[nWords];
245 AliHLTUInt8_t *rowPtr = reinterpret_cast<AliHLTUInt8_t*>(&rowCharge);
246 rowPtr+=3; // this is to run for little endian architecture, the word is read from right to left
248 cluster.fPadRow = (UChar_t)((*rowPtr)&0x3f);
249 cluster.fCharge = ((UInt_t)rowCharge&0xFFFFFF)>>6; //24-bit mask to get out the charge and division with 64(>>6) for the gain correction
251 Float_t tmpPad = *((Float_t*)&buffer[nWords+1]);
252 Float_t tmpTime = *((Float_t*)&buffer[nWords+2]);
253 cluster.fSigmaY2 = *((Float_t*)&buffer[nWords+3]);
254 cluster.fSigmaZ2 = *((Float_t*)&buffer[nWords+4]);
257 if(cluster.fCharge<fChargeThreshold) continue;
259 // correct expressions for the error calculation
260 // Kenneth: 12.11.2009 I'm not sure if this is a correct calculation. Leave it out for now since it is anyway not used later since it caused segfaults.
261 // cluster.fSigmaY2 = TMath::Sqrt( *((Float_t*)&buffer[nWords+3]) - *((Float_t*)&buffer[nWords+1])* (*((Float_t*)&buffer[nWords+1])) );
262 // cluster.fSigmaZ2 = TMath::Sqrt( *((Float_t*)&buffer[nWords+3]) - *((Float_t*)&buffer[nWords+1])* (*((Float_t*)&buffer[nWords+1])) );
264 Float_t xyz[3]; xyz[0] = xyz[1] = xyz[2] = -99.;
266 HLTDebug("padrow: %d, charge: %f, pad: %f, time: %f, errY: %f, errZ: %f \n", cluster.fPadRow, (Float_t)cluster.fCharge, tmpPad, tmpTime, cluster.fSigmaY2, cluster.fSigmaZ2);
268 //fOfflineTransform=NULL;
270 if(fOfflineTransform == NULL){
271 cluster.fPadRow += AliHLTTPCTransform::GetFirstRow(minPartition);
272 AliHLTTPCTransform::Slice2Sector(minSlice, cluster.fPadRow, sector, thisrow);
273 AliHLTTPCTransform::Raw2Local(xyz, sector, thisrow, tmpPad, tmpTime);
274 if(minSlice>17) xyz[1]=(-1)*xyz[1];
282 cluster.fPadRow += AliHLTTPCTransform::GetFirstRow(minPartition);
284 AliHLTTPCTransform::Slice2Sector(minSlice, (UInt_t)cluster.fPadRow, sector, thisrow);
287 Double_t x[3] = {thisrow,tmpPad+.5,tmpTime};
288 Int_t iSector[1]= {sector};
289 fOfflineTransform->Transform(x,iSector,0,1);
295 HLTDebug("cluster X: %f, Y: %f, Z: %f \n", cluster.fX, cluster.fY, cluster.fZ);
296 spacePoints[nAddedClusters] = cluster;
299 } // end of clusters starting with 11=0x3
300 else if(bit3130 == 0x2){ // we have reached the beginning of the RCU trailer - 10=0x2
303 } // end of loop over clusters
305 HLTDebug("Number of found clusters: %d", nAddedClusters);
307 outPtr->fSpacePointCnt = nAddedClusters;
308 nSize = sizeof(AliHLTTPCSpacePointData)*outPtr->fSpacePointCnt;
309 mysize += nSize+sizeof(AliHLTTPCClusterData);
311 AliHLTComponentBlockData bd;
315 bd.fSpecification = iter->fSpecification;
317 if(fDataId==kFALSE) bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
318 else bd.fDataType = AliHLTTPCDefinitions::fgkAlterClustersDataType;
320 //HLTDebug("datatype: %s", DataType2Text(bd.fDataType).c_str());
322 outputBlocks.push_back( bd );
326 outPtr = (AliHLTTPCClusterData*)outBPtr;
328 } // end of loop over data blocks
333 int AliHLTTPCHWClusterTransformComponent::ScanConfigurationArgument(int argc, const char** argv){
335 // see header file for class documentation
337 if (argc<=0) return 0;
339 TString argument=argv[i];
341 if (argument.CompareTo("-solenoidBz")==0){
342 if (++i>=argc) return -EPROTO;
344 AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
346 HLTError("CalibDB not available");
348 Float_t magneticField = argument.Atof();
349 calib->SetExBField(magneticField);
350 HLTInfo("SolenoidBz is set to %f in the calibDB",magneticField);
354 if (argument.CompareTo("-change-dataId")==0){
355 HLTDebug("Change data ID received.");
360 if (argument.CompareTo("-charge-threshold")==0) {
361 if (++i>=argc) return -EPROTO;
363 fChargeThreshold=argument.Atof();
364 HLTInfo("The charge threshold has been set to %d.", fChargeThreshold);
372 int AliHLTTPCHWClusterTransformComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) {
373 // see header file for class documentation
374 return ConfigureFromCDBTObjString(fgkOCDBEntryHWTransform);
377 void AliHLTTPCHWClusterTransformComponent::PrintDebug(AliHLTUInt32_t *buffer, Int_t size){
378 // see header file for class documentation
380 HLTInfo("The size is: %d", size);
381 for(Int_t n32bit=0; n32bit<size; n32bit++){
383 AliHLTUInt8_t *wordPtr = reinterpret_cast<AliHLTUInt8_t*>(&buffer[n32bit]);
384 // cout << "word ptr initialized"<<endl;
385 for(Int_t w=3;w>=0;w--){
386 // cout <<"accessing word"<<endl;
387 AliHLTUInt8_t word = wordPtr[w];
388 // cout<< "word was accessed"<<endl;
389 for(int n=7; n>=0; n--){
390 //print the byte values
391 if((((word>>n)<<7)&0x80) != 0){
402 } // end of PrintDebug