Fitter3DUtility.h

#ifndef FITTER3DUTILITY_H
#define FITTER3DUTILITY_H
 
#include <TVectorD.h>
#include <TLorentzVector.h>
#include <TVector3.h>
#include <TVector2.h>
#include <map>
#include <string>
 
namespace Belle2 {
  class TRGCDCJSignal;
  class TRGCDCJSignalData;
  class TRGCDCJLUT;
};
 
 
class Fitter3DUtility {
 
public:
 
  static int findSign(double* phi2);
 
  static void rPhiFit(double* rr, double* phi2, double* phierror, double& rho, double& myphi0);
 
  static void rPhiFitter(double* rr, double* phi2, double* invphierror, double& rho, double& myphi0);
 
  static void rPhiFitter(double* rr, double* phi2, double* invphierror, double& rho, double& myphi0, double& chi2);
 
  static void chargeFinder(double* nTSs, double* tsIds, double* tsHitmap, double phi0, double inCharge, double& outCharge);
 
  static void rPhiFit2(double* rr, double* phi2, double* phierror, double& rho, double& myphi0, int nTS);
 
  static unsigned toUnsignedTdc(int tdc, int nBits);
 
  static double calPhi(double wirePhi, double driftLength, double rr, int lr);
 
  static double calPhi(double wirePhi, double driftTime, double eventTime, double rr, int lr);
 
  static double calPhi(int localId, int nWires, double driftTime, double eventTime, double rr, int lr);
 
  static void calPhi(std::map<std::string, double> const& mConstD, std::map<std::string, std::vector<double> > const& mConstV,
                     std::map<std::string, Belle2::TRGCDCJSignal>& mSignalStorage, std::map<std::string, Belle2::TRGCDCJLUT* >& mLutStorage);
 
  static void saveStereoXt(std::vector<std::vector<double> >& stXts, std::string const& filePrefix);
 
  static void loadStereoXt(std::string const& filePrefix, int nFiles, std::vector<std::vector<double> >& stXts);
 
  static double stereoIdToPhi(std::vector<double>& stNWires, int iSt, int id);
 
  static void calPhiFast(std::map<std::string, std::vector<double> >& stGeometry, std::vector<std::vector<double> > const& stXts,
                         int eventTimeValid, int eventTime, std::vector<std::vector<int> > const& rawStTSs, std::vector<double>& stTSs);
 
  static double rotatePhi(double value, double refPhi);
 
  static double rotatePhi(double value, int refId, int nTSs);
 
  static int rotateTsId(int value, int refId, int nTSs);
 
  static int findQuadrant(double value);
 
  static void setErrorFast(std::vector<std::vector<int> > const& rawStTSs, int eventTimeValid, std::vector<double>& invZError2);
 
  static void setError(std::map<std::string, double> const& mConstD, std::map<std::string, std::vector<double> > const& mConstV,
                       std::map<std::string, Belle2::TRGCDCJSignal>& mSignalStorage);
 
  static double calStAxPhi(int charge, double anglest, double ztostraw, double rr, double rho, double phi0);
 
  static double calDeltaPhi(int charge, double anglest, double ztostraw, double rr, double phi, double rho, double phi0);
 
  static void constrainRPerStSl(std::map<std::string, std::vector<double> > const& mConstV,
                                std::map<std::string, Belle2::TRGCDCJSignal>& mSignalStorage);
 
  static double calZ(int charge, double anglest, double ztostraw, double rr, double phi, double rho, double phi0);
 
  static void calZ(std::map<std::string, double> const& mConstD, std::map<std::string, std::vector<double> > const& mConstV,
                   std::map<std::string, Belle2::TRGCDCJSignal>& mSignalStorage, std::map<std::string, Belle2::TRGCDCJLUT* >& mLutStorage);
 
  static double calS(double rho, double rr);
 
  static void calS(std::map<std::string, double> const& mConstD, std::map<std::string, std::vector<double> > const& mConstV,
                   std::map<std::string, Belle2::TRGCDCJSignal>& mSignalStorage, std::map<std::string, Belle2::TRGCDCJLUT* >& mLutStorage);
 
  static double calIZError2(int lr, double driftZError, double wireZError);
 
  static double calDen(double* arcS, double* zError);
 
  static double calDenWithIZError(double* arcS, double* iZError);
 
  static void rSFit(double* iezz2, double* arcS, double* zz, double& z0, double& cot, double& zchi2);
 
  static void rSFit2(double* iezz21, double* iezz22, double* arcS, double* zz, int* lutv,  double& z0, double& cot, double& zchi2);
 
  static void rSFit(std::map<std::string, double> const& mConstD, std::map<std::string, std::vector<double> > const& mConstV,
                    std::map<std::string, Belle2::TRGCDCJSignal>& mSignalStorage, std::map<std::string, Belle2::TRGCDCJLUT* >& mLutStorage);
 
  static void fitter3D(std::map<std::string, std::vector<double> >& stGeometry, std::vector<std::vector<double> > const& stXts,
                       int eventTimeValid, int eventTime,
                       std::vector<std::vector<int> > const& rawStTSs,
                       int charge, double radius, double phi_c, double& z0, double& cot, double& chi2);
  static void fitter3D(std::map<std::string, std::vector<double> >& stGeometry, std::vector<std::vector<double> > const& stXts,
                       int eventTimeValid, int eventTime,
                       std::vector<std::vector<int> > const& rawStTSs,
                       int charge, double radius, double phi_c, double& z0, double& cot, double& chi2,
                       std::vector<double>& arcS, std::vector<double>& zz, std::vector<double>& invZError2);
 
  static void fitter3DFirm(std::map<std::string, double>& mConstD, std::map<std::string, std::vector<double> >& mConstV,
                           int eventTimeValid, int eventTime,
                           std::vector<std::vector<int> > const& rawStTSs,
                           int charge, double radius, double phi_c,
                           Belle2::TRGCDCJSignalData* commonData, std::map<std::string, Belle2::TRGCDCJSignal>& mSignalStorage,
                           std::map<std::string, Belle2::TRGCDCJLUT*>& mLutStorage);
 
 
  static void findImpactPosition(TVector3* mcPosition, TLorentzVector* mcMomentum, int charge, TVector2& helixCenter,
                                 TVector3& impactPosition);
 
  static void calHelixParameters(TVector3 position, TVector3 momentum, int charge, TVectorD& helixParameters);
 
  static void calVectorsAtR(TVectorD& helixParameters, int charge, double radius, TVector3& position, TVector3& momentum);
 
 
  static int bitSize(int numberBits, int mode);
 
  static void changeInteger(int& integer, double real, double minValue, double maxValue, int bitSize);
 
  static void changeReal(double& real, int integer, double minValue, double maxValue, int bitSize);
 
  static void findExtreme(double& m_max, double& m_min, double value);
};
 
#endif