#include "AliHLTComponent.h"
#include "AliHLTGlobalBarrelTrack.h"
#include "AliHLTDataDeflater.h"
+#include "AliHLTErrorGuard.h"
#include "TMath.h"
#include "TH2F.h"
#include <memory>
AliHLTTPCTrackGeometry::AliHLTTPCTrackGeometry()
: AliHLTTrackGeometry()
, fRawTrackPoints()
+ , fDriftTimeFactorA(0.)
+ , fDriftTimeOffsetA(0.)
+ , fDriftTimeFactorC(0.)
+ , fDriftTimeOffsetC(0.)
{
/// standard constructor
}
AliHLTTPCTrackGeometry::AliHLTTPCTrackGeometry(const AliHLTTPCTrackGeometry& src)
: AliHLTTrackGeometry(src)
, fRawTrackPoints(src.fRawTrackPoints)
+ , fDriftTimeFactorA(0.)
+ , fDriftTimeOffsetA(0.)
+ , fDriftTimeFactorC(0.)
+ , fDriftTimeOffsetC(0.)
{
/// copy constructor
}
if (AddTrackPoint(AliHLTTrackPoint(id, y, z), AliHLTTPCSpacePointData::GetID(slice, partition, 0))>=0) {
Float_t rpt[3]={0.,y,z}; // row pad time
AliHLTTPCTransform::LocHLT2Raw(rpt, slice, padrow);
- fRawTrackPoints.push_back(AliHLTTrackPoint(id, rpt[1], rpt[2]));
+ float m=fDriftTimeFactorA;
+ float n=fDriftTimeOffsetA;
+ if (slice>=18) {
+ m=fDriftTimeFactorC;
+ n=fDriftTimeOffsetC;
+ }
+ if (TMath::Abs(m)>0.) {
+ rpt[2]=(z-n)/m;
+ fRawTrackPoints.push_back(AliHLTTrackPoint(id, rpt[1], rpt[2]));
+ } else {
+ ALIHLTERRORGUARD(1, "drift time correction not initialized, can not add track points in raw coordinates");
+ }
}
}
return 0;
AliHLTDataDeflater* pDeflater,
AliHLTUInt8_t* outputPtr,
AliHLTUInt32_t size,
+ vector<AliHLTUInt32_t>* writtenClusterIds,
const char* option) const
{
// write track block to buffer
pDeflater->Clear();
pDeflater->InitBitDataOutput(reinterpret_cast<AliHLTUInt8_t*>(outputPtr+sizeof(AliHLTTPCTrackBlock)), size-sizeof(AliHLTTPCTrackBlock));
- int result=WriteAssociatedClusters(pSpacePoints, pDeflater, option);
+ int result=WriteAssociatedClusters(pSpacePoints, pDeflater, writtenClusterIds, option);
if (result<0) return result;
pTrackBlock->fSize+=result;
return pTrackBlock->fSize;
int AliHLTTPCTrackGeometry::WriteAssociatedClusters(AliHLTSpacePointContainer* pSpacePoints,
AliHLTDataDeflater* pDeflater,
+ vector<AliHLTUInt32_t>* writtenClusterIds,
const char* /*option*/) const
{
// write associated clusters to buffer via deflater
HLTError("can not find spacepoint 0x%08x", clid->fId);
continue;
}
+ if (writtenClusterIds) {
+ writtenClusterIds->push_back(clid->fId);
+ }
float deltapad =clid->fdU;
float deltatime =clid->fdV;
///
#include "AliHLTTrackGeometry.h"
+#include <vector>
class AliHLTGlobalBarrelTrack;
class AliHLTDataDeflater;
AliHLTDataDeflater* pDeflater,
AliHLTUInt8_t* outputPtr,
AliHLTUInt32_t size,
+ vector<AliHLTUInt32_t>* writtenClusterIds=NULL,
const char* option="") const;
virtual int WriteAssociatedClusters(AliHLTSpacePointContainer* pSpacePoints,
AliHLTDataDeflater* pDeflater,
+ vector<AliHLTUInt32_t>* writtenClusterIds=NULL,
const char* option="") const;
+ int InitDriftTimeTransformation(float mA, float nA, float mC, float nC) {
+ fDriftTimeFactorA=mA; fDriftTimeOffsetA=nA; fDriftTimeFactorC=mC; fDriftTimeOffsetC=nC; return 0;
+ }
+
struct AliHLTTPCTrackBlock {
AliHLTUInt16_t fSize; //! size in byte of the complete track block
AliHLTUInt8_t fSlice; //! slice number -> rotation angle of local coordinates
vector<AliHLTTrackPoint> fRawTrackPoints; // list of points in raw coordinates
+ float fDriftTimeFactorA; //! drift time A side
+ float fDriftTimeOffsetA; //! drift time A side
+ float fDriftTimeFactorC; //! drift time C side
+ float fDriftTimeOffsetC; //! drift time C side
+
ClassDef(AliHLTTPCTrackGeometry, 0)
};
#endif
#include "AliHLTDataDeflaterHuffman.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCClusterMCData.h"
+#include "AliHLTTPCClusterTransformation.h"
#include "AliRawDataHeader.h"
#include "AliCDBManager.h"
#include "AliCDBPath.h"
: AliHLTProcessor()
, fMode(0)
, fDeflaterMode(0)
+ , fVerificationMode(0)
, fMaxDeltaPad(AliHLTTPCDefinitions::GetMaxClusterDeltaPad())
, fMaxDeltaTime(AliHLTTPCDefinitions::GetMaxClusterDeltaTime())
, fRawInputClusters(NULL)
, fHistogramFile()
, fTrainingTableOutput()
, fpBenchmark(NULL)
+ , fpWrittenAssociatedClusterIds(NULL)
+ , fDriftTimeFactorA(1.)
+ , fDriftTimeOffsetA(0.)
+ , fDriftTimeFactorC(1.)
+ , fDriftTimeOffsetC(0.)
, fVerbosity(0)
{
}
AliHLTTPCDataCompressionComponent::~AliHLTTPCDataCompressionComponent()
{
/// destructor
+ if (fpWrittenAssociatedClusterIds) delete fpWrittenAssociatedClusterIds;
}
{
/// inherited from AliHLTComponent: multiple output data types of the component.
tgtList.clear();
- tgtList.push_back(AliHLTTPCDefinitions::fgkRawClustersDataType);
+ tgtList.push_back(AliHLTTPCDefinitions::RawClustersDataType());
+ tgtList.push_back(AliHLTTPCDefinitions::RemainingClustersCompressedDataType());
+ tgtList.push_back(AliHLTTPCDefinitions::RemainingClusterIdsDataType());
+ tgtList.push_back(AliHLTTPCDefinitions::ClusterTracksCompressedDataType());
+ tgtList.push_back(AliHLTTPCDefinitions::ClusterIdTracksDataType());
return tgtList.size();
}
{
/// inherited from AliHLTComponent: output data size estimator
constBase=0;
- inputMultiplier=1.3;
+ inputMultiplier=1.; // there should not be more data than input
+ inputMultiplier+=.3; // slightly more data when using the old HWCF data with 20 Byte and raw clusters 22 Byte
+ if (fpWrittenAssociatedClusterIds) inputMultiplier+=.3; // space for optional cluster id array
}
AliHLTComponent* AliHLTTPCDataCompressionComponent::Spawn()
// Process an event
// Loop over all input blocks in the event
bool bHaveMC=(GetFirstInputBlock(AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo | kAliHLTDataOriginTPC))!=NULL;
+ if ((bHaveMC || fVerificationMode>0) && fpWrittenAssociatedClusterIds==NULL) {
+ fpWrittenAssociatedClusterIds=new vector<AliHLTUInt32_t>;
+ }
const AliHLTComponentBlockData* pDesc=NULL;
}
}
- AliHLTTrackGeometry* trackpoints=new AliHLTTPCTrackGeometry;
+ AliHLTTPCTrackGeometry* trackpoints=new AliHLTTPCTrackGeometry;
if (!trackpoints) continue;
+ trackpoints->InitDriftTimeTransformation(fDriftTimeFactorA, fDriftTimeOffsetA, fDriftTimeFactorC, fDriftTimeOffsetC);
trackpoints->SetTrackId(trackID);
trackpoints->CalculateTrackPoints(*track);
trackpoints->RegisterTrackPoints(fTrackGrid);
// FIXME: decoder index instead of data specification to be used
// use an external access grid to reduce allocated memory
// set to NULL after writing the clusters
+ const char* writeoptions="";
+ if (fpWrittenAssociatedClusterIds) {
+ writeoptions="write-cluster-ids";
+ }
fRawInputClusters->SetSpacePointPropertyGrid(pDesc->fSpecification, fSpacePointGrid);
- iResult=fRawInputClusters->Write(outputPtr+size, capacity-size, outputBlocks, fpDataDeflater);
+ iResult=fRawInputClusters->Write(outputPtr+size, capacity-size, outputBlocks, fpDataDeflater, writeoptions);
fRawInputClusters->SetSpacePointPropertyGrid(pDesc->fSpecification, NULL);
if (iResult>=0) {
size+=iResult;
// output of track model clusters
if (iResult>=0) {
+ if (fpWrittenAssociatedClusterIds) fpWrittenAssociatedClusterIds->clear();
iResult=WriteTrackClusters(inputTrackArray, fRawInputClusters, fpDataDeflater, outputPtr+size, capacity-size);
if (iResult>=0) {
AliHLTComponent_BlockData bd;
size += bd.fSize;
outputDataSize+=bd.fSize;
HLTBenchmark("track data block of %d tracks: size %d", inputTrackArray.size(), bd.fSize);
+
+ if (fpWrittenAssociatedClusterIds && fpWrittenAssociatedClusterIds->size()>0) {
+ AliHLTComponent::FillBlockData(bd);
+ bd.fOffset = size;
+ bd.fSize = fpWrittenAssociatedClusterIds->size()*sizeof(vector<AliHLTUInt32_t>::value_type);
+ memcpy(outputPtr+bd.fOffset, &(*fpWrittenAssociatedClusterIds)[0], bd.fSize);
+ bd.fDataType = AliHLTTPCDefinitions::ClusterIdTracksDataType();
+ bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(minSlice, maxSlice, minPatch, maxPatch);
+ outputBlocks.push_back(bd);
+ size += bd.fSize;
+
+ fpWrittenAssociatedClusterIds->clear();
+ }
}
}
return -EBADF;
}
- int result=pTrackPoints->Write(*track, pSpacePoints, pDeflater, outputPtr+size, capacity-size);
+ int result=pTrackPoints->Write(*track, pSpacePoints, pDeflater, outputPtr+size, capacity-size, fpWrittenAssociatedClusterIds);
if (result<0) return result;
size+=result;
fHistoTrackClusterRatio=histoTrackClusterRatio.release();
}
+ if (iResult>=0 && (iResult=InitDriftTimeTransformation())<0) return iResult;
+
return iResult;
}
fHistoTrackClusterRatio=NULL;
if (fpDataDeflater) {
+ if (!fHistogramFile.IsNull()) {
+ TString filename=fHistogramFile;
+ filename.ReplaceAll(".root", "-deflater.root");
+ fpDataDeflater->SaveAs(filename);
+ }
if (fDeflaterMode==3) {
if (fTrainingTableOutput.IsNull()) {
fTrainingTableOutput=GetComponentID();
return bd.fSize;
}
+
+int AliHLTTPCDataCompressionComponent::InitDriftTimeTransformation()
+{
+ /// calculate correction factor and offset for a linear approximation of the
+ /// drift time transformation, separately for A and C side
+ int iResult=0;
+ AliHLTTPCClusterTransformation transform;
+ if ((iResult=transform.Init( GetBz(), GetTimeStamp()))<0) {
+ HLTError("failed to init AliHLTTPCClusterTransformation: %d", iResult);
+ return iResult;
+ }
+
+ if ((iResult=CalculateDriftTimeTransformation(transform, 0, 0, fDriftTimeFactorA, fDriftTimeOffsetA))<0) return iResult;
+ if (fVerbosity>0) HLTInfo("drift time transformation A side: m=%f n=%f", fDriftTimeFactorA, fDriftTimeOffsetA);
+ if ((iResult=CalculateDriftTimeTransformation(transform, 18, 0, fDriftTimeFactorC, fDriftTimeOffsetC))<0) return iResult;
+ if (fVerbosity>0) HLTInfo("drift time transformation C side: m=%f n=%f", fDriftTimeFactorC, fDriftTimeOffsetC);
+
+ return 0;
+}
+
+int AliHLTTPCDataCompressionComponent::CalculateDriftTimeTransformation(AliHLTTPCClusterTransformation& transform,
+ int slice, int padrow,
+ float& m, float& n) const
+{
+ /// calculate correction factor and offset for a linear approximation of the
+ /// drift time transformation by just probing the range of timebins with
+ /// AliHLTTPCClusterTransformation
+ const int nofSteps=100;
+ vector<float> zvalues;
+
+ int nofTimebins=AliHLTTPCTransform::GetNTimeBins();
+ int stepWidth=nofTimebins/nofSteps;
+ int time=0;
+ int count=0;
+ float meanT=0.;
+ float meanZ=0.;
+ for (time=0; time<nofTimebins; time+=stepWidth, count++) {
+ Float_t xyz[3];
+ transform.Transform(slice, padrow, 0, time, xyz);
+ zvalues.push_back(xyz[2]);
+ meanT+=time;
+ meanZ+=xyz[2];
+ }
+ meanT/=count;
+ meanZ/=count;
+ float sumTZ=.0;
+ float sumT2=.0;
+ time=0;
+ for (vector<float>::const_iterator z=zvalues.begin();
+ z!=zvalues.end(); z++, time+=stepWidth) {
+ sumTZ+=(time-meanT)*((*z)-meanZ);
+ sumT2+=(time-meanT)*(time-meanT);
+ }
+ m=sumTZ/sumT2;
+ n=meanZ-m*meanT;
+
+ return 0;
+}
#include "TString.h"
#include "AliHLTTrackGeometry.h"
#include "AliHLTSpacePointContainer.h"
+#include <vector>
class AliHLTGlobalBarrelTrack;
class AliHLTComponentBenchmark;
class AliHLTSpacePointContainer;
class AliHLTDataDeflater;
+class AliHLTTPCClusterTransformation;
class TH1F;
/**
int InitDeflater(int mode);
+ /// calculate correction factor and offset for a linear approximation of the
+ /// drift time transformation, separately for A and C side
+ int InitDriftTimeTransformation();
+ /// calculate correction factor and offset for a linear approximation of the
+ /// drift time transformation by just probing the range of timebins
+ int CalculateDriftTimeTransformation(AliHLTTPCClusterTransformation& transform, int slice, int padrow,
+ float& m, float& n) const;
+
AliHLTComponentBenchmark* GetBenchmarkInstance() const {return fpBenchmark;}
int fMode; //! mode
int fDeflaterMode; //! deflater mode
+ int fVerificationMode; //! mode for verification and unit tests
float fMaxDeltaPad; //! maximum deviation in pad
float fMaxDeltaTime; //! maximum deviation in time
/// benchmark
AliHLTComponentBenchmark* fpBenchmark; //! benchmark instance
+ /// temporary array of ids of associated cluster ids
+ vector<AliHLTUInt32_t>* fpWrittenAssociatedClusterIds; //!
+
+ float fDriftTimeFactorA; //! drift time A side
+ float fDriftTimeOffsetA; //! drift time A side
+ float fDriftTimeFactorC; //! drift time C side
+ float fDriftTimeOffsetC; //! drift time C side
+
/// verbosity
int fVerbosity; // verbosity for debug printout