ARICHReconstruction.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <arich/dbobjects/ARICHGeometryConfig.h>
#include <arich/dbobjects/ARICHReconstructionPar.h>
#include <arich/dbobjects/ARICHChannelMask.h>
#include <arich/dbobjects/ARICHChannelMapping.h>
#include <arich/dbobjects/ARICHGlobalAlignment.h>
#include <arich/dbobjects/ARICHMirrorAlignment.h>
#include <arich/dbobjects/ARICHAeroTilesAlignment.h>
#include "framework/datastore/StoreArray.h"
#include "arich/dataobjects/ARICHHit.h"
#include "arich/dataobjects/ARICHTrack.h"
#include "arich/dataobjects/ARICHLikelihood.h"
#include <framework/database/DBObjPtr.h>
 
#include <Math/Vector3D.h>
 
namespace Belle2 {
  class ARICHReconstruction {
 
  public:
 
    explicit ARICHReconstruction(int storePhotons = 0);
 
    ~ARICHReconstruction() {};
 
    void initialize();
 
    int smearTrack(ARICHTrack& arichTrack);
 
    void transformTrackToLocal(ARICHTrack& arichTrack, bool align);
 
    int likelihood2(ARICHTrack& arichTrack, const StoreArray<ARICHHit>& arichHits, ARICHLikelihood& arichLikelihood);
 
    void setTrackPositionResolution(double pRes);
 
    void setTrackAngleResolution(double aRes);
 
    void useMirrorAlignment(bool align)
    {
      m_alignMirrors = align;
    };
 
    void correctEmissionPoint(int tileID, double r);
 
  private:
 
    static const int c_noOfHypotheses = Const::ChargedStable::c_SetSize; 
    static const int c_noOfAerogels = 5; 
    double p_mass[c_noOfHypotheses];  
    DBObjPtr<ARICHGeometryConfig> m_arichgp; 
    DBObjPtr<ARICHReconstructionPar> m_recPars; 
    DBObjPtr<ARICHChannelMask> m_chnMask; 
    DBObjPtr<ARICHChannelMapping> m_chnMap; 
    DBObjPtr<ARICHGlobalAlignment> m_alignp; 
    DBObjPtr<ARICHMirrorAlignment> m_mirrAlign; 
    OptionalDBObjPtr<ARICHAeroTilesAlignment> m_tileAlign; 
    std::vector<ROOT::Math::XYZVector > m_mirrorPoints; 
    std::vector<ROOT::Math::XYZVector > m_mirrorNorms;  
    double m_trackPosRes; 
    double m_trackAngRes; 
    bool   m_alignMirrors; 
    unsigned int m_nAerogelLayers; 
    double  m_refractiveInd[c_noOfAerogels]; 
    double  m_zaero[c_noOfAerogels]; 
    double  m_thickness[c_noOfAerogels]; 
    double  m_transmissionLen[c_noOfAerogels]; 
    double  m_n0[c_noOfAerogels];  
    ROOT::Math::XYZVector m_anorm[c_noOfAerogels]; 
    int m_storePhot; 
    double m_tilePars[124][2] = {{0}}; 
    int InsideDetector(ROOT::Math::XYZVector a, int copyno);
 
    ROOT::Math::XYZVector HitVirtualPosition(const ROOT::Math::XYZVector& hitpos, int mirrorID);
 
    ROOT::Math::XYZVector FastTracking(ROOT::Math::XYZVector dirf, ROOT::Math::XYZVector r,  double* refind, double* z, int n,
                                       int opt);
//    ROOT::Math::XYZVector FastTracking(ROOT::Math::XYZVector dirf, ROOT::Math::XYZVector r,  double* refind, double* z, int n);
 
    ROOT::Math::XYZVector FastTrackingSimple(ROOT::Math::XYZVector dirf, ROOT::Math::XYZVector r,  double* refind, double* z, int n);
 
    int  CherenkovPhoton(ROOT::Math::XYZVector r, ROOT::Math::XYZVector rh,
                         ROOT::Math::XYZVector& rf, ROOT::Math::XYZVector& dirf,
                         double* refind, double* z, int n, int mirrorID = 0);
 
    bool HitsMirror(const ROOT::Math::XYZVector& pos, const ROOT::Math::XYZVector& dir, int mirrorID);
 
    ROOT::Math::XYZVector getTrackMeanEmissionPosition(const ARICHTrack& track, int iAero);
 
    ROOT::Math::XYZVector getTrackPositionAtZ(const ARICHTrack& track, double zout);
 
    ROOT::Math::XYZVector getMirrorPoint(int mirrorID);
 
    ROOT::Math::XYZVector getMirrorNorm(int mirrorID);
 
  };
 
} // end of namespace Belle2