HLT/TPCLib/AliHLTTPCSpacePointContainer.cxx

   1 // $Id$
   2
   3 //**************************************************************************
   4 //* This file is property of and copyright by the ALICE HLT Project        *
   5 //* ALICE Experiment at CERN, All rights reserved.                         *
   6 //*                                                                        *
   7 //* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
   8 //*                  for The ALICE HLT Project.                            *
   9 //*                                                                        *
  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 //**************************************************************************
  18
  19 /// @file   AliHLTTPCSpacePointContainer.h
  20 /// @author Matthias Richter
  21 /// @date   2011-04-29
  22 /// @brief  Helper class for handling of HLT TPC space point data blocks
  23 ///
  24
  25 #include "AliHLTTPCSpacePointContainer.h"
  26 #include "AliHLTTPCSpacePointData.h"
  27 #include "AliHLTTPCDefinitions.h"
  28 #include "AliHLTTPCTransform.h"
  29 #include "AliHLTComponent.h"
  30 #include "AliHLTTemplates.h"
  31 #include "TMath.h"
  32 #include <memory>
  33 #include <algorithm>
  34
  35 /** ROOT macro for the implementation of ROOT specific class methods */
  36 ClassImp(AliHLTTPCSpacePointContainer)
  37
  38 AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointContainer()
  39   : AliHLTSpacePointContainer()
  40   , fClusters()
  41   , fSelections()
  42 {
  43   // see header file for class documentation
  44   // or
  45   // refer to README to build package
  46   // or
  47   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  48 }
  49
  50 AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointContainer(const AliHLTTPCSpacePointContainer& c)
  51   : AliHLTSpacePointContainer(c)
  52   , fClusters(c.fClusters.begin(), c.fClusters.end())
  53   , fSelections()
  54 {
  55   /// copy constructor
  56 }
  57
  58 AliHLTTPCSpacePointContainer& AliHLTTPCSpacePointContainer::operator=(const AliHLTTPCSpacePointContainer& c)
  59 {
  60   /// assignment operator
  61   if (&c==this) return *this;
  62   AliHLTSpacePointContainer::operator=(c);
  63   fClusters=c.fClusters;
  64
  65   return *this;
  66 }
  67
  68 AliHLTTPCSpacePointContainer::~AliHLTTPCSpacePointContainer()
  69 {
  70   // destructor
  71
  72   Clear();
  73 }
  74
  75 int AliHLTTPCSpacePointContainer::AddInputBlock(const AliHLTComponentBlockData* pDesc)
  76 {
  77   // add input block to the collection
  78   if (!pDesc) return -EINVAL;
  79   int count=0;
  80   if (pDesc->fDataType!=AliHLTTPCDefinitions::fgkClustersDataType) {
  81     HLTWarning("ignoring data block of type %s", AliHLTComponent::DataType2Text(pDesc->fDataType).c_str());
  82     return 0;
  83   }
  84   if (!pDesc->fPtr || pDesc->fSize<sizeof(AliHLTTPCClusterData)) return -ENODATA;
  85
  86   // consistency check of the input block
  87   const AliHLTTPCClusterData* pClusterData=reinterpret_cast<AliHLTTPCClusterData*>(pDesc->fPtr);
  88   if (pClusterData->fSpacePointCnt*sizeof(AliHLTTPCSpacePointData)+sizeof(AliHLTTPCClusterData)!=pDesc->fSize) {
  89     HLTError("data block of type %s corrupted: number of entries %d is not consistent with block size %d",
  90              AliHLTComponent::DataType2Text(pDesc->fDataType).c_str(), pClusterData->fSpacePointCnt, pDesc->fSize);
  91     return -EBADMSG;
  92   }
  93
  94   AliHLTUInt8_t minslice = AliHLTTPCDefinitions::GetMinSliceNr( pDesc->fSpecification );
  95   AliHLTUInt8_t maxslice = AliHLTTPCDefinitions::GetMaxSliceNr( pDesc->fSpecification );
  96   AliHLTUInt8_t minpart  = AliHLTTPCDefinitions::GetMinPatchNr( pDesc->fSpecification );
  97   AliHLTUInt8_t maxpart  = AliHLTTPCDefinitions::GetMaxPatchNr( pDesc->fSpecification );
  98   bool bIsSinglePartition=(pDesc->fSpecification==kAliHLTVoidDataSpec?false:minslice==maxslice && minpart==maxpart);
  99
 100   for (UInt_t i=0; i<pClusterData->fSpacePointCnt; i++) {
 101     AliHLTUInt32_t clusterID=~(AliHLTUInt32_t)0;
 102     if (bIsSinglePartition) {
 103       // cluster ID has to match ID encoded from slice, partition and index
 104       clusterID=AliHLTTPCSpacePointData::GetID(minslice, minpart, i);
 105       if (clusterID!=pClusterData->fSpacePoints[i].fID) {
 106         HLTWarning("cluster ID 0x%08x does not match slice %d partition %d index %d",
 107                    pClusterData->fSpacePoints[i].fID, minslice, minpart, i);
 108       }
 109     } else {
 110       // check the cluster ID for correct bounds
 111       clusterID=pClusterData->fSpacePoints[i].fID;
 112       UInt_t clusterSlice =AliHLTTPCSpacePointData::GetSlice(clusterID);
 113       UInt_t clusterPart  =AliHLTTPCSpacePointData::GetPatch(clusterID);
 114       UInt_t clusterNumber=AliHLTTPCSpacePointData::GetNumber(clusterID);
 115       if (pDesc->fSpecification!=kAliHLTVoidDataSpec) {
 116         if (clusterSlice<minslice || clusterSlice>maxslice ||
 117             clusterPart<minpart || clusterPart>maxpart) {
 118           HLTWarning("cluster ID 0x%08d out of range indicated by data specification 0x%08x", clusterID, pDesc->fSpecification);
 119         } else if (clusterNumber!=i) {
 120           HLTWarning("cluster ID 0x%08d does not match index %d in block 0x%08x", clusterID, i, pDesc->fSpecification);
 121         }
 122       }
 123     }
 124     {
 125       // consistency check for x and row number
 126       // UInt_t clusterSlice =AliHLTTPCSpacePointData::GetSlice(clusterID);
 127       // UInt_t clusterPart  =AliHLTTPCSpacePointData::GetPatch(clusterID);
 128       // int row=AliHLTTPCTransform::GetPadRow(pClusterData->fSpacePoints[i].fX);
 129       // if (row<AliHLTTPCTransform::GetFirstRow(clusterPart) || row>AliHLTTPCTransform::GetLastRow(clusterPart)) {
 130       //        HLTError("row number %d calculated from x value %f is outside slice %d partition %d, expected row %d"
 131       //                 , row, pClusterData->fSpacePoints[i].fX, clusterSlice, clusterPart, pClusterData->fSpacePoints[i].fPadRow);
 132       // }
 133     }
 134
 135     if (fClusters.find(clusterID)==fClusters.end()) {
 136       // new cluster
 137       fClusters[clusterID]=AliHLTTPCSpacePointProperties(&pClusterData->fSpacePoints[i]);
 138       count++;
 139     } else {
 140       HLTError("cluster with ID 0x%08x already existing, skipping cluster %d of data block 0x%08x",
 141                clusterID, i, pDesc->fSpecification);
 142     }
 143   }
 144
 145   return count;
 146 }
 147
 148 int AliHLTTPCSpacePointContainer::GetClusterIDs(vector<AliHLTUInt32_t>& tgt) const
 149 {
 150   // get array of cluster IDs
 151   tgt.clear();
 152   transform(fClusters.begin(), fClusters.end(), back_inserter(tgt), HLT::AliGetKey());
 153   return tgt.size();
 154 }
 155
 156 bool AliHLTTPCSpacePointContainer::Check(AliHLTUInt32_t clusterID) const
 157 {
 158   // check if the cluster is available
 159   return fClusters.find(clusterID)!=fClusters.end();
 160 }
 161
 162 const vector<AliHLTUInt32_t>* AliHLTTPCSpacePointContainer::GetClusterIDs(AliHLTUInt32_t mask)
 163 {
 164   // get array of cluster IDs filtered by mask
 165   if (fSelections.find(mask)!=fSelections.end()) {
 166     // return existing selection
 167     return fSelections.find(mask)->second;
 168   }
 169   // create new collection
 170   vector<AliHLTUInt32_t>* selected=new vector<AliHLTUInt32_t>;
 171   if (!selected) return NULL;
 172   UInt_t slice=AliHLTTPCSpacePointData::GetSlice(mask);
 173   UInt_t partition=AliHLTTPCSpacePointData::GetPatch(mask);
 174   HLTInfo("creating collection 0x%08x", mask);
 175   for (std::map<AliHLTUInt32_t, AliHLTTPCSpacePointProperties>::const_iterator cl=fClusters.begin();
 176        cl!=fClusters.end(); cl++) {
 177     UInt_t s=AliHLTTPCSpacePointData::GetSlice(cl->first);
 178     UInt_t p=AliHLTTPCSpacePointData::GetPatch(cl->first);
 179     if ((slice>=(unsigned)AliHLTTPCTransform::GetNSlice() || s==slice) &&
 180         (partition>=(unsigned)AliHLTTPCTransform::GetNumberOfPatches() || p==partition)) {
 181       selected->push_back(cl->first);
 182     }
 183   }
 184   HLTInfo("collection 0x%08x with %d spacepoints", mask, selected->size());
 185   fSelections[mask]=selected;
 186   return selected;
 187 }
 188
 189 float AliHLTTPCSpacePointContainer::GetX(AliHLTUInt32_t clusterID) const
 190 {
 191   // get X coordinate
 192   if (fClusters.find(clusterID)==fClusters.end() ||
 193       fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
 194   // FIXME: understand deviation from the nominal x value
 195   // there is a small deviation in the x coordinate - padrow number correlation
 196   // in principle, the clusterfinder only uses the mapping to set the x parameter.
 197   // now extracting the x value from the padrow no.
 198   //return fClusters.find(clusterID)->second.Data()->fX;
 199   return AliHLTTPCTransform::Row2X(fClusters.find(clusterID)->second.Data()->fPadRow);
 200 }
 201
 202 float AliHLTTPCSpacePointContainer::GetXWidth(AliHLTUInt32_t clusterID) const
 203 {
 204   // get error for X coordinate
 205   if (fClusters.find(clusterID)==fClusters.end() ||
 206       fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
 207   return 0.0; // fixed in padrow number
 208 }
 209
 210 float AliHLTTPCSpacePointContainer::GetY(AliHLTUInt32_t clusterID) const
 211 {
 212   // get Y coordinate
 213   if (fClusters.find(clusterID)==fClusters.end() ||
 214       fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
 215   return fClusters.find(clusterID)->second.Data()->fY;
 216 }
 217
 218 float AliHLTTPCSpacePointContainer::GetYWidth(AliHLTUInt32_t clusterID) const
 219 {
 220   // get error for Y coordinate
 221   if (fClusters.find(clusterID)==fClusters.end() ||
 222       fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
 223   return fClusters.find(clusterID)->second.Data()->fSigmaY2;
 224 }
 225
 226 float AliHLTTPCSpacePointContainer::GetZ(AliHLTUInt32_t clusterID) const
 227 {
 228   // get Z coordinate
 229   if (fClusters.find(clusterID)==fClusters.end() ||
 230       fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
 231   return fClusters.find(clusterID)->second.Data()->fZ;
 232 }
 233
 234 float AliHLTTPCSpacePointContainer::GetZWidth(AliHLTUInt32_t clusterID) const
 235 {
 236   // get error for Z coordinate
 237   if (fClusters.find(clusterID)==fClusters.end() ||
 238       fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
 239   return fClusters.find(clusterID)->second.Data()->fSigmaZ2;
 240 }
 241
 242 float AliHLTTPCSpacePointContainer::GetCharge(AliHLTUInt32_t clusterID) const
 243 {
 244   // get charge
 245   if (fClusters.find(clusterID)==fClusters.end() ||
 246       fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
 247   return fClusters.find(clusterID)->second.Data()->fCharge;
 248 }
 249
 250 float AliHLTTPCSpacePointContainer::GetMaxSignal(AliHLTUInt32_t clusterID) const
 251 {
 252   // get charge
 253   if (fClusters.find(clusterID)==fClusters.end() ||
 254       fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
 255   return fClusters.find(clusterID)->second.Data()->fQMax;
 256 }
 257
 258 float AliHLTTPCSpacePointContainer::GetPhi(AliHLTUInt32_t clusterID) const
 259 {
 260   // get charge
 261
 262   // phi can be derived directly from the id, no need to search
 263   // for existing cluster
 264   int slice=AliHLTTPCSpacePointData::GetSlice(clusterID);
 265   return ( slice + 0.5 ) * TMath::Pi() / 9.0;
 266 }
 267
 268 void AliHLTTPCSpacePointContainer::Clear(Option_t * option)
 269 {
 270   // clear the object and reset pointer references
 271   fClusters.clear();
 272
 273   for (std::map<AliHLTUInt32_t, vector<AliHLTUInt32_t>*>::iterator selection=fSelections.begin();
 274        selection!=fSelections.end(); selection++) {
 275     if (selection->second) delete selection->second;
 276   }
 277   fSelections.clear();
 278
 279   AliHLTSpacePointContainer::Clear(option);
 280 }
 281
 282 void AliHLTTPCSpacePointContainer::Print(ostream& out, Option_t */*option*/) const
 283 {
 284   // print to stream
 285   out << "AliHLTTPCSpacePointContainer::Print" << endl;
 286   out << "n clusters: " << fClusters.size() << endl;
 287   for (std::map<AliHLTUInt32_t, AliHLTTPCSpacePointProperties>::const_iterator cl=fClusters.begin();
 288        cl!=fClusters.end(); cl++) {
 289     out << " " << cl->first << cl->second << endl;
 290   }
 291 }
 292
 293 AliHLTSpacePointContainer* AliHLTTPCSpacePointContainer::SelectByMask(AliHLTUInt32_t mask, bool /*bAlloc*/) const
 294 {
 295   /// create a collection of clusters for a space point mask
 296   std::auto_ptr<AliHLTTPCSpacePointContainer> c(new AliHLTTPCSpacePointContainer);
 297   if (!c.get()) return NULL;
 298
 299   UInt_t slice=AliHLTTPCSpacePointData::GetSlice(mask);
 300   UInt_t partition=AliHLTTPCSpacePointData::GetPatch(mask);
 301   for (std::map<AliHLTUInt32_t, AliHLTTPCSpacePointProperties>::const_iterator cl=fClusters.begin();
 302        cl!=fClusters.end(); cl++) {
 303     UInt_t s=AliHLTTPCSpacePointData::GetSlice(cl->first);
 304     UInt_t p=AliHLTTPCSpacePointData::GetPatch(cl->first);
 305     if ((slice>=(unsigned)AliHLTTPCTransform::GetNSlice() || s==slice) &&
 306         (partition>=(unsigned)AliHLTTPCTransform::GetNumberOfPatches() || p==partition)) {
 307       c->fClusters[cl->first]=cl->second;
 308     }
 309   }
 310   return c.release();
 311 }
 312
 313 AliHLTSpacePointContainer* AliHLTTPCSpacePointContainer::SelectByTrack(int trackId, bool /*bAlloc*/) const
 314 {
 315   /// create a collection of clusters for a specific track
 316   std::auto_ptr<AliHLTTPCSpacePointContainer> c(new AliHLTTPCSpacePointContainer);
 317   if (!c.get()) return NULL;
 318
 319   HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties, int>(&AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties::GetTrackId,trackId));
 320   return c.release();
 321 }
 322
 323 AliHLTSpacePointContainer* AliHLTTPCSpacePointContainer::SelectByMC(int mcId, bool /*bAlloc*/) const
 324 {
 325   /// create a collection of clusters for a specific MC track
 326   std::auto_ptr<AliHLTTPCSpacePointContainer> c(new AliHLTTPCSpacePointContainer);
 327   if (!c.get()) return NULL;
 328
 329   HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties, int>(&AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties::GetMCId,mcId));
 330   return c.release();
 331 }
 332
 333 AliHLTSpacePointContainer* AliHLTTPCSpacePointContainer::UsedClusters(bool /*bAlloc*/) const
 334 {
 335   /// create a collection of all used clusters
 336   std::auto_ptr<AliHLTTPCSpacePointContainer> c(new AliHLTTPCSpacePointContainer);
 337   if (!c.get()) return NULL;
 338
 339   HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties, bool>(&AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties::IsUsed,true));
 340   return c.release();
 341 }
 342
 343 AliHLTSpacePointContainer* AliHLTTPCSpacePointContainer::UnusedClusters(bool /*bAlloc*/) const
 344 {
 345   /// create a collection of all unused clusters
 346   std::auto_ptr<AliHLTTPCSpacePointContainer> c(new AliHLTTPCSpacePointContainer);
 347   if (!c.get()) return NULL;
 348
 349   HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties, bool>(&AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties::IsUsed,false));
 350   return c.release();
 351 }
 352
 353 int AliHLTTPCSpacePointContainer::MarkUsed(const AliHLTUInt32_t* clusterIDs, int arraySize)
 354 {
 355   /// mark the clusters with specified IDs as used
 356   if (!clusterIDs) return -EINVAL;
 357   int iCount=0;
 358   for (int i=0; i<arraySize; i++) {
 359     if (fClusters.find(clusterIDs[i])==fClusters.end()) continue;
 360     fClusters[clusterIDs[i]].MarkUsed();
 361     iCount++;
 362   }
 363   return iCount;
 364 }
 365
 366 int AliHLTTPCSpacePointContainer::SetTrackID(int trackID, const AliHLTUInt32_t* clusterIDs, int arraySize)
 367 {
 368   /// set track id for specified clusters
 369   if (!clusterIDs) return -EINVAL;
 370   int iCount=0;
 371   for (int i=0; i<arraySize; i++) {
 372     if (fClusters.find(clusterIDs[i])==fClusters.end()) continue;
 373     fClusters[clusterIDs[i]].SetTrackId(trackID);
 374     iCount++;
 375   }
 376   return iCount;
 377 }
 378
 379 int AliHLTTPCSpacePointContainer::GetTrackID(AliHLTUInt32_t clusterID) const
 380 {
 381   /// get track id for specified cluster
 382   map<AliHLTUInt32_t, AliHLTTPCSpacePointProperties>::const_iterator element=fClusters.find(clusterID);
 383   if (element==fClusters.end()) return -1;
 384   return element->second.GetTrackId();
 385 }
 386
 387 int AliHLTTPCSpacePointContainer::SetMCID(int mcID, const AliHLTUInt32_t* clusterIDs, int arraySize)
 388 {
 389   /// set mc id for specified clusters
 390   if (!clusterIDs) return -EINVAL;
 391   int iCount=0;
 392   for (int i=0; i<arraySize; i++) {
 393     if (fClusters.find(clusterIDs[i])==fClusters.end()) continue;
 394     fClusters[clusterIDs[i]].SetMCId(mcID);
 395     iCount++;
 396   }
 397   return iCount;
 398 }
 399
 400 AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties::AliHLTTPCSpacePointProperties()
 401   : fCluster(NULL)
 402   , fUsed(false)
 403   , fTrackId(-1)
 404   , fMCId(-1)
 405 {
 406   // constructor
 407 }
 408
 409 AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties::AliHLTTPCSpacePointProperties(const AliHLTTPCSpacePointData* pCluster)
 410   : fCluster(pCluster)
 411   , fUsed(false)
 412   , fTrackId(-1)
 413   , fMCId(-1)
 414 {
 415   // constructor
 416 }
 417
 418 AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties::AliHLTTPCSpacePointProperties(const AliHLTTPCSpacePointProperties& src)
 419   : fCluster(src.fCluster)
 420   , fUsed(src.fUsed)
 421   , fTrackId(src.fTrackId)
 422   , fMCId(src.fMCId)
 423 {
 424   // copy constructor
 425 }
 426
 427 AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties& AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties::operator=(const AliHLTTPCSpacePointProperties& src)
 428 {
 429   // assignment operator
 430   if (&src==this) return *this;
 431   fCluster=src.fCluster;
 432   fUsed=src.fUsed;
 433   fTrackId=src.fTrackId;
 434   fMCId=src.fMCId;
 435
 436   return *this;
 437 }
 438
 439 void AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties::Print(ostream& out, Option_t */*option*/) const
 440 {
 441   // print info
 442   if (!Data()) {
 443     out << "no data";
 444     return;
 445   }
 446   const AliHLTTPCSpacePointData* data=Data();
 447   out << " " << data->fX << " " << data->fY << " " << data->fZ << " " << (UInt_t)data->fPadRow
 448       << " " << data->GetSigmaY2() << " "  << data->GetSigmaZ2()
 449       << " " << data->GetCharge() << " "  << data->GetQMax()
 450       << " " << fTrackId << " " << fMCId << " " << fUsed;
 451 }
 452
 453 ostream& operator<<(ostream &out, const AliHLTTPCSpacePointContainer::AliHLTTPCSpacePointProperties& p)
 454 {
 455   p.Print(out);
 456   return out;
 457 }