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/trackingUtilities/eventdata/hits/CDCWireHit.h>
 
#include <tracking/trackingUtilities/utilities/VectorRange.h>
 
#include <tracking/trackingUtilities/geometry/Vector3D.h>
#include <vector>
#include <memory>
 
namespace Belle2 {
  namespace TrackingUtilities {

    class CDCTrack;
    class CDCTrajectory3D;
    class Helix;
  }
 
  namespace TrackFindingCDC {

    class CDCSimpleSimulation  {
 
    private:

      struct SimpleSimHit {

        SimpleSimHit(const TrackingUtilities::CDCWireHit& wireHit,
                     size_t iMCTrack,
                     TrackingUtilities::ERightLeft rlInfo) :
          m_wireHit(wireHit),
          m_iMCTrack(iMCTrack),
          m_rlInfo(rlInfo)
        {}

        SimpleSimHit(const TrackingUtilities::CDCWireHit& wireHit,
                     size_t iMCTrack,
                     TrackingUtilities::ERightLeft rlInfo,
                     const TrackingUtilities::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)
        {}

        TrackingUtilities::CDCWireHit m_wireHit;

        size_t m_iMCTrack;

        TrackingUtilities::ERightLeft m_rlInfo;

        TrackingUtilities::Vector3D m_pos3D  = m_wireHit.getRefPos3D();

        double m_arcLength2D = NAN;

        double m_trueDriftLength = NAN;
      };
 
    public:
      TrackingUtilities::ConstVectorRange<TrackingUtilities::CDCWireHit> getWireHits() const;
 
    public:
      std::vector<TrackingUtilities::CDCTrack> simulate(const std::vector<TrackingUtilities::CDCTrajectory3D>& trajectories3D);

      TrackingUtilities::CDCTrack simulate(const TrackingUtilities::CDCTrajectory3D& trajectory3D);

      std::vector<TrackingUtilities::CDCTrack> loadPreparedEvent();
 
    private:
      std::vector<TrackingUtilities::CDCTrack> constructMCTracks(int nMCTracks, std::vector<SimpleSimHit> simpleSimHits);

      std::vector<SimpleSimHit> createHits(const TrackingUtilities::Helix& globalHelix, double arcLength2DOffset) const;

      std::vector<SimpleSimHit> createHitsForLayer(const CDC::CDCWire& nearWire,
                                                   const TrackingUtilities::Helix& globalHelix,
                                                   double arcLength2DOffset) const;

      SimpleSimHit createHitForCell(const CDC::CDCWire& wire,
                                    const TrackingUtilities::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<TrackingUtilities::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;
    };
 
  }
}