CDCSimpleSimulation Class Reference

Class providing a simple simulation of the CDC mainly for quick unit test checks. More...

#include <CDCSimpleSimulation.h>

Collaboration diagram for CDCSimpleSimulation:

Classes
struct	SimpleSimHit
	Structure to accomdate information about the individual hits during the simluation. More...

Public Member Functions
ConstVectorRange< CDCWireHit >	getWireHits () const
	Getter for the wire hits created in the simulation.
std::vector< CDCTrack >	simulate (const std::vector< CDCTrajectory3D > &trajectories3D)
	Propagates the trajectories through the CDC as without energy loss until they first leave the CDC. More...
CDCTrack	simulate (const CDCTrajectory3D &trajectory3D)
	Same as above for one trajectory.
std::vector< CDCTrack >	loadPreparedEvent ()
	Fills the wire hits with a hard coded event from the real simulation.
double	getEventTime () const
	Getter for a global event time offset.
void	setEventTime (double eventTime)
	Setter for a global event time offset.
void	activateTOFDelay (bool activate=true)
	Activate the TOF time delay.
void	activateInWireSignalDelay (bool activate=true)
	Activate the in wire signal delay.
int	getMaxNHitOnWire () const
	Getter for the maximal number of hits that are allowed on each layer.
void	setMaxNHitOnWire (int maxNHitOnWire)
	Setter for the maximal number of hits that are allowed on each layer.

Private Member Functions
std::vector< CDCTrack >	constructMCTracks (int nMCTracks, std::vector< SimpleSimHit > simpleSimHits)
	Creates CDCWireHits and uses them to construct the true CDCTracks. More...
std::vector< SimpleSimHit >	createHits (const Helix &globalHelix, double arcLength2DOffset) const
	Generate hits for the given helix in starting from the two dimensional arc length.
std::vector< SimpleSimHit >	createHitsForLayer (const CDCWire &nearWire, const Helix &globalHelix, double arcLength2DOffset) const
	Generate connected hits for wires in the same layer close to the given wire. More...
SimpleSimHit	createHitForCell (const CDCWire &wire, const Helix &globalHelix, double arcLength2DOffset) const
	Generate a hit for the given wire.

Private Attributes
std::shared_ptr< const std::vector< CDCWireHit > >	m_sharedWireHits
	Space for the memory of the generated wire hits.
const double	s_nominalDriftLengthVariance = 0.000169
	Default drift length variance.
const double	s_nominalPropSpeed = 27.25
	Default in wire signal propagation speed - 27.25 cm / ns.
const double	s_nominalDriftSpeed = 4e-3
	Default electron drift speed in cdc gas - 4 * 10^-3 cm / ns.
int	m_maxNHitOnWire = 0
	Maximal number of hits allowed on each wire (0 means all).
double	m_eventTime = 0
	A global event time.
bool	m_addTOFDelay = false
	Switch to activate the addition of the time of flight.
bool	m_addInWireSignalDelay = false
	Switch to activate the in wire signal delay.
double	m_driftLengthVariance = s_nominalDriftLengthVariance
	Variance by which the drift length should be smeared.
double	m_driftLengthSigma = std::sqrt(m_driftLengthVariance)
	Standard deviation by which the drift length should be smeared.
double	m_propSpeed = s_nominalPropSpeed
	Electrical current propagation speed in the wires.
double	m_driftSpeed = s_nominalDriftSpeed
	Electron drift speed in the cdc gas.

Detailed Description

Class providing a simple simulation of the CDC mainly for quick unit test checks.

Most aspects of the detection are idealized

• Trajectories are ideal helices
• Wires are straight lines
• Drift relation linear
• No detection inefficiencies are enabled
• T0, TOF and signal delay in the wire are not taken into account (but can eventually implemented to study them)

Nevertheless drift length a smeared by one gaussian distribution of fixed width to have a realistic check for the accuracy of fast fitting procedures in terms of their chi2 distributions.

Definition at line 44 of file CDCSimpleSimulation.h.

Member Function Documentation

constructMCTracks()

std::vector< CDCTrack > constructMCTracks ( int  nMCTracks, std::vector< SimpleSimHit >  simpleSimHits  )

private

Creates CDCWireHits and uses them to construct the true CDCTracks.

Sort the hits by the order of their occurance

Definition at line 89 of file CDCSimpleSimulation.cc.

{
 
  // Sort the hits along side their wire hits
  std::stable_sort(simpleSimHits.begin(), simpleSimHits.end(),
  [](const SimpleSimHit & lhs, const SimpleSimHit & rhs) -> bool {
    return lhs.m_wireHit < rhs.m_wireHit;
  });
 
  // Discard multiple hits on the same wire up to the maximal exceeding the maximal desired number
  if (m_maxNHitOnWire > 0) {
    const CDCWire* lastWire = nullptr;
    size_t nSameWire = 0;
    const size_t maxNHitOnWire = m_maxNHitOnWire;
 
    auto exceedsMaxNHitOnWire =
    [&lastWire, &nSameWire, maxNHitOnWire](const SimpleSimHit & simpleSimHit) -> bool {
 
      if (&(simpleSimHit.m_wireHit.getWire()) == lastWire)
      {
        ++nSameWire;
      } else {
        nSameWire = 1;
        lastWire = &(simpleSimHit.m_wireHit.getWire());
      }
      return nSameWire > maxNHitOnWire ? true : false;
    };
 
    auto itLast = std::remove_if(simpleSimHits.begin(), simpleSimHits.end(), exceedsMaxNHitOnWire);
    simpleSimHits.erase(itLast, simpleSimHits.end());
  }
 
  // Write the created hits and move them to the their storage place.
  {
    std::vector<CDCWireHit> wireHits;
    wireHits.reserve(simpleSimHits.size());
    for (SimpleSimHit& simpleSimHit : simpleSimHits) {
      wireHits.push_back(simpleSimHit.m_wireHit);
    }
 
    B2ASSERT("WireHits should be sorted as a result from sorting the SimpleSimHits. "
             "Algorithms may relay on the sorting o the WireHits",
             std::is_sorted(wireHits.begin(), wireHits.end()));
 
    m_sharedWireHits.reset(new const std::vector<CDCWireHit>(std::move(wireHits)));
  }
 
  // TODO: Decide if the EventMeta should be incremented after write.
 
  // Now construct the tracks.
  std::vector<CDCTrack> mcTracks;
  mcTracks.resize(nMCTracks);
  ConstVectorRange<CDCWireHit> wireHits = getWireHits();
  const size_t nWireHits = wireHits.size();
 
  for (size_t iWireHit = 0; iWireHit < nWireHits; ++iWireHit) {
    const CDCWireHit& wireHit = wireHits[iWireHit];
    const SimpleSimHit& simpleSimHit = simpleSimHits[iWireHit];
 
    CDCTrack& mcTrack = mcTracks[simpleSimHit.m_iMCTrack];
 
    CDCRLWireHit rlWireHit(&wireHit, simpleSimHit.m_rlInfo);
    CDCRecoHit3D recoHit3D(rlWireHit, simpleSimHit.m_pos3D, simpleSimHit.m_arcLength2D);
    mcTrack.push_back(recoHit3D);
  }
 
  for (CDCTrack& mcTrack : mcTracks) {
    mcTrack.sortByArcLength2D();
  }
 
  return mcTracks;
}

createHitsForLayer()

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

private

Generate connected hits for wires in the same layer close to the given wire.

Iter counter clockwise for more hits

Iter clockwise for more hits

Definition at line 274 of file CDCSimpleSimulation.cc.

simulate()

std::vector< CDCTrack > simulate

(

const std::vector< CDCTrajectory3D > &

trajectories3D

)

Propagates the trajectories through the CDC as without energy loss until they first leave the CDC.

Parameters

trajectories3D

Ideal trajectories to be propagated.

Returns

The true tracks containing the hits generated in this process

Assign mc trajectories to the tracks

Definition at line 48 of file CDCSimpleSimulation.cc.

---

The documentation for this class was generated from the following files:

• tracking/trackFindingCDC/sim/include/CDCSimpleSimulation.h
• tracking/trackFindingCDC/sim/src/CDCSimpleSimulation.cc