code cleanup, removing unused functionality; fully implemented in the AliHLTTPCDataCo...
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 20 Mar 2012 23:34:07 +0000 (23:34 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 20 Mar 2012 23:34:07 +0000 (23:34 +0000)
HLT/TPCLib/AliHLTTPCClusterAccessHLTOUT.cxx
HLT/TPCLib/AliHLTTPCClusterAccessHLTOUT.h

index 0889a1b..ad13c37 100644 (file)
@@ -1,7 +1,7 @@
 // $Id$
 
 //**************************************************************************
-//* This file is property of and copyright by the ALICE HLT Project        * 
+//* This file is property of and copyright by the ALICE Project            * 
 //* ALICE Experiment at CERN, All rights reserved.                         *
 //*                                                                        *
 //* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
@@ -363,365 +363,6 @@ int AliHLTTPCClusterAccessHLTOUT::ProcessClusters(const char* params)
   return pArray->GetEntriesFast();
 }
 
-int AliHLTTPCClusterAccessHLTOUT::ReadAliHLTTPCClusterMCData(AliHLTOUT* pHLTOUT, AliHLTTPCClusterMCDataList &tpcClusterLabels) const
-{
-  // read cluster data from AliHLTTPCClusterData
-  int iResult=0;
-  if (!pHLTOUT) return -EINVAL;
-  do {
-    const AliHLTUInt8_t* pBuffer=NULL;
-    AliHLTUInt32_t size=0;
-    if ((iResult=pHLTOUT->GetDataBuffer(pBuffer, size))<0) {
-      continue;
-    }
-    if (pBuffer==NULL || size<4) {
-      AliError("invalid cluster mc data block");
-      continue;
-    }
-    const AliHLTTPCClusterMCData* clusterMCData = reinterpret_cast<const AliHLTTPCClusterMCData*>(pBuffer);
-    Int_t nLabels = (Int_t) clusterMCData->fCount;
-    if (nLabels*sizeof(AliHLTTPCClusterMCLabel) + sizeof(AliHLTTPCClusterMCData) != size) {
-      AliError("inconsistent cluster mc data block size, skipping block");
-      continue;
-    }
-    // id of the cluster is 
-    AliHLTComponentDataType dt=kAliHLTVoidDataType;
-    AliHLTUInt32_t specification=kAliHLTVoidDataSpec;
-    if (pHLTOUT->GetDataBlockDescription(dt, specification)<0) {
-      AliError("failed to retrieve data block description, skipping mc cluster data block ...");
-      continue;
-    }
-    AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(specification);
-    AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(specification);
-    if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr(specification) ||
-       partition!=AliHLTTPCDefinitions::GetMaxPatchNr(specification)) {
-      AliError(Form("can not read cluster mc data block with data of multiple partitions, skipping block %s %08x",
-                   AliHLTComponent::DataType2Text(dt).c_str(), specification));
-      continue;
-    }
-    const AliHLTTPCClusterMCLabel *labels = clusterMCData->fLabels;
-    for (int i=0; i<nLabels; i++) {
-      AliHLTUInt32_t id=AliHLTTPCSpacePointData::GetID(slice, partition, i);
-      if (tpcClusterLabels.find(id)==tpcClusterLabels.end()) {
-       // new cluster
-       tpcClusterLabels[id]=labels[i];
-      } else {
-       AliError(Form("cluster with ID 0x%08x already existing, skipping cluster %d of data block 0x%08x",
-                     id, i, specification));
-      }
-    }
-  } while (pHLTOUT->SelectNextDataBlock()>=0);
-  return iResult;
-}
-
-int AliHLTTPCClusterAccessHLTOUT::ReadAliHLTTPCClusterData(AliHLTOUT* pHLTOUT, TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels) const
-{
-  // read cluster data from AliHLTTPCClusterData
-  int iResult=0;
-  if (!pHLTOUT || !pClusters) return -EINVAL;
-  do {
-    const AliHLTUInt8_t* pBuffer=NULL;
-    AliHLTUInt32_t size=0;
-    if ((iResult=pHLTOUT->GetDataBuffer(pBuffer, size))<0) {
-      continue;
-    }
-    if (pBuffer==NULL || size<4) {
-      AliError("invalid cluster data block");
-      continue;
-    }
-    AliHLTComponentDataType dt=kAliHLTVoidDataType;
-    AliHLTUInt32_t specification=kAliHLTVoidDataSpec;
-    if (pHLTOUT->GetDataBlockDescription(dt, specification)<0) {
-      AliError("failed to retrieve data block description, skipping mc cluster data block ...");
-      continue;
-    }
-    const AliHLTTPCClusterData* clusterData = reinterpret_cast<const AliHLTTPCClusterData*>(pBuffer);
-    Int_t nSpacepoints = (Int_t) clusterData->fSpacePointCnt;
-    if (nSpacepoints*sizeof(AliHLTTPCSpacePointData) + sizeof(AliHLTTPCClusterData) != size) {
-      AliError("inconsistent cluster data block size, skipping block");
-      continue;
-    }
-    const AliHLTTPCSpacePointData *clusters = clusterData->fSpacePoints;
-    int offset=pClusters->GetEntries();
-    pClusters->ExpandCreate(offset+nSpacepoints);
-    AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(specification);
-    AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(specification);
-    // FIXME: get first row number of outer sectors from a common definition instead using number
-    unsigned rowOffset=partition<2?0:63;
-    for (int i=0; i<nSpacepoints; i++) {
-      if (!pClusters->At(offset+i)) continue;
-      AliTPCclusterMI* pCluster=dynamic_cast<AliTPCclusterMI*>(pClusters->At(offset+i));
-      if (!pCluster) {
-       AliError("invalid object type, expecting AliTPCclusterMI");
-       break; // this is a problem of all objects
-      }
-      if (clusters[i].fPadRow<rowOffset) {
-       AliError(Form("invalid row number %d, expecting minimum row number %d for slice %d partition %d", clusters[i].fPadRow, rowOffset, slice, partition));
-      } else {
-      pCluster->SetRow(clusters[i].fPadRow-rowOffset);
-      }
-      pCluster->SetPad(clusters[i].fY);
-      pCluster->SetTimeBin(clusters[i].fZ);
-      pCluster->SetSigmaY2(clusters[i].fSigmaY2);
-      pCluster->SetSigmaZ2(clusters[i].fSigmaZ2);
-      pCluster->SetQ(clusters[i].fCharge);
-      pCluster->SetMax(clusters[i].fQMax);
-      if (tpcClusterLabels) {
-       if (tpcClusterLabels->find(clusters[i].fID)!=tpcClusterLabels->end()) {
-         const AliHLTTPCClusterMCWeight* mcWeights=tpcClusterLabels->find(clusters[i].fID)->second.fClusterID;
-         for (int k=0; k<3; k++) {
-           // TODO: sort the labels according to the weight in order to assign the most likely mc label
-           // to the first component 
-           pCluster->SetLabel(mcWeights[k].fMCID, k);
-         }
-       } else {
-         AliError(Form("can not find mc label of cluster with id %0x08x", clusters[i].fID));
-       }
-      }
-    }
-    if (fVerbosity>0) AliInfo(Form("converted %d cluster(s) from block %s 0x%08x", nSpacepoints, AliHLTComponent::DataType2Text(dt).c_str(), specification));
-  } while (pHLTOUT->SelectNextDataBlock()>=0);
-  return iResult;
-}
-
-int AliHLTTPCClusterAccessHLTOUT::ReadAliHLTTPCRawClusterData(AliHLTOUT* pHLTOUT, TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels)
-{
-  // read cluster data from AliHLTTPCClusterData
-
-  // FIXME: this is in large parts like ReadAliHLTTPCClusterData,
-  // make a common method
-  int iResult=0;
-  if (!pHLTOUT || !pClusters) return -EINVAL;
-  do {
-    const AliHLTUInt8_t* pBuffer=NULL;
-    AliHLTUInt32_t size=0;
-    if ((iResult=pHLTOUT->GetDataBuffer(pBuffer, size))<0) {
-      continue;
-    }
-    if (pBuffer==NULL || size<4) {
-      AliError("invalid cluster data block");
-      continue;
-    }
-    AliHLTComponentDataType dt=kAliHLTVoidDataType;
-    AliHLTUInt32_t specification=kAliHLTVoidDataSpec;
-    if (pHLTOUT->GetDataBlockDescription(dt, specification)<0) {
-      AliError("failed to retrieve data block description, skipping mc cluster data block ...");
-      continue;
-    }
-    const AliHLTTPCRawClusterData* clusterData = reinterpret_cast<const AliHLTTPCRawClusterData*>(pBuffer);
-    Int_t nCount = (Int_t) clusterData->fCount;
-    if (clusterData->fVersion!=0) {
-      // this is encoded data of different formats
-      switch (clusterData->fVersion) {
-      case 1: 
-       iResult=ReadAliHLTTPCRawClusterDataDeflateSimple(reinterpret_cast<const AliHLTUInt8_t*>(clusterData->fClusters),
-                                                        size-sizeof(AliHLTTPCRawClusterData), nCount, specification,
-                                                        pClusters, tpcClusterLabels);
-       break;
-      default:
-       iResult=-EPROTO;
-      }
-      return iResult;
-    }
-
-    if (nCount*sizeof(AliHLTTPCRawCluster) + sizeof(AliHLTTPCRawClusterData) != size) {
-      AliError("inconsistent cluster data block size, skipping block");
-      continue;
-    }
-    const AliHLTTPCRawCluster *clusters = clusterData->fClusters;
-    int offset=pClusters->GetEntries();
-    pClusters->ExpandCreate(offset+nCount);
-    AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(specification);
-    AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(specification);
-    // FIXME: get first row number of outer sectors from a common definition instead using number
-    int rowOffset=partition<2?0:63;
-    for (int i=0; i<nCount; i++) {
-      if (!pClusters->At(offset+i)) continue;
-      AliTPCclusterMI* pCluster=dynamic_cast<AliTPCclusterMI*>(pClusters->At(offset+i));
-      if (!pCluster) {
-       AliError("invalid object type, expecting AliTPCclusterMI");
-       break; // this is a problem of all objects
-      }
-      if (fVerbosity>1) AliInfo(Form("cluster padrow %d (slice %d partition %d)", clusters[i].GetPadRow(), slice, partition));
-      if (clusters[i].GetPadRow()<rowOffset) {
-       AliError(Form("invalid row number %d, expecting minimum row number %d for slice %d partition %d", clusters[i].GetPadRow(), rowOffset, slice, partition));
-      } else {
-      pCluster->SetRow(clusters[i].GetPadRow()-rowOffset);
-      }
-      pCluster->SetPad(clusters[i].GetPad());
-      pCluster->SetTimeBin(clusters[i].GetTime());
-      pCluster->SetSigmaY2(clusters[i].GetSigmaY2());
-      pCluster->SetSigmaZ2(clusters[i].GetSigmaZ2());
-      pCluster->SetQ(clusters[i].GetCharge());
-      pCluster->SetMax(clusters[i].GetQMax());
-      if (tpcClusterLabels) {
-       UInt_t clusterID=AliHLTTPCSpacePointData::GetID(slice, partition, i);
-       if (tpcClusterLabels->find(clusterID)!=tpcClusterLabels->end()) {
-         const AliHLTTPCClusterMCWeight* mcWeights=tpcClusterLabels->find(clusterID)->second.fClusterID;
-         for (int k=0; k<3; k++) {
-           // TODO: sort the labels according to the weight in order to assign the most likely mc label
-           // to the first component 
-           pCluster->SetLabel(mcWeights[k].fMCID, k);
-         }
-       } else {
-         AliError(Form("can not find mc label of cluster with id %0x08x", clusterID));
-       }
-      }
-    }
-    if (fVerbosity>0) AliInfo(Form("converted %d cluster(s) from block %s 0x%08x", nCount, AliHLTComponent::DataType2Text(dt).c_str(), specification));
-  } while (pHLTOUT->SelectNextDataBlock()>=0);
-  return iResult;
-}
-
-int AliHLTTPCClusterAccessHLTOUT::ReadRemainingClustersCompressed(AliHLTOUT* pHLTOUT, TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels)
-{
-  // read cluster data from AliHLTTPCClusterData
-  int iResult=0;
-  if (!pHLTOUT || !pClusters) return -EINVAL;
-  do {
-    const AliHLTUInt8_t* pBuffer=NULL;
-    AliHLTUInt32_t size=0;
-    if ((iResult=pHLTOUT->GetDataBuffer(pBuffer, size))<0) {
-      continue;
-    }
-    if (pBuffer==NULL || size<4) {
-      AliError("invalid cluster data block");
-      continue;
-    }
-    AliHLTComponentDataType dt=kAliHLTVoidDataType;
-    AliHLTUInt32_t specification=kAliHLTVoidDataSpec;
-    if (pHLTOUT->GetDataBlockDescription(dt, specification)<0) {
-      AliError("failed to retrieve data block description, skipping mc cluster data block ...");
-      continue;
-    }
-    const AliHLTTPCRawClusterData* clusterData = reinterpret_cast<const AliHLTTPCRawClusterData*>(pBuffer);
-    Int_t nCount = (Int_t) clusterData->fCount;
-
-    // this is encoded data of different formats
-    switch (clusterData->fVersion) {
-    case 1: 
-      iResult=ReadAliHLTTPCRawClusterDataDeflateSimple(reinterpret_cast<const AliHLTUInt8_t*>(clusterData->fClusters),
-                                                      size-sizeof(AliHLTTPCRawClusterData), nCount, specification,
-                                                      pClusters, tpcClusterLabels);
-      break;
-    default:
-      AliError(Form("invalid cluster format version %d", clusterData->fVersion));
-      iResult=-EPROTO;
-    }
-
-    if (fVerbosity>0) AliInfo(Form("converted %d cluster(s) from block %s 0x%08x", nCount, AliHLTComponent::DataType2Text(dt).c_str(), specification));
-  } while (pHLTOUT->SelectNextDataBlock()>=0 && iResult>=0);
-
-  return iResult;
-}
-
-int AliHLTTPCClusterAccessHLTOUT::ReadAliHLTTPCRawClusterDataDeflateSimple(const AliHLTUInt8_t* pData, int dataSize,
-                                                                          int nofClusters, AliHLTUInt32_t specification,
-                                                                          TClonesArray* pClusters,
-                                                                          const AliHLTTPCClusterMCDataList *tpcClusterLabels)
-{
-  // read cluster data from AliHLTTPCClusterData
-
-  // FIXME: quick implementation to read the compressed cluster data from HLTOUT
-  // the data definition below is the same as in AliHLTTPCDataCompressionComponent
-  // but needs to be moved to a common class (AliHLTTPCDefinitions?)
-  // Think about a decoder class supporting iterator objects for various types
-  // of cluster data
-  int iResult=0;
-  if (!pData || !pClusters) return -EINVAL;
-  AliHLTDataInflater inflater;
-  if ((iResult=inflater.InitBitDataInput(pData, dataSize))<0) {
-    return iResult;
-  }
-
-  int offset=pClusters->GetEntries();
-  pClusters->ExpandCreate(offset+nofClusters);
-  AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(specification);
-  AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(specification);
-  // the compressed format stores the difference of the local row number in
-  // the partition to the row of the last cluster
-  // add the first row in the partition to get global row number
-  // offline uses row number in physical sector, inner sector consists of
-  // partitions 0 and 1, outer sector of partition 2-5
-  int rowOffset=AliHLTTPCTransform::GetFirstRow(partition)-(partition<2?0:AliHLTTPCTransform::GetFirstRow(2));
-
-  int parameterId=0;
-  int outClusterCnt=0;
-  AliHLTUInt8_t switchBit=0;
-  AliHLTUInt64_t value=0;
-  AliTPCclusterMI* pCluster=NULL;
-  AliHLTUInt32_t lastPadRow=0;
-  while (outClusterCnt<nofClusters && inflater.InputBit(switchBit)) {
-    const AliHLTTPCDefinitions::AliClusterParameter& parameter
-      =AliHLTTPCDefinitions::fgkClusterParameterDefinitions[parameterId];
-    // in mode DeflaterSimple, the optional parameter of the cluster parameter definition
-    // corresponds to the number bits of the reduced format
-    if (!inflater.InputBits(value, switchBit?parameter.fBitLength:parameter.fOptional)) {
-      break;
-    }
-
-    if (!pCluster) {
-      if (!pClusters->At(offset+outClusterCnt)) {
-       // here we should not get anymore because of the condition outClusterCnt<nofClusters
-       return -ENOSPC;
-      }
-      pCluster=dynamic_cast<AliTPCclusterMI*>(pClusters->At(offset+outClusterCnt));
-      if (!pCluster) {
-       AliError("invalid object type, expecting AliTPCclusterMI");
-       iResult=-EBADF; // this is a problem of all objects
-       break;
-      }
-    }
-    switch (parameterId) {
-    case AliHLTTPCDefinitions::kPadRow:
-      {pCluster->SetRow(value+lastPadRow+rowOffset); lastPadRow+=value;break;}
-    case AliHLTTPCDefinitions::kPad:
-      {float pad=value; pad/=parameter.fScale; pCluster->SetPad(pad); break;}
-    case AliHLTTPCDefinitions::kTime:
-      {float time=value; time/=parameter.fScale; pCluster->SetTimeBin(time); break;}
-    case AliHLTTPCDefinitions::kSigmaY2:
-      {float sigmaY2=value; sigmaY2/=parameter.fScale; pCluster->SetSigmaY2(sigmaY2); break;}
-    case AliHLTTPCDefinitions::kSigmaZ2:
-      {float sigmaZ2=value; sigmaZ2/=parameter.fScale; pCluster->SetSigmaZ2(sigmaZ2); break;}
-    case AliHLTTPCDefinitions::kCharge:
-      {pCluster->SetQ(value); break;}
-    case AliHLTTPCDefinitions::kQMax:
-      {pCluster->SetMax(value); break;}
-    }
-    if (parameterId>=AliHLTTPCDefinitions::kLast) {
-      // switch to next cluster
-      if (tpcClusterLabels) {
-       UInt_t clusterID=AliHLTTPCSpacePointData::GetID(slice, partition, outClusterCnt);
-       if (tpcClusterLabels->find(clusterID)!=tpcClusterLabels->end()) {
-         const AliHLTTPCClusterMCWeight* mcWeights=tpcClusterLabels->find(clusterID)->second.fClusterID;
-         for (int k=0; k<3; k++) {
-           // TODO: sort the labels according to the weight in order to assign the most likely mc label
-           // to the first component 
-           pCluster->SetLabel(mcWeights[k].fMCID, k);
-         }
-       } else {
-         AliError(Form("can not find mc label of cluster with id 0x%08x", clusterID));
-       }
-      }
-      outClusterCnt++;
-      pCluster=NULL;
-      parameterId=-1;
-    }
-    parameterId++;
-  }
-  inflater.Pad8Bits();
-  if (inflater.InputBit(switchBit)) {
-    AliWarning("format error of compressed clusters, there is more data than expected");
-  }
-  inflater.CloseBitDataInput();
-  if (iResult>=0 && nofClusters!=outClusterCnt) {
-    // is this a Fatal?
-    AliError(Form("error reading compressed cluster format: expected %d, read only %d cluster(s)", nofClusters, outClusterCnt));
-    return -EPROTO;
-  }
-  return iResult;
-}
-
 AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::AliTPCclusterMIContainer()
   : fClusterArrays()
   , fRemainingClusterIds()
@@ -773,70 +414,6 @@ AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::iterator& AliHLTTPCClust
   return fIterator;
 }
 
-int AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::AddClusterMCData(const AliHLTComponentBlockData* pDesc)
-{
-  /// add cluster mc data block
-  if (!pDesc) return -EINVAL;
-  if (pDesc->fDataType==AliHLTTPCDefinitions::AliHLTDataTypeClusterMCInfo()) {
-    AliHLTUInt8_t slice=AliHLTTPCDefinitions::GetMinSliceNr(pDesc->fSpecification);
-    AliHLTUInt8_t partition=AliHLTTPCDefinitions::GetMinPatchNr(pDesc->fSpecification);
-    unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
-    if (fClusterMCData.size()<=index) {
-      if ((int)fClusterMCData.size()<AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches()) {
-       fClusterMCData.resize(AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches(), NULL);
-      } else {
-       fClusterMCData.resize(index+1, NULL);
-      }
-    }
-    if (pDesc->fSize<sizeof(AliHLTTPCClusterMCData)) return -EINVAL;
-    const AliHLTTPCClusterMCData* pData=reinterpret_cast<const AliHLTTPCClusterMCData*>(pDesc->fPtr);
-    unsigned nLabels = pData->fCount;
-    if (nLabels*sizeof(AliHLTTPCClusterMCLabel) + sizeof(AliHLTTPCClusterMCData) != pDesc->fSize) {
-      return -EINVAL;
-    }
-    fClusterMCData[index]=pData;
-    return 0;
-  }
-  return -ENODATA;
-}
-
-int AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::AddClusterIds(const AliHLTComponentBlockData* pDesc)
-{
-  /// add cluster id block for remaining or track model clusters
-  if (!pDesc) return -EINVAL;
-  if (pDesc->fDataType==AliHLTTPCDefinitions::ClusterIdTracksDataType()) {
-    fTrackModelClusterIds.fIds=reinterpret_cast<AliHLTUInt32_t*>(pDesc->fPtr);
-    fTrackModelClusterIds.fSize=pDesc->fSize/sizeof(AliHLTUInt32_t);
-    return 0;
-  }
-  if (pDesc->fDataType==AliHLTTPCDefinitions::RemainingClusterIdsDataType()) {
-    AliHLTUInt8_t slice=AliHLTTPCDefinitions::GetMinSliceNr(pDesc->fSpecification);
-    AliHLTUInt8_t partition=AliHLTTPCDefinitions::GetMinPatchNr(pDesc->fSpecification);
-    unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
-    if (fRemainingClusterIds.size()<=index) {
-      if ((int)fRemainingClusterIds.size()<AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches()) {
-       fRemainingClusterIds.resize(AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches());
-      } else {
-       fRemainingClusterIds.resize(index+1);
-      }
-    }
-    fRemainingClusterIds[index].fIds=reinterpret_cast<AliHLTUInt32_t*>(pDesc->fPtr);
-    fRemainingClusterIds[index].fSize=pDesc->fSize/sizeof(AliHLTUInt32_t);
-    return 0;
-  }
-  return -ENODATA;
-}
-
-AliHLTUInt32_t AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::GetClusterId(int clusterNo) const
-{
-  /// get the cluster id from the current cluster id block (optional)
-  if (!fCurrentClusterIds ||
-      (int)fCurrentClusterIds->fSize<=clusterNo ||
-      clusterNo<0)
-    return kAliHLTVoidDataSpec;
-  return fCurrentClusterIds->fIds[clusterNo];
-}
-
 AliTPCclusterMI* AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::NextCluster(int slice, int partition)
 {
   /// load next cluster from array of the sepcific sector
@@ -851,31 +428,6 @@ AliTPCclusterMI* AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::NextClu
   return new (array[count]) AliTPCclusterMI;
 }
 
-int AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::SetMC(AliTPCclusterMI* pCluster, AliHLTUInt32_t clusterId)
-{
-  /// set MC data for the cluster
-  if (!pCluster) return -EINVAL;
-  if (clusterId==kAliHLTVoidDataSpec) return 0;
-
-  unsigned slice=AliHLTTPCSpacePointData::GetSlice(clusterId);
-  unsigned partition=AliHLTTPCSpacePointData::GetPatch(clusterId);
-  unsigned number=AliHLTTPCSpacePointData::GetNumber(clusterId);
-  if ((int)slice>=AliHLTTPCTransform::GetNSlice() ||
-      (int)partition>=AliHLTTPCTransform::GetNumberOfPatches()) return -EDOM;
-  unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
-  if (fClusterMCData.size()<=index ||
-      fClusterMCData[index]==NULL ||
-      fClusterMCData[index]->fCount<=number) return 0;
-  const AliHLTTPCClusterMCWeight* mcWeights=fClusterMCData[index]->fLabels[number].fClusterID;
-  for (int k=0; k<3; k++) {
-    // TODO: sort the labels according to the weight in order to assign the most likely mc label
-    // to the first component 
-    pCluster->SetLabel(mcWeights[k].fMCID, k);
-  }
-
-  return 0;
-}
-
 void  AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::Clear(Option_t* /*option*/)
 {
   /// internal cleanup
@@ -939,7 +491,6 @@ AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::iterator& AliHLTTPCClust
   // switch to next cluster
   if (!fData) {
     fCluster=NULL;
-    fClusterId=kAliHLTVoidDataSpec;
     return *this;
   }
   if (fClusterNo>=0 && !fCluster) {
@@ -947,10 +498,6 @@ AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::iterator& AliHLTTPCClust
     return *this;
   }
   fCluster=fData->NextCluster(slice, partition);
-  fClusterId=fData->GetClusterId(++fClusterNo);
-  if (fCluster && fClusterId!=kAliHLTVoidDataSpec) {
-    fData->SetMC(fCluster, fClusterId);
-  }
   // offline uses row number in physical sector, inner sector consists of
   // partitions 0 and 1, outer sector of partition 2-5
   fRowOffset=partition<2?0:AliHLTTPCTransform::GetFirstRow(2);
index de45b89..50c8d41 100644 (file)
@@ -2,7 +2,7 @@
 // $Id$
 #ifndef ALIHLTTPCCLUSTERACCESSHLTOUT_H
 #define ALIHLTTPCCLUSTERACCESSHLTOUT_H
-//* This file is property of and copyright by the ALICE HLT Project        * 
+//* This file is property of and copyright by the ALICE Project            * 
 //* ALICE Experiment at CERN, All rights reserved.                         *
 //* See cxx source for full Copyright notice                               *
 
@@ -106,23 +106,6 @@ class AliHLTTPCClusterAccessHLTOUT : public TObject
   /// process the cluster data block of various formats from HLTOUT
   int ProcessClusters(const char* params);
 
-  /// process the cluster mc data block {CLMCINFO:TPC } from HLTOUT
-  int ReadAliHLTTPCClusterMCData(AliHLTOUT* pHLTOUT, AliHLTTPCClusterMCDataList &tpcClusterLabels) const;
-
-  /// process the cluster data block {CLUSTERS:TPC } from HLTOUT
-  int ReadAliHLTTPCClusterData(AliHLTOUT* pHLTOUT, TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels=NULL) const;
-
-  /// process the cluster data block {CLUSTRAW:TPC } from HLTOUT
-  int ReadAliHLTTPCRawClusterData(AliHLTOUT* pHLTOUT, TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels);
-
-  /// process the clusters of type {REMCLSCM:TPC } from HLTOUT
-  int ReadRemainingClustersCompressed(AliHLTOUT* pHLTOUT, TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels);
-
-  /// process clusters encoded by AliHLTDataDeflaterSimple
-  int ReadAliHLTTPCRawClusterDataDeflateSimple(const AliHLTUInt8_t* pData, int dataSize,
-                                              int nofClusters, AliHLTUInt32_t specification,
-                                              TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels);
-
   /**
    * @class AliTPCclusterMIContainer
    * Cluster read interface for offline.
@@ -142,12 +125,12 @@ class AliHLTTPCClusterAccessHLTOUT : public TObject
 
     class iterator {
     public:
-      iterator() : fClusterNo(-1), fData(NULL), fCluster(NULL), fClusterId(kAliHLTVoidDataSpec), fRowOffset(0) {}
-      iterator(AliTPCclusterMIContainer* pData) : fClusterNo(-1), fData(pData), fCluster(NULL), fClusterId(fData?fData->GetClusterId(fClusterNo):kAliHLTVoidDataSpec), fRowOffset(0) {}
-      iterator(const iterator& other) : fClusterNo(other.fClusterNo), fData(other.fData), fCluster(other.fCluster), fClusterId(other.fClusterId), fRowOffset(other.fRowOffset) {}
+      iterator() : fClusterNo(-1), fData(NULL), fCluster(NULL), fRowOffset(0) {}
+      iterator(AliTPCclusterMIContainer* pData) : fClusterNo(-1), fData(pData), fCluster(NULL), fRowOffset(0) {}
+      iterator(const iterator& other) : fClusterNo(other.fClusterNo), fData(other.fData), fCluster(other.fCluster), fRowOffset(other.fRowOffset) {}
       iterator& operator=(const iterator& other) {
        if (this==&other) return *this;
-       fClusterNo=other.fClusterNo; fData=other.fData; fCluster=other.fCluster, fClusterId=other.fClusterId; fRowOffset=other.fRowOffset; return *this;
+       fClusterNo=other.fClusterNo; fData=other.fData; fCluster=other.fCluster; fRowOffset=other.fRowOffset; return *this;
       }
       ~iterator() {}
 
@@ -170,7 +153,6 @@ class AliHLTTPCClusterAccessHLTOUT : public TObject
       int fClusterNo; //! cluster no in the current block
       AliTPCclusterMIContainer* fData; //! pointer to actual data
       AliTPCclusterMI* fCluster; //! pointer to current cluster
-      AliHLTUInt32_t fClusterId; //! id of the cluster, from optional cluster id blocks
       int fRowOffset;  //! row offset for current partition
     };
 
@@ -179,13 +161,6 @@ class AliHLTTPCClusterAccessHLTOUT : public TObject
     /// iterator of track model clusters
     iterator& BeginTrackModelClusterBlock(int count);
 
-    /// add cluster mc data block
-    int AddClusterMCData(const AliHLTComponentBlockData* pDesc);
-    /// add cluster id block for remaining or track model clusters
-    int AddClusterIds(const AliHLTComponentBlockData* pDesc);
-    /// get the cluster id from the current cluster id block (optional)
-    AliHLTUInt32_t GetClusterId(int clusterNo) const;
-
     /// internal cleanup
     virtual void  Clear(Option_t * option="");
     /// get the cluster array for a sector
@@ -196,8 +171,6 @@ class AliHLTTPCClusterAccessHLTOUT : public TObject
   protected:
     /// load next cluster from array of the sepcific sector
     AliTPCclusterMI* NextCluster(int slice, int partition);
-    /// set MC data for the cluster
-    int SetMC(AliTPCclusterMI* cluster, AliHLTUInt32_t clusterId);
 
   private:
     AliTPCclusterMIContainer(const AliTPCclusterMIContainer&);