HLT/TPCLib/AliHLTTPCDataCompressorHelper.cxx

   1 // @(#) $Id$
   2 // Original: AliHLTDataCompressorHelper.cxx,v 1.5 2004/06/15 10:26:57 hristov Exp $
   3
   4 //**************************************************************************
   5 //* This file is property of and copyright by the ALICE HLT Project        *
   6 //* ALICE Experiment at CERN, All rights reserved.                         *
   7 //*                                                                        *
   8 //* Primary Authors: Anders Vestbo                                         *
   9 //*                  for The ALICE HLT Project.                            *
  10 //*                                                                        *
  11 //* Permission to use, copy, modify and distribute this software and its   *
  12 //* documentation strictly for non-commercial purposes is hereby granted   *
  13 //* without fee, provided that the above copyright notice appears in all   *
  14 //* copies and that both the copyright notice and this permission notice   *
  15 //* appear in the supporting documentation. The authors make no claims     *
  16 //* about the suitability of this software for any purpose. It is          *
  17 //* provided "as is" without express or implied warranty.                  *
  18 //**************************************************************************
  19
  20 #include "AliHLTStdIncludes.h"
  21 #include "AliHLTTPCRootTypes.h"
  22 #include "AliHLTTPCTransform.h"
  23
  24 #include "AliHLTTPCDataCompressorHelper.h"
  25
  26 #if __GNUC__ >= 3
  27 using namespace std;
  28 #endif
  29
  30 //_____________________________________________________________
  31 //
  32 //  AliHLTTPCDataCompression
  33 //
  34 // Interface class; binary <-> AliROOT handling of TPC data compression classes.
  35 //
  36
  37
  38 ClassImp(AliHLTTPCDataCompressorHelper)
  39
  40 AliHLTTPCDataCompressorHelper::AliHLTTPCDataCompressorHelper()
  41 {
  42 }
  43
  44 AliHLTTPCDataCompressorHelper::~AliHLTTPCDataCompressorHelper()
  45 {
  46 }
  47
  48 Int_t AliHLTTPCDataCompressorHelper::fgNumTimeBits = 12;
  49 Int_t AliHLTTPCDataCompressorHelper::fgNumPadBits = 12;
  50 Int_t AliHLTTPCDataCompressorHelper::fgNumChargeBits = 14;
  51 Int_t AliHLTTPCDataCompressorHelper::fgNumShapeBits = 14;
  52 Float_t AliHLTTPCDataCompressorHelper::fgXYResidualStep1 = 0.03;
  53 Float_t AliHLTTPCDataCompressorHelper::fgXYResidualStep2 = 0.03;
  54 Float_t AliHLTTPCDataCompressorHelper::fgXYResidualStep3 = 0.03;
  55 Float_t AliHLTTPCDataCompressorHelper::fgZResidualStep1 = 0.05;
  56 Float_t AliHLTTPCDataCompressorHelper::fgZResidualStep2 = 0.05;
  57 Float_t AliHLTTPCDataCompressorHelper::fgZResidualStep3 = 0.05;
  58 Float_t AliHLTTPCDataCompressorHelper::fgXYWidthStep = 0.005;
  59 Float_t AliHLTTPCDataCompressorHelper::fgZWidthStep = 0.005;
  60 Int_t AliHLTTPCDataCompressorHelper::fgClusterCharge = 100;
  61 Int_t AliHLTTPCDataCompressorHelper::fgNumPadBitsRemaining = 18;
  62 Int_t AliHLTTPCDataCompressorHelper::fgNumTimeBitsRemaining = 19;
  63 Int_t AliHLTTPCDataCompressorHelper::fgNumShapeBitsRemaining = 11;
  64
  65 void AliHLTTPCDataCompressorHelper::SetBitNumbers(Int_t pad,Int_t time,Int_t charge,Int_t shape)
  66 {
  67   // sets the numbers of bits
  68   fgNumPadBits = pad;
  69   fgNumTimeBits = time;
  70   fgNumChargeBits = charge;
  71   fgNumShapeBits = shape;
  72 }
  73
  74 void AliHLTTPCDataCompressorHelper::SetTransverseResolutions(Float_t res1,Float_t res2,Float_t res3,Float_t width)
  75 {
  76   // sets the transverse resolution
  77   fgXYResidualStep1 = res1;
  78   fgXYResidualStep2 = res2;
  79   fgXYResidualStep3 = res3;
  80   fgXYWidthStep = width;
  81 }
  82
  83 void AliHLTTPCDataCompressorHelper::SetLongitudinalResolutions(Float_t res1,Float_t res2,Float_t res3,Float_t width)
  84 {
  85   // sets the longitudinal resolution
  86   fgZResidualStep1 = res1;
  87   fgZResidualStep2 = res2;
  88   fgZResidualStep3 = res3;
  89   fgZWidthStep = width;
  90 }
  91
  92 void AliHLTTPCDataCompressorHelper::SetRemainingBitNumbers(Int_t pad,Int_t time,Int_t shape)
  93 {
  94   // sets the numbers of remaining bits
  95   fgNumPadBitsRemaining = pad;
  96   fgNumTimeBitsRemaining = time;
  97   fgNumShapeBitsRemaining = shape;
  98 }
  99
 100 Float_t AliHLTTPCDataCompressorHelper::GetXYResidualStep(Int_t row)
 101 {
 102   // gets the XY residual step
 103   if(row < AliHLTTPCTransform::GetNRowLow())
 104     return fgXYResidualStep1;
 105   else if(row < AliHLTTPCTransform::GetNRowLow() + AliHLTTPCTransform::GetNRowUp1())
 106     return fgXYResidualStep2;
 107   else if(row < AliHLTTPCTransform::GetNRowLow() + AliHLTTPCTransform::GetNRowUp1() + AliHLTTPCTransform::GetNRowUp2())
 108     return fgXYResidualStep3;
 109   else
 110     {
 111       cerr<<"AliHLTTPCDataCompressorHelper::GetXYResidualStep : Wrong row number "<<row<<endl;
 112       return -1;
 113     }
 114 }
 115
 116 Float_t AliHLTTPCDataCompressorHelper::GetZResidualStep(Int_t row)
 117 {
 118   // gets the Z residual step
 119   if(row < AliHLTTPCTransform::GetNRowLow())
 120     return fgZResidualStep1;
 121   else if(row < AliHLTTPCTransform::GetNRowLow() + AliHLTTPCTransform::GetNRowUp1())
 122     return fgZResidualStep2;
 123   else if(row < AliHLTTPCTransform::GetNRowLow() + AliHLTTPCTransform::GetNRowUp1() + AliHLTTPCTransform::GetNRowUp2())
 124     return fgZResidualStep3;
 125   else
 126     {
 127       cerr<<"AliHLTTPCDataCompressorHelper::GetXYResidualStep : Wrong row number "<<row<<endl;
 128       return -1;
 129     }
 130 }
 131
 132 Float_t AliHLTTPCDataCompressorHelper::GetPadPrecisionFactor()
 133 {
 134   // gets pad precision factor
 135   Int_t nbits = fgNumPadBitsRemaining;
 136   if(nbits >=21)
 137     return 10000;
 138   if(nbits >= 18)
 139     return 1000;
 140   if(nbits >= 14)
 141     return 100;
 142   if(nbits >= 11)
 143     return 10;
 144   if(nbits >= 8)
 145     return 1;
 146   else
 147     {
 148       cerr<<"AliHLTTPCDataCompressorHelper::GetRemainingPadFactor : Too few bits for the pad direction: "<<nbits<<endl;
 149       return 1;
 150     }
 151 }
 152
 153 Float_t AliHLTTPCDataCompressorHelper::GetTimePrecisionFactor()
 154 {
 155   // gest time precision factor
 156   Int_t nbits = fgNumTimeBitsRemaining;
 157   if(nbits >=23)
 158     return 10000;
 159   if(nbits >= 19)
 160     return 1000;
 161   if(nbits >= 16)
 162     return 100;
 163   if(nbits >= 13)
 164     return 10;
 165   if(nbits >= 9)
 166     return 1;
 167   else
 168     {
 169       cerr<<"AliHLTTPCDataCompressorHelper::GetRemainingPadFactor : Too few bits for the pad direction: "<<nbits<<endl;
 170       return 1;
 171     }
 172 }
 173
 174
 175 Int_t AliHLTTPCDataCompressorHelper::Nint(Double_t x)
 176 {
 177    // Round to nearest integer. Rounds half integers
 178    // to the nearest even integer.
 179
 180    Int_t i=0;
 181    if (x >= 0) {
 182       i = Int_t(x + 0.5);
 183       if (x + 0.5 == Double_t(i) && i & 1) i--;
 184    } else {
 185       i = Int_t(x - 0.5);
 186       if (x - 0.5 == Double_t(i) && i & 1) i++;
 187
 188    }
 189    return i;
 190 }