WireHitCreator Class Reference

Combines the geometrical information and the raw hit information into wire hits, which can be used from all modules after that. More...

#include <WireHitCreator.h>

Inheritance diagram for WireHitCreator:

Public Types
using	IOTypes
	Types that should be served to apply on invocation.
using	IOVectors
	Vector types that should be served to apply on invocation.

Public Member Functions
	WireHitCreator ()
	Default constructor.
	~WireHitCreator ()
	Default destructor.
std::string	getDescription () final
	Short description of the findlet.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters to a module.
void	initialize () final
	Signals the beginning of the event processing.
void	beginRun () final
	Signal the beginning of a new run.
void	apply (std::vector< CDCWireHit > &outputWireHits) final
	Main algorithm creating the wire hits.
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
void	beginEvent () override
	Receive and dispatch signal for the start of a new event.
void	endRun () override
	Receive and dispatch signal for the end of the run.
void	terminate () override
	Receive and dispatch Signal for termination of the event processing.

Protected Types
using	ToVector
	Short hand for ToRangeImpl.

Protected Member Functions
void	addProcessingSignalListener (ProcessingSignalListener *psl)
	Register a processing signal listener to be notified.
int	getNProcessingSignalListener ()
	Get the number of currently registered listeners.

Private Types
using	Super = Findlet<CDCWireHit>
	Type of the base class.

Private Attributes
std::string	m_param_wirePosition = "base"
	Parameter : Geometry set to be used. Either "base", "misalign" or " aligned".
bool	m_param_ignoreWireSag = false
	Parameter : Switch to deactivate the sag of the wires for the concerns of the track finders.
std::string	m_param_flightTimeEstimation = "none"
	Parameter : Method for the initial time of flight estimation as string.
std::tuple< double, double, double >	m_param_triggerPoint = {0.0, 0.0, 0.0}
	Parameter : Location of the flight time zero.
std::vector< int >	m_param_useSuperLayers
	Parameter : List of super layers to be used - mostly for debugging.
std::vector< uint >	m_param_useLayers
	Parameter : List of layers to be used.
std::vector< uint >	m_param_ignoreLayers
	Parameter : List of layers to be ignored in tracking e.g. for simulating too high occupancy.
std::vector< float >	m_param_maxDriftTimes = { -1, -1, -1, -1, -1, -1, -1, -1, -1}
	Parameter : Cut for approximate drift time (super-layer dependent)
bool	m_param_useSecondHits = false
	Parameter : If true, the second hit information will be used to create Wire Hits.
bool	m_param_useBadWires = false
	Parameter : If true, the hits on bad wires are not ignored.
std::tuple< double, double >	m_param_useDegreeSector {INFINITY, INFINITY}
	Parameter : Angular range in degrees for which hits should be unpacked.
std::vector< int >	m_param_useMCParticleIds {}
	Parameter : Indices of the Monte Carlo particles for which hits should be used.
EWirePosition	m_wirePosition = EWirePosition::c_Base
	Geometry set to be used.
std::array< float, ISuperLayerUtil::c_N >	m_maxDriftTimes = { -1, -1, -1, -1, -1, -1, -1, -1, -1}
	Cut for approximate drift time (super-layer dependent)
EPreferredDirection	m_flightTimeEstimation = EPreferredDirection::c_None
	Method for the initial time of flight estimation.
Vector3D	m_triggerPoint = Vector3D(0.0, 0.0, 0.0)
	Central location of the flight time zero position. Usually the location of the trigger.
std::array< bool, ISuperLayerUtil::c_N >	m_useSuperLayers {}
	Bits for the used super layers.
std::array< bool, c_maxNSenseLayers >	m_useLayers {}
	Bits for the used layers.
std::array< Vector2D, 2 >	m_useSector {}
	Unit vectors denoting the sector for which hits should be created.
std::unique_ptr< CDC::TDCCountTranslatorBase >	m_tdcCountTranslator
	TDC Count translator to be used to calculate the initial dirft length estiamtes.
std::unique_ptr< CDC::ADCCountTranslatorBase >	m_adcCountTranslator
	ADC Count translator to be used to calculate the charge deposit in the drift cell.
DBObjPtr< CDClayerTimeCut >	m_DBCDClayerTimeCut
	Cut for approximate drift time (super-layer dependent)
std::vector< ProcessingSignalListener * >	m_subordinaryProcessingSignalListeners
	References to subordinary signal processing listener contained in this findlet.
bool	m_initialized
	Flag to keep track whether initialization happened before.
bool	m_terminated
	Flag to keep track whether termination happened before.
std::string	m_initializedAs
	Name of the type during initialisation.

Detailed Description

Combines the geometrical information and the raw hit information into wire hits, which can be used from all modules after that.

Definition at line 44 of file WireHitCreator.h.

Member Typedef Documentation

IOTypes

using IOTypes

inherited

Types that should be served to apply on invocation.

Definition at line 30 of file Findlet.h.

IOVectors

using IOVectors

inherited

Vector types that should be served to apply on invocation.

Definition at line 53 of file Findlet.h.

Super

using Super = Findlet<CDCWireHit>

private

Type of the base class.

Definition at line 48 of file WireHitCreator.h.

ToVector

using ToVector

protectedinherited

Short hand for ToRangeImpl.

Definition at line 49 of file Findlet.h.

Member Function Documentation

addProcessingSignalListener()

void addProcessingSignalListener ( ProcessingSignalListener * psl )

protectedinherited

Register a processing signal listener to be notified.

Definition at line 53 of file CompositeProcessingSignalListener.cc.

{
  m_subordinaryProcessingSignalListeners.push_back(psl);
}

apply()

void apply ( std::vector< CDCWireHit > & outputWireHits )

final

Main algorithm creating the wire hits.

Definition at line 212 of file WireHitCreator.cc.

{
  // Wire hits have been created before
  if (not outputWireHits.empty()) return;
 
  const CDCWireTopology& wireTopology = CDCWireTopology::getInstance();
  CDC::TDCCountTranslatorBase& tdcCountTranslator = *m_tdcCountTranslator;
  CDC::ADCCountTranslatorBase& adcCountTranslator = *m_adcCountTranslator;
  CDC::CDCGeometryPar& geometryPar = CDC::CDCGeometryPar::Instance();
 
  // Create the wire hits into a vector
  StoreArray<CDCHit> hits;
  std::size_t nHits = hits.getEntries();
  if (nHits == 0) {
    B2WARNING("Event with no hits");
    outputWireHits.clear();
  }
 
  std::map<int, size_t> nHitsByMCParticleId;
 
  outputWireHits.reserve(nHits);
 
  // make sure that DB object for time cut is valid:
  if (not m_DBCDClayerTimeCut.isValid()) {
    B2FATAL("CDClayerTimeCut DB object is invalid");
  }
 
  for (const CDCHit& hit : hits) {
 
    if (hit.getICLayer() < geometryPar.getOffsetOfFirstLayer() or
        hit.getISuperLayer() < geometryPar.getOffsetOfFirstSuperLayer()) {
      continue;
    }
 
    // ignore this hit if it contains the information of a 2nd hit
    if (!m_param_useSecondHits && hit.is2ndHit()) {
      continue;
    }
 
    // Only use some MCParticles if request - mostly for debug
    if (not m_param_useMCParticleIds.empty()) {
      MCParticle* mcParticle = hit.getRelated<MCParticle>();
      int mcParticleId = mcParticle->getArrayIndex();
      if (mcParticle) {
        nHitsByMCParticleId[mcParticleId]++;
      }
      bool useMCParticleId = std::count(m_param_useMCParticleIds.begin(),
                                        m_param_useMCParticleIds.end(),
                                        mcParticleId);
      if (not useMCParticleId) continue;
    }
 
    WireID wireID(hit.getID());
    if (not wireTopology.isValidWireID(wireID)) {
      B2WARNING("Skip invalid wire id " << hit.getID());
      continue;
    }
 
    // ignore hit if it is on a bad wire
    if (not m_param_useBadWires and geometryPar.isBadWire(wireID)) {
      continue;
    }
 
    // Exclude hit with large drift time
    // In the following, the tof correction is off; the propagation-delay corr. is off (default of the translator); the event time corr. is on when it is available.
    const double approxDriftTime = tdcCountTranslator.getDriftTime(hit.getTDCCount(), wireID, 0, 0, hit.getADCCount());
    ISuperLayer iSL = wireID.getISuperLayer();
 
    // If input module parameter is set to positive value, use it. Otherwise use DB
    if (m_maxDriftTimes.at(iSL) > 0) {
      if (approxDriftTime > m_maxDriftTimes.at(iSL)) continue;
    } else {
      if (m_DBCDClayerTimeCut->getLayerTimeCut(iSL) > 0 && approxDriftTime > m_DBCDClayerTimeCut->getLayerTimeCut(iSL)) continue;
    }
 
    if (not m_useSuperLayers[iSL]) continue;
    unsigned short layer = wireID.getICLayer();
    if (not m_useLayers[layer]) continue;
 
    const CDCWire& wire = wireTopology.getWire(wireID);
 
    const Vector2D& pos2D = wire.getRefPos2D();
 
    // Check whether the position is outside the selected sector
    if (pos2D.isBetween(m_useSector[1], m_useSector[0])) continue;
 
    // Only use some MCParticles if request - mostly for debug
    if (not m_param_useMCParticleIds.empty()) {
      MCParticle* mcParticle = hit.getRelated<MCParticle>();
      int mcParticleId = mcParticle->getArrayIndex();
      if (mcParticle) {
        nHitsByMCParticleId[mcParticleId]++;
      }
      bool useMCParticleId = std::count(m_param_useMCParticleIds.begin(),
                                        m_param_useMCParticleIds.end(),
                                        mcParticleId);
      if (not useMCParticleId) continue;
    }
 
 
 
    // Consider the particle as incoming in the top part of the CDC for a downwards flight direction
    bool isIncoming = m_flightTimeEstimation == EPreferredDirection::c_Downwards and pos2D.y() > 0;
    const double alpha = isIncoming ?  M_PI : 0;
    const double beta = 1;
    const double flightTimeEstimate =
      FlightTimeEstimator::instance().getFlightTime2D(pos2D, alpha, beta);
 
    const double driftTime =  tdcCountTranslator.getDriftTime(hit.getTDCCount(),
                                                              wire.getWireID(),
                                                              flightTimeEstimate,
                                                              wire.getRefZ(),
                                                              hit.getADCCount());
    const bool left = false;
    const bool right = true;
    const double theta = M_PI / 2;
 
    const double leftRefDriftLength =
      tdcCountTranslator.getDriftLength(hit.getTDCCount(),
                                        wire.getWireID(),
                                        flightTimeEstimate,
                                        left,
                                        wire.getRefZ(),
                                        alpha,
                                        theta);
 
    const double rightRefDriftLength =
      tdcCountTranslator.getDriftLength(hit.getTDCCount(),
                                        wire.getWireID(),
                                        flightTimeEstimate,
                                        right,
                                        wire.getRefZ(),
                                        alpha,
                                        theta);
 
    const double refDriftLength =
      (leftRefDriftLength + rightRefDriftLength) / 2.0;
 
    const double leftRefDriftLengthVariance =
      tdcCountTranslator.getDriftLengthResolution(refDriftLength,
                                                  wire.getWireID(),
                                                  left,
                                                  wire.getRefZ(),
                                                  alpha,
                                                  theta);
 
    const double rightRefDriftLengthVariance =
      tdcCountTranslator.getDriftLengthResolution(refDriftLength,
                                                  wire.getWireID(),
                                                  right,
                                                  wire.getRefZ(),
                                                  alpha,
                                                  theta);
 
    const double refDriftLengthVariance =
      (leftRefDriftLengthVariance + rightRefDriftLengthVariance) / 2.0;
 
    const double leftRefChargeDeposit =
      adcCountTranslator.getCharge(hit.getADCCount(),
                                   wire.getWireID(),
                                   left,
                                   wire.getRefZ(),
                                   theta);
 
    const double rightRefChargeDeposit =
      adcCountTranslator.getCharge(hit.getADCCount(),
                                   wire.getWireID(),
                                   right,
                                   wire.getRefZ(),
                                   theta);
 
    const double refChargeDeposit =
      (leftRefChargeDeposit + rightRefChargeDeposit) / 2.0;
 
    outputWireHits.emplace_back(&hit, refDriftLength, refDriftLengthVariance, refChargeDeposit, driftTime);
  }
 
  std::sort(outputWireHits.begin(), outputWireHits.end());
 
  if (not m_param_useMCParticleIds.empty()) {
    for (const std::pair<int, size_t> nHitsForMCParticleId : nHitsByMCParticleId) {
      B2DEBUG(25,
              "MC particle " << nHitsForMCParticleId.first << " #hits "
              << nHitsForMCParticleId.second);
    }
  }
}

beginEvent()

void beginEvent ( )

overrideinherited

Receive and dispatch signal for the start of a new event.

Definition at line 36 of file CompositeProcessingSignalListener.cc.

{
  Super::beginEvent();
  for (ProcessingSignalListener* psl : m_subordinaryProcessingSignalListeners) {
    psl->beginEvent();
  }
}

beginRun()

void beginRun ( )

finalvirtual

Signal the beginning of a new run.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 205 of file WireHitCreator.cc.

{
  Super::beginRun();
  CDCWireTopology& wireTopology = CDCWireTopology::getInstance();
  wireTopology.reinitialize(m_wirePosition, m_param_ignoreWireSag);
}

endRun()

void endRun ( )

overrideinherited

Receive and dispatch signal for the end of the run.

Definition at line 39 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->endRun();
  }
  Super::endRun();
}

exposeParameters()

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose the parameters to a module.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 42 of file WireHitCreator.cc.

{
  moduleParamList->addParameter(prefixed(prefix, "wirePosition"),
                                m_param_wirePosition,
                                "Set of geometry parameters to be used in the track finding. "
                                "Either 'base', 'misaligned' or 'aligned'.",
                                m_param_wirePosition);
 
  moduleParamList->addParameter(prefixed(prefix, "ignoreWireSag"),
                                m_param_ignoreWireSag,
                                "Assume a wire sag coefficient of zero "
                                "such that the wires appear to be straight for "
                                "the track finders",
                                m_param_ignoreWireSag);
 
  moduleParamList->addParameter(prefixed(prefix, "flightTimeEstimation"),
                                m_param_flightTimeEstimation,
                                "Option which flight direction should be assumed for "
                                "an initial time of flight estimation. Options are: "
                                "'none' (no TOF correction), "
                                "'outwards', "
                                "'downwards'.",
                                m_param_flightTimeEstimation);
 
  moduleParamList->addParameter(prefixed(prefix, "triggerPoint"),
                                m_param_triggerPoint,
                                "Point relative to which the flight times are calculated",
                                m_param_triggerPoint);
 
  moduleParamList->addParameter(prefixed(prefix, "useSuperLayers"),
                                m_param_useSuperLayers,
                                "List of super layers to be used.",
                                m_param_useSuperLayers);
 
  moduleParamList->addParameter(prefixed(prefix, "maxDriftTimes"),
                                m_param_maxDriftTimes,
                                "Maximum drift time (nsec) allowed per super layer (in order of super layer#0-8). Default payload-based cut is applied if this value is negative",
                                m_param_maxDriftTimes);
 
  moduleParamList->addParameter(prefixed(prefix, "useLayers"),
                                m_param_useLayers,
                                "List of layers to be used. "
                                "If a layer number is given in 'ignoreLayers', too, this will result on a B2FATAL. "
                                "Either use 'useLayers' and provide a set of layers to be used, "
                                "or use 'ignoreLayers' and provide a list of layers to be ignored, but not both at the same time.",
                                m_param_useLayers);
 
  moduleParamList->addParameter(prefixed(prefix, "ignoreLayers"),
                                m_param_ignoreLayers,
                                "List of layers to be ignored. "
                                "If a layer number is given in 'useLayers', too, this will result on a B2FATAL. "
                                "Either use 'useLayers' and provide a set of layers to be used, "
                                "or use 'ignoreLayers' and provide a list of layers to be ignored, but not both at the same time.",
                                m_param_ignoreLayers);
 
  moduleParamList->addParameter(prefixed(prefix, "useSecondHits"),
                                m_param_useSecondHits,
                                "Use the second hit information in the track finding.",
                                m_param_useSecondHits);
 
  moduleParamList->addParameter(prefixed(prefix, "useBadWires"),
                                m_param_useBadWires,
                                "Also create the hits that are on bad wires.",
                                m_param_useBadWires);
 
  moduleParamList->addParameter(prefixed(prefix, "useDegreeSector"),
                                m_param_useDegreeSector,
                                "To angles in degrees for which hits should be created - mostly for debugging",
                                m_param_useDegreeSector);
 
  moduleParamList->addParameter(prefixed(prefix, "useMCParticleIds"),
                                m_param_useMCParticleIds,
                                "Ids of the MC particles to use. Default does not look at the MCParticles - most for debugging",
                                m_param_useMCParticleIds);
}

getDescription()

std::string getDescription ( )

finalvirtual

Short description of the findlet.

Reimplemented from Findlet< CDCWireHit >.

Definition at line 36 of file WireHitCreator.cc.

{
  return "Combines the geometrical information and the raw hit information into wire hits, "
         "which can be used from all modules after that";
}

getNProcessingSignalListener()

int getNProcessingSignalListener ( )

protectedinherited

Get the number of currently registered listeners.

Definition at line 56 of file CompositeProcessingSignalListener.cc.

{
  return m_subordinaryProcessingSignalListeners.size();
}

initialize()

void initialize ( )

finalvirtual

Signals the beginning of the event processing.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 118 of file WireHitCreator.cc.

{
  StoreArray<CDCHit> hits;
  hits.isRequired();
 
  // Create the wires and layers once during initialisation
  CDCWireTopology::getInstance();
 
  if (m_param_wirePosition == "base") {
    m_wirePosition = EWirePosition::c_Base;
  } else if (m_param_wirePosition == "misaligned") {
    m_wirePosition = EWirePosition::c_Misaligned;
  } else if (m_param_wirePosition == "aligned") {
    m_wirePosition = EWirePosition::c_Aligned;
  } else {
    B2ERROR("Received unknown wirePosition " << m_param_wirePosition);
  }
 
  m_tdcCountTranslator.reset(new CDC::RealisticTDCCountTranslator);
  m_adcCountTranslator.reset(new CDC::LinearGlobalADCCountTranslator);
 
  if (m_param_flightTimeEstimation != std::string("")) {
    try {
      m_flightTimeEstimation = getPreferredDirection(m_param_flightTimeEstimation);
    } catch (std::invalid_argument& e) {
      B2ERROR("Unexpected 'flightTimeEstimation' parameter : '" << m_param_flightTimeEstimation);
    }
  }
 
  m_triggerPoint = Vector3D(std::get<0>(m_param_triggerPoint),
                            std::get<1>(m_param_triggerPoint),
                            std::get<2>(m_param_triggerPoint));
 
  if (m_flightTimeEstimation == EPreferredDirection::c_Symmetric) {
    B2ERROR("Unexpected 'flightTimeEstimation' parameter : '" << m_param_flightTimeEstimation);
  } else if (m_flightTimeEstimation == EPreferredDirection::c_Downwards) {
    FlightTimeEstimator::instance(std::make_unique<CosmicRayFlightTimeEstimator>(m_triggerPoint));
  } else if (m_flightTimeEstimation == EPreferredDirection::c_Outwards) {
    FlightTimeEstimator::instance(std::make_unique<BeamEventFlightTimeEstimator>());
  }
 
  int nSL = m_param_maxDriftTimes.size();
  for (int iSL = 0; iSL < nSL; ++iSL) {
    m_maxDriftTimes.at(iSL) = m_param_maxDriftTimes.at(iSL);
  }
 
  if (not m_param_useSuperLayers.empty()) {
    for (const ISuperLayer iSL : m_param_useSuperLayers) {
      m_useSuperLayers.at(iSL) = true;
    }
  } else {
    m_useSuperLayers.fill(true);
  }
 
  // Check for common value in the two vectors for using / ignoring layers
  for (const uint useLayer : m_param_useLayers) {
    for (const uint ingoreLayer : m_param_ignoreLayers) {
      if (useLayer == ingoreLayer) {
        B2FATAL("You chose to use and ignore CDC layer " << useLayer << " at the same time. "
                "Please decide to either use or to ignore the layer.");
      }
    }
  }
 
  // fill all layers that should be used
  if (not m_param_useLayers.empty()) {
    for (const uint layer : m_param_useLayers) {
      m_useLayers.at(layer) = true;
    }
  } else {
    m_useLayers.fill(true);
  }
  // set layers that should be ignored to false
  if (not m_param_ignoreLayers.empty()) {
    for (const uint layer : m_param_ignoreLayers) {
      m_useLayers.at(layer) = false;
    }
  }
 
  if (std::isfinite(std::get<0>(m_param_useDegreeSector))) {
    m_useSector[0] = Vector2D::Phi(std::get<0>(m_param_useDegreeSector) * Unit::deg);
    m_useSector[1] = Vector2D::Phi(std::get<1>(m_param_useDegreeSector) * Unit::deg);
  }
 
  Super::initialize();
}

terminate()

void terminate ( )

overrideinherited

Receive and dispatch Signal for termination of the event processing.

Definition at line 42 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->terminate();
  }
  Super::terminate();
}

Member Data Documentation

m_adcCountTranslator

std::unique_ptr<CDC::ADCCountTranslatorBase> m_adcCountTranslator

private

ADC Count translator to be used to calculate the charge deposit in the drift cell.

Definition at line 136 of file WireHitCreator.h.

m_DBCDClayerTimeCut

DBObjPtr<CDClayerTimeCut> m_DBCDClayerTimeCut

private

Cut for approximate drift time (super-layer dependent)

Definition at line 139 of file WireHitCreator.h.

m_flightTimeEstimation

EPreferredDirection m_flightTimeEstimation = EPreferredDirection::c_None

private

Method for the initial time of flight estimation.

Definition at line 117 of file WireHitCreator.h.

m_initialized

bool m_initialized

privateinherited

Flag to keep track whether initialization happened before.

Definition at line 52 of file ProcessingSignalListener.h.

m_initializedAs

std::string m_initializedAs

privateinherited

Name of the type during initialisation.

Definition at line 58 of file ProcessingSignalListener.h.

m_maxDriftTimes

std::array<float, ISuperLayerUtil::c_N> m_maxDriftTimes = { -1, -1, -1, -1, -1, -1, -1, -1, -1}

private

Cut for approximate drift time (super-layer dependent)

Definition at line 114 of file WireHitCreator.h.

{ -1, -1, -1, -1, -1, -1, -1, -1, -1};

m_param_flightTimeEstimation

std::string m_param_flightTimeEstimation = "none"

private

Parameter : Method for the initial time of flight estimation as string.

Definition at line 80 of file WireHitCreator.h.

m_param_ignoreLayers

std::vector<uint> m_param_ignoreLayers

private

Parameter : List of layers to be ignored in tracking e.g. for simulating too high occupancy.

Definition at line 92 of file WireHitCreator.h.

m_param_ignoreWireSag

bool m_param_ignoreWireSag = false

private

Parameter : Switch to deactivate the sag of the wires for the concerns of the track finders.

Definition at line 77 of file WireHitCreator.h.

m_param_maxDriftTimes

std::vector<float> m_param_maxDriftTimes = { -1, -1, -1, -1, -1, -1, -1, -1, -1}

private

Parameter : Cut for approximate drift time (super-layer dependent)

Definition at line 95 of file WireHitCreator.h.

{ -1, -1, -1, -1, -1, -1, -1, -1, -1};

m_param_triggerPoint

std::tuple<double, double, double> m_param_triggerPoint = {0.0, 0.0, 0.0}

private

Parameter : Location of the flight time zero.

Definition at line 83 of file WireHitCreator.h.

{0.0, 0.0, 0.0};

m_param_useBadWires

bool m_param_useBadWires = false

private

Parameter : If true, the hits on bad wires are not ignored.

Definition at line 101 of file WireHitCreator.h.

m_param_useDegreeSector

std::tuple<double, double> m_param_useDegreeSector {INFINITY, INFINITY}

private

Parameter : Angular range in degrees for which hits should be unpacked.

Definition at line 104 of file WireHitCreator.h.

{INFINITY, INFINITY};

m_param_useLayers

std::vector<uint> m_param_useLayers

private

Parameter : List of layers to be used.

Definition at line 89 of file WireHitCreator.h.

m_param_useMCParticleIds

std::vector<int> m_param_useMCParticleIds {}

private

Parameter : Indices of the Monte Carlo particles for which hits should be used.

Definition at line 107 of file WireHitCreator.h.

{};

m_param_useSecondHits

bool m_param_useSecondHits = false

private

Parameter : If true, the second hit information will be used to create Wire Hits.

Definition at line 98 of file WireHitCreator.h.

m_param_useSuperLayers

std::vector<int> m_param_useSuperLayers

private

Parameter : List of super layers to be used - mostly for debugging.

Definition at line 86 of file WireHitCreator.h.

m_param_wirePosition

std::string m_param_wirePosition = "base"

private

Parameter : Geometry set to be used. Either "base", "misalign" or " aligned".

Definition at line 74 of file WireHitCreator.h.

m_subordinaryProcessingSignalListeners

std::vector<ProcessingSignalListener*> m_subordinaryProcessingSignalListeners

privateinherited

References to subordinary signal processing listener contained in this findlet.

Definition at line 60 of file CompositeProcessingSignalListener.h.

m_tdcCountTranslator

std::unique_ptr<CDC::TDCCountTranslatorBase> m_tdcCountTranslator

private

TDC Count translator to be used to calculate the initial dirft length estiamtes.

Definition at line 133 of file WireHitCreator.h.

m_terminated

bool m_terminated

privateinherited

Flag to keep track whether termination happened before.

Definition at line 55 of file ProcessingSignalListener.h.

m_triggerPoint

Vector3D m_triggerPoint = Vector3D(0.0, 0.0, 0.0)

private

Central location of the flight time zero position. Usually the location of the trigger.

Definition at line 120 of file WireHitCreator.h.

m_useLayers

std::array<bool, c_maxNSenseLayers> m_useLayers {}

private

Bits for the used layers.

Definition at line 126 of file WireHitCreator.h.

{};

m_useSector

std::array<Vector2D, 2> m_useSector {}

private

Unit vectors denoting the sector for which hits should be created.

Definition at line 129 of file WireHitCreator.h.

{};

m_useSuperLayers

std::array<bool, ISuperLayerUtil::c_N> m_useSuperLayers {}

private

Bits for the used super layers.

Definition at line 123 of file WireHitCreator.h.

{};

m_wirePosition

EWirePosition m_wirePosition = EWirePosition::c_Base

private

Geometry set to be used.

Definition at line 111 of file WireHitCreator.h.

---

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

• tracking/trackFindingCDC/findlets/minimal/include/WireHitCreator.h
• tracking/trackFindingCDC/findlets/minimal/src/WireHitCreator.cc