TOPTrack.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 <framework/gearbox/Const.h>
#include <top/reconstruction_cpp/HelixSwimmer.h>
#include <top/reconstruction_cpp/RaytracerBase.h>
#include <framework/database/DBObjPtr.h>
#include <top/dbobjects/TOPCalModuleAlignment.h>
#include <top/dbobjects/TOPFrontEndSetting.h>
#include <mdst/dataobjects/MCParticle.h>
 
#include <vector>
#include <map>
#include <unordered_map>
#include <string>
 
namespace Belle2 {
  class Track;
  class ExtHit;
  class TOPBarHit;
 
  namespace TOP {
 
    class TOPTrack {
 
    public:
 
      struct TrackAngles {
        double cosTh = 0; 
        double sinTh = 0; 
        double cosFi = 0; 
        double sinFi = 0; 
        TrackAngles()
        {}
 
        explicit TrackAngles(const ROOT::Math::XYZVector& direction);
 
        ROOT::Math::XYZVector getDirection() const {return ROOT::Math::XYZVector(cosFi * sinTh, sinFi * sinTh, cosTh);}
      };
 
      struct AssumedEmission {
        ROOT::Math::XYZPoint position;  
        TrackAngles trackAngles; 
        bool isSet = false; 
      };
 
      struct SelectedHit {
        int pixelID = 0;    
        double time = 0;    
        double timeErr = 0; 
        SelectedHit(int pix, double t, double terr):
          pixelID(pix), time(t), timeErr(terr)
        {}
      };
 
      TOPTrack()
      {}
 
      explicit TOPTrack(const Track& track, const std::string& digitsName = "",
                        const Const::ChargedStable& chargedStable = Const::pion);
 
      explicit TOPTrack(const ExtHit* extHit, const std::string& digitsName = "");
 
      bool overrideTransformation(const ROOT::Math::Transform3D& transform)
      {
        m_valid = setHelix(transform);
        return m_valid;
      }
 
      bool isValid() const {return m_valid;}
 
      int getModuleID() const {return m_moduleID;}
 
      double getMomentumMag() const {return m_momentum;}
 
      double getTransverseMomentum() const {return m_pT;}
 
      double getCharge() const {return m_charge;}
 
      double getTrackLength() const {return m_trackLength;}
 
      double getLengthInQuartz() const {return m_length;}
 
      double getBeta(const Const::ChargedStable& particle, double overrideMass = 0) const;
 
      const TOPTrack::AssumedEmission& getEmissionPoint(double dL = 0) const;
 
      double getTOF(const Const::ChargedStable& particle, double dL = 0, double overrideMass = 0) const;
 
      const TOP::HelixSwimmer& getHelix() const {return m_helix;}
 
      const Track* getTrack() const {return m_track;}
 
      const ExtHit* getExtHit() const {return m_extHit;}
 
      const MCParticle* getMCParticle() const {return m_mcParticle;}
 
      int getPDGCode() const
      {
        if (m_mcParticle) return m_mcParticle->getPDG();
        return 0;
      }
 
      const TOPBarHit* getBarHit() const {return m_barHit;}
 
      const std::vector<SelectedHit>& getSelectedHits() const {return m_selectedHits;}
 
      double getBkgRate() const {return m_bkgRate;}
 
      bool isScanRequired(unsigned col, double time, double wid) const;
 
    private:
 
      void set(const Track& track, const std::string& digitsName, const Const::ChargedStable& chargedStable);
 
      bool setHelix(const ROOT::Math::Transform3D& transform);
 
      bool xsecPrism(std::vector<double>& lengths, std::vector<ROOT::Math::XYZPoint>& positions,
                     const RaytracerBase::Prism& prism, const ROOT::Math::Transform3D& transform);
 
      int m_moduleID = 0;  
      double m_momentum = 0; 
      double m_pT = 0; 
      double m_charge = 0;  
      double m_TOFLength = 0; 
      double m_trackLength = 0;  
      double m_length = 0; 
      TOP::HelixSwimmer m_helix; 
      DBObjPtr<TOPCalModuleAlignment> m_alignment;   
      DBObjPtr<TOPFrontEndSetting> m_feSetting;  
      const Track* m_track = 0;  
      const ExtHit* m_extHit = 0;  
      const MCParticle* m_mcParticle = 0;  
      const TOPBarHit* m_barHit = 0;  
      bool m_valid = false;  
      std::vector<SelectedHit> m_selectedHits; 
      double m_bkgRate = 0; 
      std::unordered_multimap<unsigned, const SelectedHit*> m_columnHits; 
      mutable std::map<double, TOPTrack::AssumedEmission> m_emissionPoints;
 
    };
 
 
    inline double TOPTrack::getBeta(const Const::ChargedStable& chargedStable, double overrideMass) const
    {
      double mass = chargedStable.getMass();
      if (overrideMass > 0)
        mass = overrideMass;
      return m_momentum / sqrt(m_momentum * m_momentum + mass * mass);
    }
 
    inline double TOPTrack::getTOF(const Const::ChargedStable& chargedStable, double dL, double overrideMass) const
    {
      return (m_trackLength + dL) / getBeta(chargedStable, overrideMass) / Const::speedOfLight;
    }
 
 
  } // end TOP namespace
} // end Belle2 namespace