CDCSimpleSimulation.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 <tracking/trackFindingCDC/eventdata/hits/CDCWireHit.h>
 
#include <tracking/trackFindingCDC/utilities/VectorRange.h>
 
#include <tracking/trackFindingCDC/geometry/Vector3D.h>
#include <vector>
#include <memory>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    class CDCTrack;
    class CDCTrajectory3D;
    class Helix;
 
    class CDCSimpleSimulation  {
 
    private:
 
      struct SimpleSimHit {
 
        SimpleSimHit(const CDCWireHit& wireHit,
                     size_t iMCTrack,
                     ERightLeft rlInfo) :
          m_wireHit(wireHit),
          m_iMCTrack(iMCTrack),
          m_rlInfo(rlInfo)
        {}
 
        SimpleSimHit(const CDCWireHit& wireHit,
                     size_t iMCTrack,
                     ERightLeft rlInfo,
                     const Vector3D& pos3D,
                     double arcLength2D = NAN,
                     double trueDriftLength = NAN) :
          m_wireHit(wireHit),
          m_iMCTrack(iMCTrack),
          m_rlInfo(rlInfo),
          m_pos3D(pos3D),
          m_arcLength2D(arcLength2D),
          m_trueDriftLength(trueDriftLength)
        {}
 
        CDCWireHit m_wireHit;
 
        size_t m_iMCTrack;
 
        ERightLeft m_rlInfo;
 
        Vector3D m_pos3D  = m_wireHit.getRefPos3D();
 
        double m_arcLength2D = NAN;
 
        double m_trueDriftLength = NAN;
      };
 
    public:
      ConstVectorRange<CDCWireHit> getWireHits() const;
 
    public:
      std::vector<CDCTrack> simulate(const std::vector<CDCTrajectory3D>& trajectories3D);
 
      CDCTrack simulate(const CDCTrajectory3D& trajectory3D);
 
      std::vector<CDCTrack> loadPreparedEvent();
 
    private:
      std::vector<CDCTrack> constructMCTracks(int nMCTracks, std::vector<SimpleSimHit> simpleSimHits);
 
      std::vector<SimpleSimHit> createHits(const Helix& globalHelix, double arcLength2DOffset) const;
 
      std::vector<SimpleSimHit> createHitsForLayer(const CDCWire& nearWire,
                                                   const Helix& globalHelix,
                                                   double arcLength2DOffset) const;
 
      SimpleSimHit createHitForCell(const CDCWire& wire,
                                    const Helix& globalHelix,
                                    double arcLength2DOffset) const;
 
    public:
      double getEventTime() const
      { return m_eventTime; }
 
      void setEventTime(double eventTime)
      { m_eventTime = eventTime; }
 
      void activateTOFDelay(bool activate = true)
      { m_addTOFDelay = activate; }
 
      void activateInWireSignalDelay(bool activate = true)
      { m_addInWireSignalDelay = activate; }
 
      int getMaxNHitOnWire() const
      { return m_maxNHitOnWire; }
 
      void setMaxNHitOnWire(int maxNHitOnWire)
      { m_maxNHitOnWire = maxNHitOnWire; }
 
    private:
      std::shared_ptr<const std::vector<CDCWireHit> > m_sharedWireHits;
 
      const double s_nominalDriftLengthVariance = 0.000169;
 
      const double s_nominalPropSpeed = 27.25;
 
      const double s_nominalDriftSpeed = 4e-3;
 
      int m_maxNHitOnWire = 0;
 
      double m_eventTime = 0;
 
      bool m_addTOFDelay = false;
 
      bool m_addInWireSignalDelay = false;
 
      // TODO: make them freely setable ?
      double m_driftLengthVariance = s_nominalDriftLengthVariance;
 
      double m_driftLengthSigma = std::sqrt(m_driftLengthVariance);
 
      double m_propSpeed = s_nominalPropSpeed;
 
      double m_driftSpeed = s_nominalDriftSpeed;
    };
 
  }
}