Classes
struct	TanhLUT

Public Member Functions
void	initialize ()

void	initializeCollections (std::string hitCollectionName)

void	createIntWeights ()

void	calculateTrackParameters (const CDCTrigger3DHTrack &track)

void	calculateTrackParametersFixedPrecision (const CDCTrigger3DHTrack &track)

void	setEventTime (const CDCTrigger3DHTrack &track)

std::vector< size_t >	load3DHits (const CDCTrigger3DHTrack &track) const

std::vector< float >	getInputVector (const std::vector< size_t > &hitIds) const

std::vector< float >	runMLP (const std::vector< float > &input) const

std::vector< float >	runMLPFixedPrecision (const std::vector< float > &input) const

std::vector< float >	unscaleTarget (const std::vector< float > &target) const

std::vector< float >	scaleTarget (const std::vector< float > &target) const

int	getWeightBits () const

int	getFractionalWeightBits () const

const std::vector< int32_t > &	getIntWeights () const

int	getEventTime () const

void	setNeuroParameters (const NeuroParametersHough &neuroParameters3DH)

void	setMLP (const CDCTrigger3DHMLP &mlp)

const CDCTrigger3DHMLP &	getMLP () const

Private Member Functions
int	getLowestTime (const RelationVector< CDCTriggerSegmentHit > &trackSegmentHits) const

float	getScaledDriftTime (const CDCTriggerSegmentHit &trackSegmentHit, const unsigned short maxTime) const

double	getRelativeID (const CDCTriggerSegmentHit &hit) const

float	scaleRelativeID (const double relativeID, const unsigned superLayerIdx) const

Static Private Member Functions
static constexpr int32_t	extractBits (int64_t value, int high, int low)

Private Attributes
CDCTrigger3DHMLP	m_MLP

std::vector< int32_t >	m_intWeights

int	m_fractionalWeightBits

NeuroParametersHough	m_neuroParameters3DH

StoreArray< CDCTriggerSegmentHit >	m_segmentHits

std::string	m_hitCollectionName

std::array< std::array< double, 2 >, m_nSL >	m_radiusWireLayer {}

std::array< unsigned short, m_nSL+1 >	m_cumulativeWires {}

std::array< unsigned short, m_nSL >	m_nWires {}

double	m_referenceID [m_nSL][2] = {}

double	m_alpha [m_nSL][2] = {}

int	m_T0 = 0

bool	m_hasT0 = false

Static Private Attributes
static constexpr unsigned int	m_nSL = 9

static constexpr unsigned int	m_nStandardInputNodes = 27

static constexpr unsigned int	m_nExtendedInputNodes = 126

static constexpr int	m_precisionPhi = 12

static constexpr int	m_precisionAlpha = 12

static constexpr int	m_precisionScaleFactor = 8

static constexpr int	m_precisionReferenceID = 8

static constexpr int	m_precisionInputs = 13

static constexpr int	m_precisionWeights = 17

Detailed Description

Definition at line 29 of file NeuroTrigger3DH.h.

Member Function Documentation

◆ calculateTrackParameters()

void calculateTrackParameters ( const CDCTrigger3DHTrack & track )

Definition at line 96 of file NeuroTrigger3DH.cc.

{
  const double omega = track.getOmega();
  const double phi = track.getPhi0();
  for (unsigned short superLayerIdx = 0; superLayerIdx < m_nSL; ++superLayerIdx) {
    for (int priorityLayer = 0; priorityLayer < 2; ++priorityLayer) {
      double radiusWireLayer = m_radiusWireLayer[superLayerIdx][priorityLayer];
      double alpha = (radiusWireLayer * std::abs(omega) < 2.0)
                     ? std::asin(radiusWireLayer * omega / 2.0)
                     : M_PI_2;
      double referenceID = (phi - alpha) * m_nWires[superLayerIdx] / (2.0 * M_PI);
      m_alpha[superLayerIdx][priorityLayer] = alpha;
      m_referenceID[superLayerIdx][priorityLayer] = std::remainder(referenceID, m_nWires[superLayerIdx]);
    }
  }
}

◆ calculateTrackParametersFixedPrecision()

void calculateTrackParametersFixedPrecision ( const CDCTrigger3DHTrack & track )

Definition at line 114 of file NeuroTrigger3DH.cc.

{
  const long scalePhi = 1L << m_precisionPhi;
  const long scaleAlpha = 1L << m_precisionAlpha;
  const long scaleFactor = 1L << m_precisionScaleFactor;
  const long scaleID = 1L << m_precisionReferenceID;
 
  const double omega = track.getOmega();
  const long phiFixed = std::round(track.getPhi0() * scalePhi);
 
  for (unsigned short int superLayerIdx = 0; superLayerIdx < m_nSL; ++superLayerIdx) {
    const long scaledWireFactor = std::round((m_nWires[superLayerIdx] / (2.0 * M_PI)) * scaleFactor);
    for (int priorityLayer = 0; priorityLayer < 2; ++priorityLayer) {
      const double radius = m_radiusWireLayer[superLayerIdx][priorityLayer];
      long alphaFixed = (radius * std::abs(omega) < 2.0)
                        ? std::round(std::asin(radius * omega / 2.0) * scaleAlpha)
                        : std::round(M_PI_2 * scaleAlpha);
      long deltaPhi = phiFixed - alphaFixed;
      long refIDFixed = (deltaPhi * scaledWireFactor) / (1L << (m_precisionPhi + m_precisionScaleFactor - m_precisionReferenceID));
      m_alpha[superLayerIdx][priorityLayer] = static_cast<double>(alphaFixed) / scaleAlpha;
      m_referenceID[superLayerIdx][priorityLayer] = static_cast<double>(refIDFixed) / scaleID;
    }
  }
}

◆ createIntWeights()

void createIntWeights ( )

Definition at line 75 of file NeuroTrigger3DH.cc.

{
  const std::vector<float>& floatWeights = m_MLP.getFloatWeights();
  float minFloatWeight = *std::min_element(floatWeights.begin(), floatWeights.end());
  float maxFloatWeight = *std::max_element(floatWeights.begin(), floatWeights.end());
  float maxAbsoluteWeight = std::max(std::abs(minFloatWeight), std::abs(maxFloatWeight));
 
  // Calculate the necessary fractional bit size to not exceed precisionWeights for the weights
  int shift = static_cast<int>(std::ceil(std::log2(maxAbsoluteWeight)));
  int fractionalWeightBits = m_precisionWeights - shift;
 
  // Transform the weights and return the fractional bit size for scaling
  std::vector<int32_t> intWeights(floatWeights.size());
  std::transform(floatWeights.begin(), floatWeights.end(), intWeights.begin(),
  [fractionalWeightBits](float w) { return static_cast<int32_t>(std::round(w * (1 << fractionalWeightBits))); });
 
  m_intWeights = intWeights;
  m_fractionalWeightBits = fractionalWeightBits;
}

◆ extractBits()

static constexpr int32_t extractBits	(	int64_t	value,
		int	high,
		int	low )

inlinestaticconstexprprivate

Definition at line 170 of file NeuroTrigger3DH.h.

    {
      int width = high - low + 1;
      int64_t shifted = value >> low;
      int32_t mask = (1 << width) - 1;
      int32_t result = static_cast<int32_t>(shifted & mask);
      if (result & (1 << (width - 1))) {
        result |= ~mask;
      }
      return result;
    }

◆ getEventTime()

int getEventTime ( ) const

inline

Definition at line 70 of file NeuroTrigger3DH.h.

70{ return m_T0; };

◆ getFractionalWeightBits()

int getFractionalWeightBits ( ) const

inline

Definition at line 66 of file NeuroTrigger3DH.h.

66{ return m_fractionalWeightBits; }

◆ getInputVector()

std::vector< float > getInputVector ( const std::vector< size_t > & hitIds ) const

Definition at line 179 of file NeuroTrigger3DH.cc.

{
  const size_t nInput = m_neuroParameters3DH.nInput;
 
  if (nInput != m_nStandardInputNodes && nInput != m_nExtendedInputNodes) {
    B2FATAL("Invalid neural network input size");
  }
  // Maximal drift time (for scaling), hits with larger values are ignored.
  constexpr unsigned short tMax = 256;
 
  const bool hasExtendedInput = (nInput == m_nExtendedInputNodes);
  const size_t featuresPerHit = nInput / m_nSL;
  const size_t patternSize = 11;
 
  std::vector<float> inputVector(nInput, 0.0f);
  for (const size_t hitIdx : hitIds) {
    const CDCTriggerSegmentHit* trackSegmentHit = m_segmentHits[hitIdx];
    const unsigned short priority = trackSegmentHit->getPriorityPosition();
    const unsigned short superLayerIdx = trackSegmentHit->getISuperLayer();
    const size_t priorityLayer = (priority == 3) ? 0 : 1;
    const size_t baseIdx = featuresPerHit * superLayerIdx;
 
    const float relativeID = scaleRelativeID(getRelativeID(*trackSegmentHit), superLayerIdx);
    const float alpha = m_alpha[superLayerIdx][priorityLayer];
    const float scaledDriftTime = getScaledDriftTime(*trackSegmentHit, tMax);
 
    inputVector[baseIdx] = relativeID;
    inputVector[baseIdx + 1] = scaledDriftTime;
    inputVector[baseIdx + 2] = alpha;
 
    if (m_hasT0 && hasExtendedInput) {
      unsigned int hitPattern = trackSegmentHit->gethitpattern();
      for (size_t j = 0; j < patternSize; ++j) {
        inputVector[baseIdx + 3 + j] = (hitPattern >> j) & 1;
      }
    }
  }
  return inputVector;
}

◆ getIntWeights()

const std::vector< int32_t > & getIntWeights ( ) const

inline

Definition at line 68 of file NeuroTrigger3DH.h.

68{ return m_intWeights; }

◆ getLowestTime()

int getLowestTime ( const RelationVector< CDCTriggerSegmentHit > & trackSegmentHits ) const

private

Definition at line 152 of file NeuroTrigger3DH.cc.

{
  int lowestTime = 9999;
  for (unsigned int hitIdx = 0; hitIdx < trackSegmentHits.size(); ++hitIdx) {
    if (trackSegmentHits.weight(hitIdx) < 0) continue;
    if (trackSegmentHits[hitIdx]->priorityTime() < lowestTime) {
      lowestTime = trackSegmentHits[hitIdx]->priorityTime();
    }
  }
  return lowestTime;
}

◆ getMLP()

const CDCTrigger3DHMLP & getMLP ( ) const

inline

Definition at line 76 of file NeuroTrigger3DH.h.

76{ return m_MLP; };

◆ getRelativeID()

double getRelativeID ( const CDCTriggerSegmentHit & hit ) const

private

Definition at line 220 of file NeuroTrigger3DH.cc.

{
  const int superLayerIdx = trackSegmentHit.getISuperLayer();
  const unsigned int priority = trackSegmentHit.getPriorityPosition();
  const unsigned int priorityLayer = (priority == 3) ? 0 : 1;
  // 0 = no hit, 1 = 2nd right, 2 = 2nd left, 3 = fist priority
  constexpr std::array<short, 4> priorityOffsetFactor = {0, -1, 1, 0};
  double relativeID = trackSegmentHit.getSegmentID()
                      - m_cumulativeWires[superLayerIdx]
                      + 0.5 * priorityOffsetFactor[priority]
                      - m_referenceID[superLayerIdx][priorityLayer];
  return std::remainder(relativeID, m_nWires[superLayerIdx]);
}

◆ getScaledDriftTime()

float getScaledDriftTime	(	const CDCTriggerSegmentHit &	trackSegmentHit,
		const unsigned short	maxTime ) const

private

Definition at line 251 of file NeuroTrigger3DH.cc.

{
  const float scaleT = std::pow(2.0f, std::floor(std::log2(1.0f / maxTime)));
  int driftTime = (m_hasT0) ? trackSegmentHit.priorityTime() - m_T0 : 0;
  driftTime = std::clamp(driftTime, 0, static_cast<int>(maxTime));
  // 0 = no hit, 1 = right, 2 = left, 3 = undetermined
  constexpr std::array<short, 4> leftRightFactor = {0, -1, 1, 0};
  float scaledDriftTime = leftRightFactor[trackSegmentHit.getLeftRight()] * driftTime * scaleT;
  return scaledDriftTime;
}

◆ getWeightBits()

int getWeightBits ( ) const

inline

Definition at line 64 of file NeuroTrigger3DH.h.

64{ return m_precisionWeights; }

◆ initialize()

void initialize ( )

Definition at line 25 of file NeuroTrigger3DH.cc.

{
  std::array<std::vector<int>, m_nSL> getWireLayerID;
 
  int layer = 0;
  // First superlayer (8 layers)
  for (int i = 0; i < 8; ++i) {
    getWireLayerID[0].push_back(layer++);
  }
  // Remaining superlayers (6 layers each)
  for (unsigned short superLayerIdx = 1; superLayerIdx < m_nSL; ++superLayerIdx) {
    for (int i = 0; i < 6; ++i) {
      getWireLayerID[superLayerIdx].push_back(layer++);
    }
  }
 
  const CDC::CDCGeometryPar& cdc = CDC::CDCGeometryPar::Instance();
 
  for (unsigned short superLayerIdx = 0; superLayerIdx < m_nSL; ++superLayerIdx) {
    if (superLayerIdx == 0) {
      m_radiusWireLayer[superLayerIdx][0] = cdc.senseWireR(getWireLayerID[superLayerIdx][3]);
      m_radiusWireLayer[superLayerIdx][1] = cdc.senseWireR(getWireLayerID[superLayerIdx][4]);
    } else {
      m_radiusWireLayer[superLayerIdx][0] = cdc.senseWireR(getWireLayerID[superLayerIdx][2]);
      m_radiusWireLayer[superLayerIdx][1] = cdc.senseWireR(getWireLayerID[superLayerIdx][3]);
    }
    m_nWires[superLayerIdx] = cdc.nWiresInLayer(getWireLayerID[superLayerIdx][0]);
  }
 
  m_cumulativeWires[0] = 0;
  for (unsigned short superLayerIdx = 1; superLayerIdx <= m_nSL; ++superLayerIdx) {
    m_cumulativeWires[superLayerIdx] = m_cumulativeWires[superLayerIdx - 1] + m_nWires[superLayerIdx - 1];
  }
}

◆ initializeCollections()

void initializeCollections ( std::string hitCollectionName )

Definition at line 61 of file NeuroTrigger3DH.cc.

{
  m_segmentHits.isRequired(hitCollectionName);
  m_hitCollectionName = hitCollectionName;
}

◆ load3DHits()

std::vector< size_t > load3DHits ( const CDCTrigger3DHTrack & track ) const

Definition at line 165 of file NeuroTrigger3DH.cc.

{
  RelationVector<CDCTriggerSegmentHit> trackSegmentHits =
    track.getRelationsTo<CDCTriggerSegmentHit>(m_hitCollectionName);
  std::vector<size_t> allHitIDs;
  for (size_t hitIdx = 0; hitIdx < trackSegmentHits.size(); ++hitIdx) {
    if (trackSegmentHits.weight(hitIdx) >= 0) {  // Ignore hits with negative relation weight
      allHitIDs.push_back(trackSegmentHits[hitIdx]->getArrayIndex());
    }
  }
  return allHitIDs;
}

◆ runMLP()

std::vector< float > runMLP ( const std::vector< float > & input ) const

Definition at line 263 of file NeuroTrigger3DH.cc.

{
  const CDCTrigger3DHMLP& network = m_MLP;
  const std::vector<float>& weights = network.getFloatWeights();
 
  std::vector<float> layerInput = input;
  std::vector<float> layerOutput;
  size_t weightIndex = 0;
 
  const size_t nLayers = network.getNumberOfLayers();
  for (size_t layerIdx = 1; layerIdx < nLayers; ++layerIdx) {
    layerInput.push_back(1.0f); // add bias
    const size_t nInputs = layerInput.size();
    const size_t nOutputs = network.getNumberOfNodes(layerIdx);
    layerOutput.assign(nOutputs, 0.0f); // create new empty output vector
    for (size_t outIdx = 0; outIdx < nOutputs; ++outIdx) {
      for (size_t inputIdx = 0; inputIdx < nInputs; ++inputIdx) {
        layerOutput[outIdx] += layerInput[inputIdx] * weights[weightIndex++];
      }
      layerOutput[outIdx] = std::tanh(layerOutput[outIdx]);
    }
    layerInput = layerOutput;
  }
  return unscaleTarget(layerOutput);
}

◆ runMLPFixedPrecision()

std::vector< float > runMLPFixedPrecision ( const std::vector< float > & input ) const

Definition at line 290 of file NeuroTrigger3DH.cc.

{
  const CDCTrigger3DHMLP& network = m_MLP;
  const int fractionalInputBits = m_precisionInputs - 1;
 
  // Transform the input floats (range [-2, 2]) to m_precisionInputs bit integers
  std::vector<int32_t> layerInput(input.size());
  std::transform(input.begin(), input.end(), layerInput.begin(),
  [](float i) { return static_cast<int32_t>(std::round(i * (1 << fractionalInputBits))); });
 
  std::vector<int32_t> layerOutput;
  size_t weightIndex = 0;
  const size_t nLayers = network.getNumberOfLayers();
  for (size_t layerIdx = 1; layerIdx < nLayers; ++layerIdx) {
    // Set bias input and scaling shift (different precisions for network inputs and tanh outputs possible)
    unsigned int scalingShift;
    if (layerIdx == 1) {
      layerInput.push_back(1 << fractionalInputBits);
      scalingShift = fractionalInputBits + m_fractionalWeightBits - TanhLUT::LUT_FRAC_BITS;
    } else {
      layerInput.push_back(1 << TanhLUT::LUT_FRAC_BITS);
      scalingShift = TanhLUT::LUT_FRAC_BITS + m_fractionalWeightBits - TanhLUT::LUT_FRAC_BITS;
    }
    const size_t nOutputs = network.getNumberOfNodes(layerIdx);
    const size_t nInputs = layerInput.size();
    layerOutput.assign(nOutputs, 0);
    for (size_t outIdx = 0; outIdx < nOutputs; ++outIdx) {
      int64_t mulAccSum = 0;
      for (size_t inputIdx = 0; inputIdx < nInputs; ++inputIdx) {
        mulAccSum += static_cast<int64_t>(layerInput[inputIdx]) * static_cast<int64_t>(m_intWeights[weightIndex++]);
      }
      int mulAccSumSign = (mulAccSum < 0) ? -1 : 1;
 
      // Cutting a LUT_FRAC_BITS + MAX_FLOAT_SHIFT + HEADROOM_BITS + 1 window from the DSP
      // This is equivalent to uint32_t lutInput = static_cast<uint32_t>(std::abs(mulAccSum) >> scalingShift);
      const int high = scalingShift + TanhLUT::LUT_FRAC_BITS + TanhLUT::MAX_FLOAT_SHIFT + TanhLUT::HEADROOM_BITS;
      const int low = scalingShift;
      uint32_t lutInput = static_cast<uint32_t>(std::abs(extractBits(mulAccSum, high, low)));
 
      int32_t outFix;
      if (lutInput >= TanhLUT::LUT_SATURATION) {
        outFix = static_cast<int32_t>(mulAccSumSign * ((1 << TanhLUT::LUT_FRAC_BITS) - 1));
      } else {
        // This is just a scaling shift (equivalent to lutInput >> MAX_FLOAT_SHIFT if LUT_FRAC_BITS == LUT_INDEX_BITS)
        size_t lutIdx = static_cast<size_t>((lutInput * TanhLUT::LUT_SIZE) / TanhLUT::LUT_SATURATION);
        int32_t lutVal = TanhLUT::get(lutIdx);
        outFix = static_cast<int32_t>(mulAccSumSign * lutVal);
      }
      layerOutput[outIdx] = outFix;
    }
    layerInput = layerOutput;
  }
  // Convert back to float and unscale
  std::vector<float> output(layerOutput.size(), 0.0f);
  std::transform(layerOutput.begin(), layerOutput.end(), output.begin(),
  [](int32_t val) { return val / static_cast<float>(1 << TanhLUT::LUT_FRAC_BITS); });
  return unscaleTarget(output);
}

◆ scaleRelativeID()

float scaleRelativeID	(	const double	relativeID,
		const unsigned	superLayerIdx ) const

private

Definition at line 235 of file NeuroTrigger3DH.cc.

{
  // Relevant ID ranges for each super layer (2x9)
  constexpr std::array<float, 18> relevantID =
  {-1.5, 1.5, -7.5, -0.5, -1.5, 1.5, 0.5, 7.5, -1.5, 1.5, -8.5, 0.5, -2.5, 1.5, -0.5, 10.5, -3.5, 2.5};
  const float idMin = relevantID[2 * superLayerIdx];
  const float idMax = relevantID[2 * superLayerIdx + 1];
  const float range = idMax - idMin;
  float scale = 2.0f / range;
  // Round down to nearest power of 2 for FPGA implementation
  scale = std::pow(2.0f, std::floor(std::log2(scale)));
  const float offset = (idMin + idMax) * 0.5f;
  return scale * static_cast<float>(relativeID - offset);
}

◆ scaleTarget()

std::vector< float > scaleTarget ( const std::vector< float > & target ) const

Definition at line 367 of file NeuroTrigger3DH.cc.

{
  std::vector<float> scaled(target.size());
  for (size_t i = 0; i < target.size(); ++i) {
    float min = m_neuroParameters3DH.outputScale[2 * i];
    float max = m_neuroParameters3DH.outputScale[2 * i + 1];
    if (i == 1) {
      min *= Unit::deg;
      max *= Unit::deg;
    }
    float range = max - min;
    scaled[i] = 2.0f * (target[i] - min) / range - 1.0f;
  }
  return scaled;
}

◆ setEventTime()

void setEventTime ( const CDCTrigger3DHTrack & track )

Definition at line 140 of file NeuroTrigger3DH.cc.

{
  m_T0 = getLowestTime(track.getRelationsTo<CDCTriggerSegmentHit>(m_hitCollectionName));
  if (m_T0 < 9999) {
    m_hasT0 = true;
  } else {
    m_T0 = 0;
    m_hasT0 = false;
  }
}

◆ setMLP()

void setMLP ( const CDCTrigger3DHMLP & mlp )

Definition at line 68 of file NeuroTrigger3DH.cc.

{
  m_MLP = mlp;
  m_neuroParameters3DH = mlp.getNeuroParameters();
}

◆ setNeuroParameters()

void setNeuroParameters ( const NeuroParametersHough & neuroParameters3DH )

inline

Definition at line 72 of file NeuroTrigger3DH.h.

72{ m_neuroParameters3DH = neuroParameters3DH; };

◆ unscaleTarget()

std::vector< float > unscaleTarget ( const std::vector< float > & target ) const

Definition at line 350 of file NeuroTrigger3DH.cc.

{
  std::vector<float> unscaled(target.size());
  for (size_t i = 0; i < target.size(); ++i) {
    float min = m_neuroParameters3DH.outputScale[2 * i];
    float max = m_neuroParameters3DH.outputScale[2 * i + 1];
    if (i == 1) {
      min *= Unit::deg;
      max *= Unit::deg;
    }
    float range = max - min;
    unscaled[i] = (target[i] + 1.0f) * range * 0.5f + min;
  }
  return unscaled;
}

Member Data Documentation

◆ m_alpha

double m_alpha[m_nSL][2] = {}

private

Definition at line 112 of file NeuroTrigger3DH.h.

112{};

◆ m_cumulativeWires

std::array< unsigned short, m_nSL + 1 > m_cumulativeWires {}

private

Definition at line 106 of file NeuroTrigger3DH.h.

106{};

◆ m_fractionalWeightBits

int m_fractionalWeightBits

private

Definition at line 93 of file NeuroTrigger3DH.h.

◆ m_hasT0

bool m_hasT0 = false

private

Definition at line 116 of file NeuroTrigger3DH.h.

◆ m_hitCollectionName

std::string m_hitCollectionName

private

Definition at line 99 of file NeuroTrigger3DH.h.

◆ m_intWeights

std::vector<int32_t> m_intWeights

private

Definition at line 91 of file NeuroTrigger3DH.h.

◆ m_MLP

CDCTrigger3DHMLP m_MLP

private

Definition at line 89 of file NeuroTrigger3DH.h.

◆ m_neuroParameters3DH

NeuroParametersHough m_neuroParameters3DH

private

Definition at line 95 of file NeuroTrigger3DH.h.

◆ m_nExtendedInputNodes

unsigned int m_nExtendedInputNodes = 126

staticconstexprprivate

Definition at line 120 of file NeuroTrigger3DH.h.

◆ m_nSL

unsigned int m_nSL = 9

staticconstexprprivate

Definition at line 102 of file NeuroTrigger3DH.h.

◆ m_nStandardInputNodes

unsigned int m_nStandardInputNodes = 27

staticconstexprprivate

Definition at line 119 of file NeuroTrigger3DH.h.

◆ m_nWires

std::array<unsigned short, m_nSL> m_nWires {}

private

Definition at line 108 of file NeuroTrigger3DH.h.

108{};

◆ m_precisionAlpha

int m_precisionAlpha = 12

staticconstexprprivate

Definition at line 124 of file NeuroTrigger3DH.h.

◆ m_precisionInputs

int m_precisionInputs = 13

staticconstexprprivate

Definition at line 129 of file NeuroTrigger3DH.h.

◆ m_precisionPhi

int m_precisionPhi = 12

staticconstexprprivate

Definition at line 123 of file NeuroTrigger3DH.h.

◆ m_precisionReferenceID

int m_precisionReferenceID = 8

staticconstexprprivate

Definition at line 126 of file NeuroTrigger3DH.h.

◆ m_precisionScaleFactor

int m_precisionScaleFactor = 8

staticconstexprprivate

Definition at line 125 of file NeuroTrigger3DH.h.

◆ m_precisionWeights

int m_precisionWeights = 17

staticconstexprprivate

Definition at line 130 of file NeuroTrigger3DH.h.

◆ m_radiusWireLayer

std::array<std::array<double, 2>, m_nSL> m_radiusWireLayer {}

private

Definition at line 104 of file NeuroTrigger3DH.h.

104{};

◆ m_referenceID

double m_referenceID[m_nSL][2] = {}

private

Definition at line 110 of file NeuroTrigger3DH.h.

110{};

◆ m_segmentHits

StoreArray<CDCTriggerSegmentHit> m_segmentHits

private

Definition at line 97 of file NeuroTrigger3DH.h.

◆ m_T0

int m_T0 = 0

private

Definition at line 114 of file NeuroTrigger3DH.h.

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

trg/cdc/include/NeuroTrigger3DH.h
trg/cdc/src/NeuroTrigger3DH.cc

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Function Documentation

◆ calculateTrackParameters()

◆ calculateTrackParametersFixedPrecision()

◆ createIntWeights()

◆ extractBits()

◆ getEventTime()

◆ getFractionalWeightBits()

◆ getInputVector()

◆ getIntWeights()

◆ getLowestTime()

◆ getMLP()

◆ getRelativeID()

◆ getScaledDriftTime()

◆ getWeightBits()

◆ initialize()

◆ initializeCollections()

◆ load3DHits()

◆ runMLP()

◆ runMLPFixedPrecision()

◆ scaleRelativeID()

◆ scaleTarget()

◆ setEventTime()

◆ setMLP()

◆ setNeuroParameters()

◆ unscaleTarget()

Member Data Documentation

◆ m_alpha

◆ m_cumulativeWires

◆ m_fractionalWeightBits

◆ m_hasT0

◆ m_hitCollectionName

◆ m_intWeights

◆ m_MLP

◆ m_neuroParameters3DH

◆ m_nExtendedInputNodes

◆ m_nSL

◆ m_nStandardInputNodes

◆ m_nWires

◆ m_precisionAlpha

◆ m_precisionInputs

◆ m_precisionPhi

◆ m_precisionReferenceID

◆ m_precisionScaleFactor

◆ m_precisionWeights

◆ m_radiusWireLayer

◆ m_referenceID

◆ m_segmentHits

◆ m_T0