configuration 'TPC-compression-emulation' added, to be activated in separate commit

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

diff --git a/HLT/TPCLib/AliHLTTPCTrackGeometry.cxx b/HLT/TPCLib/AliHLTTPCTrackGeometry.cxx
index 876b85d055d55a25bbe6c5cb17aec330ec0a4689..ec5b11d67f3c2c267735a121b404fd1a96b02a4e 100644 (file)
--- a/HLT/TPCLib/AliHLTTPCTrackGeometry.cxx
+++ b/HLT/TPCLib/AliHLTTPCTrackGeometry.cxx
@@ -36,6 +36,8 @@
 #include "TMath.h"
 #include "TH2F.h"
 #include <memory>
+#include <sstream>
+using namespace std;
 
 /** ROOT macro for the implementation of ROOT specific class methods */
 ClassImp(AliHLTTPCTrackGeometry)
@@ -181,13 +183,24 @@ int AliHLTTPCTrackGeometry::CalculateTrackPoints(AliHLTGlobalBarrelTrack& track,
       }
       if (TMath::Abs(m)>0.) {
        rpt[2]=(z-n)/m;
-       fRawTrackPoints.push_back(AliHLTTrackPoint(id, rpt[1], rpt[2]));
-       // cout << "  row "    << setfill(' ') << setw(3) << fixed << right << padrow
+       if (step>0) {
+         // ascending padrows added at end
+         fRawTrackPoints.push_back(AliHLTTrackPoint(id, rpt[1], rpt[2]));
+       } else {
+         // descending padrows added at begin
+         fRawTrackPoints.insert(fRawTrackPoints.begin(), AliHLTTrackPoint(id, rpt[1], rpt[2]));
+       }
+       // FIXME: implement a Print function for the raw track points
+       // stringstream sout;
+       // sout << "  slice "  << setfill(' ') << setw(3) << fixed << right << slice
+       //      << "  row "    << setfill(' ') << setw(3) << fixed << right << padrow
+       //      << "  id 0x"     << hex << setw(8) << id << dec
        //      << "  y "      << setfill(' ') << setw(5) << fixed << right << setprecision (2) << y
        //      << "  z "      << setfill(' ') << setw(5) << fixed << right << setprecision (2) << z
        //      << "  pad "    << setfill(' ') << setw(5) << fixed << right << setprecision (2) << rpt[1]
        //      << "  time "   << setfill(' ') << setw(5) << fixed << right << setprecision (2) << rpt[2]
        //      << endl;
+       // cout << sout.str();
       } else {
        ALIHLTERRORGUARD(1, "drift time correction not initialized, can not add track points in raw coordinates");
       }
@@ -504,6 +517,12 @@ int AliHLTTPCTrackGeometry::WriteAssociatedClusters(AliHLTSpacePointContainer* p
            // assiciated space point, calculate again, but needs to be fixed
            float deltapad =pSpacePoints->GetY(clid->fId)-clrow->GetU();//clid->fdU;
            float deltatime =pSpacePoints->GetZ(clid->fId)-clrow->GetV();//clid->fdV;
+           if (TMath::Abs(deltapad)>=AliHLTTPCDefinitions::fgkMaxClusterDeltaPad ||
+               TMath::Abs(deltatime)>=AliHLTTPCDefinitions::fgkMaxClusterDeltaTime) {
+             AliHLTUInt8_t slice = AliHLTTPCSpacePointData::GetSlice(clid->fId);
+             AliHLTUInt8_t partition = AliHLTTPCSpacePointData::GetPatch(clid->fId);
+             HLTFatal("cluster 0x%08x slice %d partition %d: residual out of range - pad %f (max %d), time %f (max %d)", clid->fId, slice, partition, deltapad, AliHLTTPCDefinitions::fgkMaxClusterDeltaPad, deltatime, AliHLTTPCDefinitions::fgkMaxClusterDeltaTime);
+           }
            float sigmaY2=pSpacePoints->GetYWidth(clid->fId);
            float sigmaZ2=pSpacePoints->GetZWidth(clid->fId);
            AliHLTUInt64_t charge=(AliHLTUInt64_t)pSpacePoints->GetCharge(clid->fId);
@@ -517,19 +536,51 @@ int AliHLTTPCTrackGeometry::WriteAssociatedClusters(AliHLTSpacePointContainer* p
            //   << "  qmax "   << setfill(' ') << setw(4) << fixed << right << qmax
            //   << endl;
 
+           // time and pad coordinates are scaled and transformed to integer values for
+           // both cluster and track point before calculating the residual. this makes
+           // the compression lossless with respect to the format without track model
+           // compression
            AliHLTUInt64_t deltapad64=0;
            AliHLTUInt32_t signDeltaPad=0;
            if (!isnan(deltapad)) {
-             if (deltapad<0.) {deltapad*=-1; signDeltaPad=1;}
-             deltapad*=AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kResidualPad].fScale;
-             deltapad64=(AliHLTUInt64_t)round(deltapad);
+             double clusterpad=pSpacePoints->GetY(clid->fId);
+             double trackpad=clrow->GetU();
+             if (clusterpad<0.) {
+               HLTError("cluster 0x%08x has negative pad position", clid->fId, clusterpad);
+             }
+             clusterpad*=AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kResidualPad].fScale;
+             trackpad*=AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kResidualPad].fScale;
+             AliHLTUInt64_t clusterpad64=(AliHLTUInt64_t)round(clusterpad);
+             AliHLTUInt64_t trackpad64=0;
+             if (trackpad>0.) trackpad64=(AliHLTUInt64_t)round(trackpad);
+             if (clusterpad64<trackpad64) {
+               deltapad64=trackpad64-clusterpad64;
+               signDeltaPad=1;
+             } else {
+               deltapad64=clusterpad64-trackpad64;
+               signDeltaPad=0;
+             }
            }
            AliHLTUInt64_t deltatime64=0;
            AliHLTUInt32_t signDeltaTime=0;
            if (!isnan(deltatime)) {
-             if (deltatime<0.) {deltatime*=-1; signDeltaTime=1;}
-             deltatime*=AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kResidualTime].fScale;
-             deltatime64=(AliHLTUInt64_t)round(deltatime);
+             double clustertime=pSpacePoints->GetZ(clid->fId);
+             double tracktime=clrow->GetV();
+             if (clustertime<0.) {
+               HLTError("cluster 0x%08x has negative time position", clid->fId, clustertime);
+             }
+             clustertime*=AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kResidualTime].fScale;
+             tracktime*=AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kResidualTime].fScale;
+             AliHLTUInt64_t clustertime64=(AliHLTUInt64_t)round(clustertime);
+             AliHLTUInt64_t tracktime64=0;
+             if (tracktime>0.) tracktime64=(AliHLTUInt64_t)round(tracktime);
+             if (clustertime64<tracktime64) {
+               deltatime64=tracktime64-clustertime64;
+               signDeltaTime=1;
+             } else {
+               deltatime64=clustertime64-tracktime64;
+               signDeltaTime=0;
+             }
            }
            AliHLTUInt64_t sigmaY264=0;
            if (!isnan(sigmaY2)) sigmaY264=(AliHLTUInt64_t)round(sigmaY2*AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kSigmaY2].fScale);