MuonML::BucketGraphUtils Namespace Reference

Classes
struct	NodeAux

Functions
double	bucket_size_mm (const MuonR4::SpacePointBucket &b)
bool	keepBucketAsTrainingNode (const MuonR4::SpacePointBucket &b)
	bucket_size == 0, where bucket_size is bucket_max - bucket_min.
void	buildNodesAndFeatures (const MuonR4::SpacePointContainer &buckets, const ActsTrk::GeometryContext &gctx, std::vector< NodeAux > &nodes, std::vector< float > &featuresLeaves, std::vector< int64_t > &spInBucket)
	Build nodes + flat features (N,6) and number of SPs per kept bucket.
void	buildSparseEdges (const std::vector< NodeAux > &nodes, int minLayers, int maxChamberDelta, int maxSectorDelta, double maxDistXY, double maxAbsDz, std::vector< int64_t > &srcEdges, std::vector< int64_t > &dstEdges)
size_t	packEdgeIndex (const std::vector< int64_t > &srcEdges, const std::vector< int64_t > &dstEdges, std::vector< int64_t > &edgeIndexPacked)

Function Documentation

bucket_size_mm()

double MuonML::BucketGraphUtils::bucket_size_mm ( const MuonR4::SpacePointBucket & b )

inline

Definition at line 31 of file BucketGraphUtils.h.

                                                              {
  return b.coveredMax() - b.coveredMin();
}

buildNodesAndFeatures()

void MuonML::BucketGraphUtils::buildNodesAndFeatures ( const MuonR4::SpacePointContainer & buckets, const ActsTrk::GeometryContext & gctx, std::vector< NodeAux > & nodes, std::vector< float > & featuresLeaves, std::vector< int64_t > & spInBucket )

inline

Build nodes + flat features (N,6) and number of SPs per kept bucket.

• Features: [x, y, z, layers, nSp, bucketSize]

In cas that the data vectors have been used by an earlier ML algorithm ensure that the vectors remain clean

Definition at line 46 of file BucketGraphUtils.h.

{
  nodes.clear();
  featuresLeaves.clear();
  spInBucket.clear();
  nodes.reserve(buckets.size());
  featuresLeaves.reserve(6u * buckets.size());   // preallocate
  spInBucket.reserve(buckets.size());
 
  MuonR4::SpacePointPerLayerSorter layerSorter{};
 
  for (const MuonR4::SpacePointBucket* bucket : buckets) {
    const double bsize = bucket_size_mm(*bucket);
    
    if (!keepBucketAsTrainingNode(*bucket)) {
      continue;
    }
  
    NodeAux n;
 
    const double midY = 0.5 * (bucket->coveredMin() + bucket->coveredMax());
    const Amg::Vector3D glob = bucket->msSector()->localToGlobalTransform(gctx) * (midY * Amg::Vector3D::UnitY());
    n.x = glob.x();
    n.y = glob.y();
    n.z = glob.z();
 
    std::unordered_set<unsigned int> laySet;
    laySet.reserve(bucket->size());
    for (const auto& spPtr : *bucket) {
      laySet.insert(layerSorter.sectorLayerNum(*spPtr));
    }
    n.layers     = static_cast<int>(laySet.size());
    n.nSp        = static_cast<int>(bucket->size());
    n.bucketSize = bsize;
    n.sector     = bucket->msSector()->sector();
    n.chamber    = Acts::toUnderlying(bucket->msSector()->chamberIndex());
 
    nodes.push_back(n);
 
    featuresLeaves.push_back(static_cast<float>(n.x));
    featuresLeaves.push_back(static_cast<float>(n.y));
    featuresLeaves.push_back(static_cast<float>(n.z));
    featuresLeaves.push_back(static_cast<float>(n.layers));
    featuresLeaves.push_back(static_cast<float>(n.nSp));
    featuresLeaves.push_back(static_cast<float>(n.bucketSize));
 
    spInBucket.emplace_back(static_cast<int64_t>(n.nSp));  // store as int64_t
  }
}

buildSparseEdges()

void MuonML::BucketGraphUtils::buildSparseEdges ( const std::vector< NodeAux > & nodes, int minLayers, int maxChamberDelta, int maxSectorDelta, double maxDistXY, double maxAbsDz, std::vector< int64_t > & srcEdges, std::vector< int64_t > & dstEdges )

inline

Ensure that previously built graphs don't leak memory

Definition at line 101 of file BucketGraphUtils.h.

{
  srcEdges.clear();
  dstEdges.clear();
 
  std::vector<size_t> validIdx;
  validIdx.reserve(nodes.size());
  for (size_t i = 0; i < nodes.size(); ++i) {
    if (nodes[i].layers >= minLayers) validIdx.push_back(i);
  }
 
  if (validIdx.size() < 2) {
    if (!nodes.empty()) {
      srcEdges.push_back(0);
      dstEdges.push_back(0);
    }
    return;
  }
 
  const unsigned int secMax = Muon::MuonStationIndex::numberOfSectors();
 
  for (size_t a = 0; a < validIdx.size(); ++a) {
    const size_t i = validIdx[a];
    const auto& ni = nodes[i];
    for (size_t b = a + 1; b < validIdx.size(); ++b) {
      const size_t j = validIdx[b];
      const auto& nj = nodes[j];
 
      const double dx = static_cast<double>(ni.x) - static_cast<double>(nj.x);
      const double dy = static_cast<double>(ni.y) - static_cast<double>(nj.y);
      const double dz = static_cast<double>(ni.z) - static_cast<double>(nj.z);
 
      const double distXY  = Acts::fastHypot(dx, dy);
      const int secDiffLin = std::abs(ni.sector - nj.sector) % static_cast<int>(secMax);
      const int d_sec      = std::min(secDiffLin, static_cast<int>(secMax) - secDiffLin);
      const int d_ch       = std::abs(ni.chamber - nj.chamber);
 
      const bool mask =
        (d_ch > 0) &&
        (d_sec <= maxSectorDelta) &&
        (distXY < maxDistXY) &&
        (std::abs(dz) < maxAbsDz) &&
        (d_ch <= maxChamberDelta);
 
      if (mask) {
        srcEdges.push_back(static_cast<int64_t>(i));
        dstEdges.push_back(static_cast<int64_t>(j));
        srcEdges.push_back(static_cast<int64_t>(j));
        dstEdges.push_back(static_cast<int64_t>(i));
      }
    }
  }
 
  if (srcEdges.empty() && !nodes.empty()) {
    srcEdges.push_back(0);
    dstEdges.push_back(0);
  }
}

keepBucketAsTrainingNode()

bool MuonML::BucketGraphUtils::keepBucketAsTrainingNode ( const MuonR4::SpacePointBucket & b )

inline

bucket_size == 0, where bucket_size is bucket_max - bucket_min.

Definition at line 38 of file BucketGraphUtils.h.

                                                                      {
  return bucket_size_mm(b) != 0.0;
}

packEdgeIndex()

size_t MuonML::BucketGraphUtils::packEdgeIndex ( const std::vector< int64_t > & srcEdges, const std::vector< int64_t > & dstEdges, std::vector< int64_t > & edgeIndexPacked )

inline

Definition at line 168 of file BucketGraphUtils.h.

{
  const size_t E = srcEdges.size();
  edgeIndexPacked = srcEdges;
  edgeIndexPacked.insert(edgeIndexPacked.end(), dstEdges.begin(), dstEdges.end());
  return E;
}