[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCRawSpacePointContainer.cxx

// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* Permission to use, copy, modify and distribute this software and its   *
//* documentation strictly for non-commercial purposes is hereby granted   *
//* without fee, provided that the above copyright notice appears in all   *
//* copies and that both the copyright notice and this permission notice   *
//* appear in the supporting documentation. The authors make no claims     *
//* about the suitability of this software for any purpose. It is          *
//* provided "as is" without express or implied warranty.                  *
//**************************************************************************

/// @file   AliHLTTPCRawSpacePointContainer.h
/// @author Matthias Richter
/// @date   2011-04-29
/// @brief  Helper class for handling of HLT TPC space point data blocks
///

#include "AliHLTTPCRawSpacePointContainer.h"
#include "AliHLTTPCRawCluster.h"
#include "AliHLTTPCDefinitions.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTComponent.h"
#include "AliHLTTemplates.h"
#include "AliHLTErrorGuard.h"
#include "TMath.h"
#include <memory>
#include <algorithm>

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCRawSpacePointContainer)

AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointContainer()
  : AliHLTSpacePointContainer()
  , fClusters()
  , fSelections()
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointContainer(const AliHLTTPCRawSpacePointContainer& c)
  : AliHLTSpacePointContainer(c)
  , fClusters(c.fClusters.begin(), c.fClusters.end())
  , fSelections()
{
  /// copy constructor
}

AliHLTTPCRawSpacePointContainer& AliHLTTPCRawSpacePointContainer::operator=(const AliHLTTPCRawSpacePointContainer& c)
{
  /// assignment operator
  if (&c==this) return *this;
  AliHLTSpacePointContainer::operator=(c);
  fClusters=c.fClusters;

  return *this;
}

AliHLTTPCRawSpacePointContainer::~AliHLTTPCRawSpacePointContainer()
{
  // destructor
  Clear();
}

int AliHLTTPCRawSpacePointContainer::AddInputBlock(const AliHLTComponentBlockData* pDesc)
{
  // add input block to the collection
  if (!pDesc) return -EINVAL;
  int count=0;
  if (pDesc->fDataType!=AliHLTTPCDefinitions::fgkRawClustersDataType) {
    HLTWarning("ignoring data block of type %s", AliHLTComponent::DataType2Text(pDesc->fDataType).c_str());
    return 0;
  }
  if (!pDesc->fPtr || pDesc->fSize<sizeof(AliHLTTPCRawClusterData)) return -ENODATA;

  // consistency check of the input block
  const AliHLTTPCRawClusterData* pClusterData=reinterpret_cast<AliHLTTPCRawClusterData*>(pDesc->fPtr);
  if (pClusterData->fCount*sizeof(AliHLTTPCRawCluster)+sizeof(AliHLTTPCRawClusterData)!=pDesc->fSize) {
    HLTError("data block of type %s corrupted: number of entries %d is not consistent with block size %d",
	     AliHLTComponent::DataType2Text(pDesc->fDataType).c_str(), pClusterData->fCount, pDesc->fSize);
    return -EBADMSG;
  }

  AliHLTUInt8_t minslice = AliHLTTPCDefinitions::GetMinSliceNr( pDesc->fSpecification );
  //AliHLTUInt8_t maxslice = AliHLTTPCDefinitions::GetMaxSliceNr( pDesc->fSpecification );
  AliHLTUInt8_t minpart  = AliHLTTPCDefinitions::GetMinPatchNr( pDesc->fSpecification );
  //AliHLTUInt8_t maxpart  = AliHLTTPCDefinitions::GetMaxPatchNr( pDesc->fSpecification );
  //bool bIsSinglePartition=(pDesc->fSpecification==kAliHLTVoidDataSpec?false:minslice==maxslice && minpart==maxpart);

  for (UInt_t i=0; i<pClusterData->fCount; i++) {
    AliHLTUInt32_t clusterID=~(AliHLTUInt32_t)0;
    // cluster ID from slice, partition and index
    clusterID=AliHLTTPCSpacePointData::GetID(minslice, minpart, i);

    if (fClusters.find(clusterID)==fClusters.end()) {
      // new cluster
      fClusters[clusterID]=AliHLTTPCRawSpacePointProperties(&pClusterData->fClusters[i]);
      count++;
    } else {
      HLTError("cluster with ID 0x%08x already existing, skipping cluster %d of data block 0x%08x",
	       clusterID, i, pDesc->fSpecification);
    }
  }

  return count;
}

int AliHLTTPCRawSpacePointContainer::GetClusterIDs(vector<AliHLTUInt32_t>& tgt) const
{
  // get array of cluster IDs
  tgt.clear();
  transform(fClusters.begin(), fClusters.end(), back_inserter(tgt), HLT::AliGetKey());
  return tgt.size();
}

bool AliHLTTPCRawSpacePointContainer::Check(AliHLTUInt32_t clusterID) const
{
  // check if the cluster is available
  return fClusters.find(clusterID)!=fClusters.end();
}

const vector<AliHLTUInt32_t>* AliHLTTPCRawSpacePointContainer::GetClusterIDs(AliHLTUInt32_t mask)
{
  // get array of cluster IDs filtered by mask
  if (fSelections.find(mask)!=fSelections.end()) {
    // return existing selection
    return fSelections.find(mask)->second;
  }
  // create new collection
  vector<AliHLTUInt32_t>* selected=new vector<AliHLTUInt32_t>;
  if (!selected) return NULL;
  UInt_t slice=AliHLTTPCSpacePointData::GetSlice(mask);
  UInt_t partition=AliHLTTPCSpacePointData::GetPatch(mask);
  //HLTInfo("creating collection 0x%08x", mask);

  // the first cluster with number 0 has equal ID to mask unless
  // the mask selects multiple partitions/slices
  std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(mask);
  bool bAll=false;
  if (slice>=(unsigned)AliHLTTPCTransform::GetNSlice() ||
      partition>=(unsigned)AliHLTTPCTransform::GetNumberOfPatches()) {
    cl=fClusters.begin();
    bAll=true;
  }
  for (; cl!=fClusters.end(); cl++) {
    UInt_t s=AliHLTTPCSpacePointData::GetSlice(cl->first);
    UInt_t p=AliHLTTPCSpacePointData::GetPatch(cl->first);
    if ((slice>=(unsigned)AliHLTTPCTransform::GetNSlice() || s==slice) && 
	(partition>=(unsigned)AliHLTTPCTransform::GetNumberOfPatches() || p==partition)) {
      selected->push_back(cl->first);
    } else if (!bAll) {
      // no need to continue, we are out of the range
      break;
    }
  }
  //HLTInfo("collection 0x%08x with %d spacepoints", mask, selected->size());
  fSelections[mask]=selected;
  return selected;
}

float AliHLTTPCRawSpacePointContainer::GetX(AliHLTUInt32_t clusterID) const
{
  // get X coordinate
  if (fClusters.find(clusterID)==fClusters.end() ||
      fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
  // FIXME: understand deviation from the nominal x value
  // there is a small deviation in the x coordinate - padrow number correlation
  // in principle, the clusterfinder only uses the mapping to set the x parameter.
  // now extracting the x value from the padrow no.
  //return fClusters.find(clusterID)->second.Data()->fX;
  return AliHLTTPCTransform::Row2X(fClusters.find(clusterID)->second.Data()->fPadRow);
}

float AliHLTTPCRawSpacePointContainer::GetXWidth(AliHLTUInt32_t clusterID) const
{
  // get error for X coordinate
  if (fClusters.find(clusterID)==fClusters.end() ||
      fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
  return 0.0; // fixed in padrow number
}

float AliHLTTPCRawSpacePointContainer::GetY(AliHLTUInt32_t clusterID) const
{
  // get Y coordinate
  if (fClusters.find(clusterID)==fClusters.end() ||
      fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
  return fClusters.find(clusterID)->second.Data()->GetPad();
}

float AliHLTTPCRawSpacePointContainer::GetYWidth(AliHLTUInt32_t clusterID) const
{
  // get error for Y coordinate
  if (fClusters.find(clusterID)==fClusters.end() ||
      fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
  return fClusters.find(clusterID)->second.Data()->GetSigmaY2();
}

float AliHLTTPCRawSpacePointContainer::GetZ(AliHLTUInt32_t clusterID) const
{
  // get Z coordinate
  if (fClusters.find(clusterID)==fClusters.end() ||
      fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
  return fClusters.find(clusterID)->second.Data()->GetTime();
}

float AliHLTTPCRawSpacePointContainer::GetZWidth(AliHLTUInt32_t clusterID) const
{
  // get error for Z coordinate
  if (fClusters.find(clusterID)==fClusters.end() ||
      fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
  return fClusters.find(clusterID)->second.Data()->GetSigmaZ2();
}

float AliHLTTPCRawSpacePointContainer::GetCharge(AliHLTUInt32_t clusterID) const
{
  // get charge
  if (fClusters.find(clusterID)==fClusters.end() ||
      fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
  return fClusters.find(clusterID)->second.Data()->GetCharge();
}

float AliHLTTPCRawSpacePointContainer::GetMaxSignal(AliHLTUInt32_t clusterID) const
{
  // get charge
  if (fClusters.find(clusterID)==fClusters.end() ||
      fClusters.find(clusterID)->second.Data()==NULL) return 0.0;
  return fClusters.find(clusterID)->second.Data()->GetQMax();
}

float AliHLTTPCRawSpacePointContainer::GetPhi(AliHLTUInt32_t clusterID) const
{
  // get charge

  // phi can be derived directly from the id, no need to search
  // for existing cluster
  int slice=AliHLTTPCSpacePointData::GetSlice(clusterID);
  return ( slice + 0.5 ) * TMath::Pi() / 9.0;
}

void AliHLTTPCRawSpacePointContainer::Clear(Option_t * option)
{
  // clear the object and reset pointer references
  fClusters.clear();

  for (std::map<AliHLTUInt32_t, vector<AliHLTUInt32_t>*>::iterator selection=fSelections.begin();
       selection!=fSelections.end(); selection++) {
    if (selection->second) delete selection->second;
  }
  fSelections.clear();

  AliHLTSpacePointContainer::Clear(option);
}

void AliHLTTPCRawSpacePointContainer::Print(ostream& out, Option_t */*option*/) const
{
  // print to stream
  out << "AliHLTTPCRawSpacePointContainer::Print" << endl;
  out << "n clusters: " << fClusters.size() << endl;
  for (std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.begin();
       cl!=fClusters.end(); cl++) {
    out << " " << cl->first << cl->second << endl;
  }
}

AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::SelectByMask(AliHLTUInt32_t mask, bool /*bAlloc*/) const
{
  /// create a collection of clusters for a space point mask
  std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
  if (!c.get()) return NULL;

  UInt_t slice=AliHLTTPCSpacePointData::GetSlice(mask);
  UInt_t partition=AliHLTTPCSpacePointData::GetPatch(mask);
  for (std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.begin();
       cl!=fClusters.end(); cl++) {
    UInt_t s=AliHLTTPCSpacePointData::GetSlice(cl->first);
    UInt_t p=AliHLTTPCSpacePointData::GetPatch(cl->first);
    if ((slice>=(unsigned)AliHLTTPCTransform::GetNSlice() || s==slice) && 
	(partition>=(unsigned)AliHLTTPCTransform::GetNumberOfPatches() || p==partition)) {
      c->fClusters[cl->first]=cl->second;
    }
  }
  return c.release();
}

AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::SelectByTrack(int trackId, bool /*bAlloc*/) const
{
  /// create a collection of clusters for a specific track
  std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
  if (!c.get()) return NULL;

  HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties, int>(&AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::GetTrackId,trackId));
  return c.release();
}

AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::SelectByMC(int mcId, bool /*bAlloc*/) const
{
  /// create a collection of clusters for a specific MC track
  std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
  if (!c.get()) return NULL;

  HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties, int>(&AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::GetMCId,mcId));
  return c.release();
}

AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::UsedClusters(bool /*bAlloc*/) const
{
  /// create a collection of all used clusters
  std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
  if (!c.get()) return NULL;

  HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties, bool>(&AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::IsUsed,true));
  return c.release();
}

AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::UnusedClusters(bool /*bAlloc*/) const
{
  /// create a collection of all unused clusters
  std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
  if (!c.get()) return NULL;

  HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties, bool>(&AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::IsUsed,false));
  return c.release();
}

int AliHLTTPCRawSpacePointContainer::MarkUsed(const AliHLTUInt32_t* clusterIDs, int arraySize)
{
  /// mark the clusters with specified IDs as used
  if (!clusterIDs) return -EINVAL;
  int iCount=0;
  for (int i=0; i<arraySize; i++) {
    if (fClusters.find(clusterIDs[i])==fClusters.end()) continue;
    fClusters[clusterIDs[i]].MarkUsed();
    iCount++;
  }
  return iCount;
}

int AliHLTTPCRawSpacePointContainer::SetTrackID(int trackID, const AliHLTUInt32_t* clusterIDs, int arraySize)
{
  /// set track id for specified clusters
  if (!clusterIDs) return -EINVAL;
  int iCount=0;
  for (int i=0; i<arraySize; i++) {
    if (fClusters.find(clusterIDs[i])==fClusters.end()) continue;
    fClusters[clusterIDs[i]].SetTrackId(trackID);
    iCount++;
  }
  return iCount;
}

int AliHLTTPCRawSpacePointContainer::GetTrackID(AliHLTUInt32_t clusterID) const
{
  /// get track id for specified cluster
  map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator element=fClusters.find(clusterID);
  if (element==fClusters.end()) return -1;
  return element->second.GetTrackId();
}

int AliHLTTPCRawSpacePointContainer::SetMCID(int mcID, const AliHLTUInt32_t* clusterIDs, int arraySize)
{
  /// set mc id for specified clusters
  if (!clusterIDs) return -EINVAL;
  int iCount=0;
  for (int i=0; i<arraySize; i++) {
    if (fClusters.find(clusterIDs[i])==fClusters.end()) continue;
    fClusters[clusterIDs[i]].SetMCId(mcID);
    iCount++;
  }
  return iCount;
}

int AliHLTTPCRawSpacePointContainer::Write(AliHLTUInt8_t* outputPtr, AliHLTUInt32_t size, AliHLTComponentBlockDataList& outputBlocks, const char* /*option*/) const
{
  /// write blocks to HLT component output
  if (!outputPtr) return -EINVAL;
  int iResult=0;
  AliHLTUInt32_t capacity=size;
  size=0;

  for (int slice=0; slice<AliHLTTPCTransform::GetNSlice() && iResult>=0; slice++) {
    for (int part=0; part<AliHLTTPCTransform::GetNPatches() && iResult>=0; part++) {
      AliHLTUInt32_t mask=AliHLTTPCSpacePointData::GetID(slice,part,0);
      // FIXME: make GetClusterIDs a const function and handle the cast there
      const vector<AliHLTUInt32_t>* collection=const_cast<AliHLTTPCRawSpacePointContainer*>(this)->GetClusterIDs(mask);
      if (!collection) continue;
      if (size+sizeof(AliHLTTPCRawClusterData)+collection->size()*sizeof(AliHLTTPCRawCluster)>capacity) {
	ALIHLTERRORGUARD(1,"too little space to write cluster output block");
	iResult=-ENOSPC;
	break;
      }
      AliHLTTPCRawClusterData* blockout=reinterpret_cast<AliHLTTPCRawClusterData*>(outputPtr+size);
      blockout->fVersion=0;
      blockout->fCount=0;
      vector<AliHLTUInt32_t>::const_iterator clusterID=collection->begin();
      if (clusterID!=collection->end()) {
	std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(*clusterID);
	for (; clusterID!=collection->end(); clusterID++, (cl!=fClusters.end())?cl++:cl) {
	  if (cl!=fClusters.end() && cl->first!=*clusterID) cl=fClusters.find(*clusterID);
	  if (cl==fClusters.end() || cl->second.Data()==NULL) continue;
	  AliHLTTPCRawCluster& c=blockout->fClusters[blockout->fCount];
	  int padrow=cl->second.Data()->GetPadRow();
	  padrow+=AliHLTTPCTransform::GetFirstRow(part);
	  c.SetPadRow(padrow);
	  c.SetCharge(cl->second.Data()->GetCharge());
	  float pad =cl->second.Data()->GetPad();
	  float time =cl->second.Data()->GetTime();
	  float sigmaY2=cl->second.Data()->GetSigmaY2();
	  float sigmaZ2=cl->second.Data()->GetSigmaZ2();
	  sigmaY2-=pad*pad;
	  sigmaZ2-=time*time;
	  c.SetPad(pad);  
	  c.SetTime(time);
	  c.SetSigmaY2(sigmaY2);
	  c.SetSigmaZ2(sigmaZ2);
	  c.SetQMax(cl->second.Data()->GetQMax());
	  blockout->fCount++;
	}
      }
      AliHLTComponent_BlockData bd;
      AliHLTComponent::FillBlockData(bd);
      bd.fOffset        = size;
      bd.fSize          = sizeof(AliHLTTPCRawClusterData)+blockout->fCount*sizeof(AliHLTTPCRawCluster);
      bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(slice, slice, part, part);
      bd.fDataType      = AliHLTTPCDefinitions::fgkRawClustersDataType;
      outputBlocks.push_back(bd);
      
      size += bd.fSize;
    }
  }

  if (iResult<0) return iResult;
  return size;
}

AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::AliHLTTPCRawSpacePointProperties()
  : fCluster(NULL)
  , fUsed(false)
  , fTrackId(-1)
  , fMCId(-1)
{
  // constructor
}

AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::AliHLTTPCRawSpacePointProperties(const AliHLTTPCRawCluster* pCluster)
  : fCluster(pCluster)
  , fUsed(false)
  , fTrackId(-1)
  , fMCId(-1)
{
  // constructor
}

AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::AliHLTTPCRawSpacePointProperties(const AliHLTTPCRawSpacePointProperties& src)
  : fCluster(src.fCluster)
  , fUsed(src.fUsed)
  , fTrackId(src.fTrackId)
  , fMCId(src.fMCId)
{
  // copy constructor
}

AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties& AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::operator=(const AliHLTTPCRawSpacePointProperties& src)
{
  // assignment operator
  if (&src==this) return *this;
  fCluster=src.fCluster;
  fUsed=src.fUsed;
  fTrackId=src.fTrackId;
  fMCId=src.fMCId;

  return *this;
}

void AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::Print(ostream& out, Option_t */*option*/) const
{
  // print info
  if (!Data()) {
    out << "no data";
    return;
  }
  const AliHLTTPCRawCluster* data=Data();
  out << " " << data->GetPadRow() << " " << data->GetPad() << " " << data->GetTime()
      << " " << data->GetSigmaY2() << " "  << data->GetSigmaZ2()
      << " " << data->GetCharge() << " "  << data->GetQMax()
      << " " << fTrackId << " " << fMCId << " " << fUsed;
}

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