from pathlib import Path

from typing import Optional, Union, List

from enum import Enum

from collections import namedtuple

import acts

import acts.examples

# ROOT might not be available

try:

from acts.examples.root import (

RootTrackFinderNTupleWriter,

RootTrackFinderPerformanceWriter,

RootTrackFitterPerformanceWriter,

RootTrackParameterWriter,

RootTrackStatesWriter,

RootTrackSummaryWriter,

RootVertexNTupleWriter,

)

ACTS_EXAMPLES_ROOT_AVAILABLE = True

except ImportError:

ACTS_EXAMPLES_ROOT_AVAILABLE = False

u = acts.UnitConstants

SeedingAlgorithm = Enum(

"SeedingAlgorithm",

"TruthSmeared TruthEstimated HoughTransform AdaptiveHoughTransform Gbts Hashing GridTriplet OrthogonalTriplet HashingPrototype",

)

TrackSmearingSigmas = namedtuple(

"TrackSmearingSigmas",

[

"loc0",

"loc0PtA",

"loc0PtB",

"loc1",

"loc1PtA",

"loc1PtB",

"time",

"phi",

"theta",

"ptRel",

],

defaults=[None] * 10,

)

SeedFinderConfigArg = namedtuple(

"SeedFinderConfig",

[

"maxSeedsPerSpM",

"cotThetaMax",

"sigmaScattering",

"radLengthPerSeed",

"minPt",

"impactMax",

"deltaPhiMax",

"interactionPointCut",

"deltaZMax",

"maxPtScattering",

"zBinEdges",

"zBinsCustomLooping",

"rRangeMiddleSP",

"useVariableMiddleSPRange",

"binSizeR",

"seedConfirmation",

"centralSeedConfirmationRange",

"forwardSeedConfirmationRange",

"rMinMiddle",

"rMaxMiddle",

"deltaR", # (min,max)

"deltaRBottomSP", # (min,max)

"deltaRTopSP", # (min,max)

"deltaRMiddleSPRange", # (min,max)

"collisionRegion", # (min,max)

"r", # (min,max)

"z", # (min,max)

],

defaults=[None] * 20 + [(None, None)] * 7,

)

SeedFinderOptionsArg = namedtuple(

"SeedFinderOptions", ["beamPos", "bFieldInZ"], defaults=[(None, None), None]

)

SeedFilterConfigArg = namedtuple(

"SeedFilterConfig",

[

"impactWeightFactor",

"zOriginWeightFactor",

"compatSeedWeight",

"compatSeedLimit",

"numSeedIncrement",

"seedWeightIncrement",

"seedConfirmation",

"maxSeedsPerSpMConf",

"maxQualitySeedsPerSpMConf",

"useDeltaRorTopRadius",

"deltaRMin",

],

defaults=[None] * 11,

)

SpacePointGridConfigArg = namedtuple(

"SeedGridConfig",

[

"rMax",

"zBinEdges",

"phiBinDeflectionCoverage",

"impactMax",

"deltaRMax",

"maxPhiBins",

"phi", # (min,max)

],

defaults=[None] * 6 + [(None, None)] * 1,

)

SeedingAlgorithmConfigArg = namedtuple(

"SeedingAlgorithmConfig",

[

"allowSeparateRMax",

"zBinNeighborsTop",

"zBinNeighborsBottom",

"numPhiNeighbors",

"useExtraCuts",

],

defaults=[None] * 5,

)

TruthEstimatedSeedingAlgorithmConfigArg = namedtuple(

"TruthSeederConfig",

[

"deltaR", # (min,max)

],

defaults=[(None, None)],

)

TrackSelectorConfig = namedtuple(

"TrackSelectorConfig",

[

"loc0",

"loc1",

"time",

"eta",

"absEta",

"pt",

"phi",

"nMeasurementsMin",

"maxHoles",

"maxOutliers",

"maxHolesAndOutliers",

"maxSharedHits",

"maxChi2",

"nMeasurementsGroupMin",

"requireReferenceSurface",

],

defaults=[(None, None)] * 7 + [None] * 8,

)

def trackSelectorDefaultKWArgs(c):

"""

Encapsulate this boilerplate code into a function so different uses do not get out of sync

"""

return acts.examples.defaultKWArgs(

loc0Min=c.loc0[0],

loc0Max=c.loc0[1],

loc1Min=c.loc1[0],

loc1Max=c.loc1[1],

timeMin=c.time[0],

timeMax=c.time[1],

phiMin=c.phi[0],

phiMax=c.phi[1],

etaMin=c.eta[0],

etaMax=c.eta[1],

absEtaMin=c.absEta[0],

absEtaMax=c.absEta[1],

ptMin=c.pt[0],

ptMax=c.pt[1],

minMeasurements=c.nMeasurementsMin,

maxHoles=c.maxHoles,

maxOutliers=c.maxOutliers,

maxHolesAndOutliers=c.maxHolesAndOutliers,

maxSharedHits=c.maxSharedHits,

maxChi2=c.maxChi2,

measurementCounter=c.nMeasurementsGroupMin,

requireReferenceSurface=c.requireReferenceSurface,

)

CkfConfig = namedtuple(

"CkfConfig",

[

"chi2CutOffMeasurement",

"chi2CutOffOutlier",

"numMeasurementsCutOff",

"maxSteps",

"seedDeduplication",

"stayOnSeed",

"pixelVolumes",

"stripVolumes",

"maxPixelHoles",

"maxStripHoles",

"trimTracks",

"useJosephFormulation",

"constrainToVolumes",

"endOfWorldVolumes",

],

defaults=[

15.0,

25.0,

10,

None,

None,

None,

None,

None,

None,

None,

None,

False,

None,

None,

],

)

AmbiguityResolutionConfig = namedtuple(

"AmbiguityResolutionConfig",

["maximumSharedHits", "nMeasurementsMin", "maximumIterations"],

defaults=[None] * 3,

)

ScoreBasedAmbiguityResolutionConfig = namedtuple(

"ScoreBasedAmbiguityResolutionConfig",

[

"minScore",

"minScoreSharedTracks",

"maxShared",

"minUnshared",

"maxSharedTracksPerMeasurement",

"useAmbiguityScoring",

],

defaults=[None] * 6,

)

AmbiguityResolutionMLConfig = namedtuple(

"AmbiguityResolutionMLConfig",

["maximumSharedHits", "nMeasurementsMin", "maximumIterations"],

defaults=[None] * 3,

)

SeedFilterMLDBScanConfig = namedtuple(

"SeedFilterMLDBScanConfig",

["epsilonDBScan", "minPointsDBScan", "minSeedScore"],

defaults=[None] * 3,

)

HashingTrainingConfigArg = namedtuple(

"HashingTrainingConfig",

["annoySeed", "f"],

defaults=[None] * 2,

)

HashingAlgorithmConfigArg = namedtuple(

"HashingAlgorithmConfig",

["bucketSize", "zBins", "phiBins"],

defaults=[None] * 3,

)

class VertexFinder(Enum):

Truth = (1,)

AMVF = (2,)

Iterative = (3,)

@acts.examples.NamedTypeArgs(

seedingAlgorithm=SeedingAlgorithm,

trackSmearingSigmas=TrackSmearingSigmas,

seedFinderConfigArg=SeedFinderConfigArg,

seedFinderOptionsArg=SeedFinderOptionsArg,

seedFilterConfigArg=SeedFilterConfigArg,

spacePointGridConfigArg=SpacePointGridConfigArg,

seedingAlgorithmConfigArg=SeedingAlgorithmConfigArg,

hashingTrainingConfigArg=HashingTrainingConfigArg,

hashingAlgorithmConfigArg=HashingAlgorithmConfigArg,

truthEstimatedSeedingAlgorithmConfigArg=TruthEstimatedSeedingAlgorithmConfigArg,

logLevel=acts.logging.Level,

)

def addSeeding(

s: acts.examples.Sequencer,

trackingGeometry: acts.TrackingGeometry,

field: acts.MagneticFieldProvider,

geoSelectionConfigFile: Optional[Union[Path, str]] = None,

stripGeoSelectionConfigFile: Optional[Union[Path, str]] = None,

layerMappingConfigFile: Optional[Union[Path, str]] = None,

connectorInputConfigFile: Optional[Union[Path, str]] = None,

lutInputConfigFile: Optional[Union[Path, str]] = None,

seedingAlgorithm: SeedingAlgorithm = SeedingAlgorithm.GridTriplet,

trackSmearingSigmas: TrackSmearingSigmas = TrackSmearingSigmas(),

initialSigmas: Optional[list] = None,

initialSigmaQoverPt: Optional[float] = None,

initialSigmaPtRel: Optional[float] = None,

initialVarInflation: Optional[list] = None,

seedFinderConfigArg: SeedFinderConfigArg = SeedFinderConfigArg(),

seedFinderOptionsArg: SeedFinderOptionsArg = SeedFinderOptionsArg(),

seedFilterConfigArg: SeedFilterConfigArg = SeedFilterConfigArg(),

spacePointGridConfigArg: SpacePointGridConfigArg = SpacePointGridConfigArg(),

seedingAlgorithmConfigArg: SeedingAlgorithmConfigArg = SeedingAlgorithmConfigArg(),

houghTransformConfig: acts.examples.HoughTransformSeeder.Config = acts.examples.HoughTransformSeeder.Config(),

adaptiveHoughTransformConfig: Optional[

acts.examples.AdaptiveHoughTransformSeeder.Config

] = None,

hashingTrainingConfigArg: Optional[

HashingTrainingConfigArg

] = HashingTrainingConfigArg(),

hashingAlgorithmConfigArg: Optional[

HashingAlgorithmConfigArg

] = HashingAlgorithmConfigArg(),

truthEstimatedSeedingAlgorithmConfigArg: TruthEstimatedSeedingAlgorithmConfigArg = TruthEstimatedSeedingAlgorithmConfigArg(),

particleHypothesis: Optional[

acts.ParticleHypothesis

] = acts.ParticleHypothesis.pion,

inputParticles: str = "particles",

selectedParticles: str = "particles_selected",

outputDirRoot: Optional[Union[Path, str]] = None,

outputDirCsv: Optional[Union[Path, str]] = None,

logLevel: Optional[acts.logging.Level] = None,

rnd: Optional[acts.examples.RandomNumbers] = None,

prefix: str = "",

) -> None:

"""This function steers the seeding

Parameters

----------

s: Sequencer

the sequencer module to which we add the Seeding steps (returned from addSeeding)

trackingGeometry : tracking geometry

field : magnetic field

geoSelectionConfigFile : Path|str, path, None

Json file for space point geometry selection. Not required for SeedingAlgorithm.TruthSmeared.

stripGeoSelectionConfigFile : Path|str, path, None

Json file for space point geometry selection in strips. Needed for SpacePoint making.

seedingAlgorithm : SeedingAlgorithm, Default

seeding algorithm to use: one of Default (no truth information used), TruthSmeared, TruthEstimated

trackSmearingSigmas : TrackSmearingSigmas(loc0, loc0PtA, loc0PtB, loc1, loc1PtA, loc1PtB, time, phi, theta, ptRel)

TrackSmearing configuration.

Defaults specified in Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/TrackParameterSmearing.hpp

initialSigmas : list

Sets the initial covariance matrix diagonal. This is ignored in case of TruthSmearing.

Defaults specified in Examples/Algorithms/TrackFinding/include/ActsExamples/TrackFinding/TrackParamsEstimationAlgorithm.hpp

initialVarInflation : list

List of 6 scale factors to inflate the initial covariance matrix

Defaults (all 1) specified in Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/TrackParameterSmearing.hpp

seedFinderConfigArg : SeedFinderConfigArg(maxSeedsPerSpM, cotThetaMax, sigmaScattering, radLengthPerSeed, minPt, impactMax, deltaPhiMax, interactionPointCut, deltaZMax, maxPtScattering, zBinEdges, zBinsCustomLooping, rRangeMiddleSP, useVariableMiddleSPRange, binSizeR, seedConfirmation, centralSeedConfirmationRange, forwardSeedConfirmationRange, deltaR, deltaRBottomSP, deltaRTopSP, deltaRMiddleSPRange, collisionRegion, r, z)

SeedFinderConfig settings. deltaR, deltaRBottomSP, deltaRTopSP, deltaRMiddleSPRange, collisionRegion, r, z.

Defaults specified in Core/include/Acts/Seeding/SeedFinderConfig.hpp

seedFinderOptionsArg : SeedFinderOptionsArg(bFieldInZ, beamPos)

Defaults specified in Core/include/Acts/Seeding/SeedFinderConfig.hpp

seedFilterConfigArg : SeedFilterConfigArg(compatSeedWeight, compatSeedLimit, numSeedIncrement, seedWeightIncrement, seedConfirmation, maxSeedsPerSpMConf, maxQualitySeedsPerSpMConf, useDeltaRorTopRadius)

Defaults specified in Core/include/Acts/Seeding/SeedFilterConfig.hpp

spacePointGridConfigArg : SpacePointGridConfigArg(rMax, zBinEdges, phiBinDeflectionCoverage, phi, maxPhiBins, impactMax)

SpacePointGridConfigArg settings. phi is specified as a tuple of (min,max).

Defaults specified in Core/include/Acts/Seeding/SpacePointGrid.hpp

seedingAlgorithmConfigArg : SeedingAlgorithmConfigArg(allowSeparateRMax, zBinNeighborsTop, zBinNeighborsBottom, numPhiNeighbors, useExtraCuts)

Defaults specified in Examples/Algorithms/TrackFinding/include/ActsExamples/TrackFinding/SeedingAlgorithm.hpp

hashingTrainingConfigArg : HashingTrainingConfigArg(annoySeed, f)

Defaults specified in Examples/Algorithms/TrackFinding/include/ActsExamples/TrackFinding/HashingPrototypeSeedingAlgorithm.hpp

hashingAlgorithmConfigArg : HashingAlgorithmConfigArg(bucketSize, zBins, phiBins)

Defaults specified in Examples/Algorithms/TrackFinding/include/ActsExamples/TrackFinding/HashingPrototypeSeedingAlgorithm.hpp

truthEstimatedSeedingAlgorithmConfigArg : TruthEstimatedSeedingAlgorithmConfigArg(deltaR)

Currently only deltaR=(min,max) range specified here.

particleHypothesis : Optional[acts.ParticleHypothesis]

The hypothesis used for track finding. Defaults to pion.

inputParticles : str, "particles"

input particles name in the WhiteBoard

selectedParticles : str, "particles_selected"

selected particles name in the WhiteBoard

outputDirRoot : Path|str, path, None

the output folder for ROOT output, None triggers no output

logLevel : acts.logging.Level, None

logging level to override setting given in `s`

rnd : RandomNumbers, None

random number generator. Only used by SeedingAlgorithm.TruthSmeared.

"""

logLevel = acts.examples.defaultLogging(s, logLevel)()

logger = acts.getDefaultLogger("addSeeding", logLevel)

# Create starting parameters from either particle smearing or combined seed

# finding and track parameters estimation

if seedingAlgorithm == SeedingAlgorithm.TruthSmeared:

logger.info("Using smeared truth particles for seeding")

addTruthSmearedSeeding(

s=s,

rnd=rnd,

selectedParticles=selectedParticles,

trackSmearingSigmas=trackSmearingSigmas,

initialSigmas=initialSigmas,

initialSigmaQoverPt=initialSigmaQoverPt,

initialSigmaPtRel=initialSigmaPtRel,

initialVarInflation=initialVarInflation,

particleHypothesis=particleHypothesis,

logLevel=logLevel,

)

else:

spacePoints = addSpacePointsMaking(

s,

trackingGeometry,

geoSelectionConfigFile,

stripGeoSelectionConfigFile,

logLevel,

prefix=prefix,

)

seeds = None

perSeedParticleHypothesis = None

# Run either: truth track finding or seeding

if seedingAlgorithm == SeedingAlgorithm.TruthEstimated:

logger.info("Using truth track finding from space points for seeding")

seeds, perSeedParticleHypothesis = addTruthEstimatedSeeding(

s,

spacePoints,

selectedParticles,

truthEstimatedSeedingAlgorithmConfigArg,

particleHypothesis=particleHypothesis,

logLevel=logLevel,

)

elif seedingAlgorithm == SeedingAlgorithm.HoughTransform:

logger.info("Using Hough Transform seeding")

houghTransformConfig.inputSpacePoints = [spacePoints]

houghTransformConfig.inputMeasurements = "measurements"

houghTransformConfig.outputProtoTracks = "protoTracks"

houghTransformConfig.outputSeeds = "seeds"

houghTransformConfig.trackingGeometry = trackingGeometry

seeds = addHoughTransformSeeding(s, houghTransformConfig, logLevel)

elif seedingAlgorithm == SeedingAlgorithm.AdaptiveHoughTransform:

logger.info("Using Adaptive Hough Transform seeding")

adaptiveHoughTransformConfig.inputSpacePoints = [spacePoints]

adaptiveHoughTransformConfig.outputProtoTracks = "protoTracks"

adaptiveHoughTransformConfig.outputSeeds = "seeds"

adaptiveHoughTransformConfig.trackingGeometry = trackingGeometry

adaptiveHoughTransformConfig.threshold = 4

adaptiveHoughTransformConfig.noiseThreshold = 12

adaptiveHoughTransformConfig.phiMinBinSize = 3.14 / (2.0 * 257.0)

adaptiveHoughTransformConfig.qOverPtMinBinSize = 1.1 / (2.0 * 257.0)

adaptiveHoughTransformConfig.qOverPtMin = 1.1

adaptiveHoughTransformConfig.doSecondPhase = True

adaptiveHoughTransformConfig.zMinBinSize = 1 * u.mm

adaptiveHoughTransformConfig.cotThetaMinBinSize = 0.1

adaptiveHoughTransformConfig.deduplicate = True

seeds = addAdaptiveHoughTransformSeeding(

s, adaptiveHoughTransformConfig, logLevel=logLevel

)

elif seedingAlgorithm == SeedingAlgorithm.Gbts:

logger.info("Using Gbts seeding")

# output of algs changed, only one output now

seeds = addGbtsSeeding(

s,

spacePoints,

seedFinderConfigArg,

trackingGeometry,

logLevel,

layerMappingConfigFile,

connectorInputConfigFile,

lutInputConfigFile,

)

elif seedingAlgorithm == SeedingAlgorithm.HashingPrototype:

logger.info("Using Hashing seeding")

seeds, buckets = addHashingSeeding(

s,

spacePoints,

seedingAlgorithmConfigArg,

seedFinderConfigArg,

seedFinderOptionsArg,

seedFilterConfigArg,

hashingTrainingConfigArg,

hashingAlgorithmConfigArg,

logLevel,

)

elif seedingAlgorithm == SeedingAlgorithm.GridTriplet:

logger.info("Using grid triplet seeding")

seeds = addGridTripletSeeding(

s,

spacePoints,

seedingAlgorithmConfigArg,

seedFinderConfigArg,

seedFinderOptionsArg,

seedFilterConfigArg,

spacePointGridConfigArg,

logLevel,

outputSeeds=f"{prefix}seeds",

)

elif seedingAlgorithm == SeedingAlgorithm.OrthogonalTriplet:

logger.info("Using orthogonal triplet seeding")

seeds = addOrthogonalTripletSeeding(

s,

spacePoints,

seedingAlgorithmConfigArg,

seedFinderConfigArg,

seedFinderOptionsArg,

seedFilterConfigArg,

spacePointGridConfigArg,

logLevel,

outputSeeds=f"{prefix}seeds",

)

else:

logger.fatal("unknown seedingAlgorithm {}", seedingAlgorithm)

parEstimateAlg = acts.examples.TrackParamsEstimationAlgorithm(

level=logLevel,

inputSeeds=seeds,

inputParticleHypotheses=perSeedParticleHypothesis,

outputTrackParameters=f"{prefix}estimatedparameters",

outputSeeds=f"{prefix}estimatedseeds",

trackingGeometry=trackingGeometry,

magneticField=field,

**acts.examples.defaultKWArgs(

initialSigmas=initialSigmas,

initialSigmaQoverPt=initialSigmaQoverPt,

initialSigmaPtRel=initialSigmaPtRel,

initialVarInflation=initialVarInflation,

particleHypothesis=particleHypothesis,

),

)

s.addAlgorithm(parEstimateAlg)

protoTracks = f"{prefix}seed-protoTracks"

s.addAlgorithm(

acts.examples.SeedsToProtoTracks(

level=logLevel,

inputSeeds=f"{prefix}estimatedseeds",

outputProtoTracks=protoTracks,

)

)

tracks = f"{prefix}seed-tracks"

s.addAlgorithm(

acts.examples.ProtoTracksToTracks(

level=logLevel,

inputProtoTracks=protoTracks,

inputTrackParameters=f"{prefix}estimatedparameters",

inputMeasurements=f"{prefix}measurement_subset",

outputTracks=tracks,

)

)

s.addAlgorithm(

acts.examples.TrackTruthMatcher(

level=logLevel,

inputTracks=tracks,

inputParticles=selectedParticles,

inputMeasurementParticlesMap="measurement_particles_map",

outputTrackParticleMatching=f"{prefix}seed_particle_matching",

outputParticleTrackMatching=f"{prefix}particle_seed_matching",

matchingRatio=1.0,

doubleMatching=False,

)

)

if outputDirRoot is not None:

addSeedPerformanceWriters(

s,

outputDirRoot,

tracks,

protoTracks,

selectedParticles,

inputParticles,

parEstimateAlg.config.outputTrackParameters,

logLevel,

prefix=prefix,

)

if outputDirCsv is not None:

outputDirCsv = Path(outputDirCsv)

if not outputDirCsv.exists():

outputDirCsv.mkdir()

csvSeedWriter = acts.examples.CsvSeedWriter(

level=logLevel,

inputTrackParameters=parEstimateAlg.config.outputTrackParameters,

inputSeeds=seeds,

inputSimHits="simhits",

inputMeasurementParticlesMap="measurement_particles_map",

inputMeasurementSimHitsMap="measurement_simhits_map",

outputDir=str(outputDirCsv),

fileName=str(f"seed.csv"),

)

s.addWriter(csvSeedWriter)

return s

def addTruthSmearedSeeding(

s: acts.examples.Sequencer,

rnd: Optional[acts.examples.RandomNumbers],

selectedParticles: str,

trackSmearingSigmas: TrackSmearingSigmas,

initialSigmas: Optional[List[float]],

initialSigmaQoverPt: Optional[float],

initialSigmaPtRel: Optional[float],

initialVarInflation: Optional[List[float]],

particleHypothesis: Optional[acts.ParticleHypothesis],

logLevel: acts.logging.Level = None,

):

"""adds algorithm that would mimic detector response uncertainties for truth seeding

For parameters description see addSeeding

"""

rnd = rnd or acts.examples.RandomNumbers(seed=42)

trkParamExtractor = acts.examples.ParticleTrackParamExtractor(

level=logLevel,

inputParticles=selectedParticles,

outputTrackParameters="trueparameters",

)

s.addAlgorithm(trkParamExtractor)

# Smearing track parameters

trkSmear = acts.examples.TrackParameterSmearing(

level=logLevel,

inputTrackParameters=trkParamExtractor.config.outputTrackParameters,

outputTrackParameters="estimatedparameters",

randomNumbers=rnd,

# gaussian sigmas to smear particle parameters

**acts.examples.defaultKWArgs(

sigmaLoc0=trackSmearingSigmas.loc0,

sigmaLoc0PtA=trackSmearingSigmas.loc0PtA,

sigmaLoc0PtB=trackSmearingSigmas.loc0PtB,

sigmaLoc1=trackSmearingSigmas.loc1,

sigmaLoc1PtA=trackSmearingSigmas.loc1PtA,

sigmaLoc1PtB=trackSmearingSigmas.loc1PtB,

sigmaTime=trackSmearingSigmas.time,

sigmaPhi=trackSmearingSigmas.phi,

sigmaTheta=trackSmearingSigmas.theta,

sigmaPtRel=trackSmearingSigmas.ptRel,

initialSigmas=initialSigmas,

initialSigmaQoverPt=initialSigmaQoverPt,

initialSigmaPtRel=initialSigmaPtRel,

initialVarInflation=initialVarInflation,

particleHypothesis=particleHypothesis,

),

)

s.addAlgorithm(trkSmear)

truthTrkFndAlg = acts.examples.TruthTrackFinder(

level=logLevel,

inputParticles=selectedParticles,

inputMeasurements="measurements",

inputParticleMeasurementsMap="particle_measurements_map",

inputSimHits="simhits",

inputMeasurementSimHitsMap="measurement_simhits_map",

outputProtoTracks="truth_particle_tracks",

)

s.addAlgorithm(truthTrkFndAlg)

def addTruthEstimatedSeeding(

sequence: acts.examples.Sequencer,

spacePoints: str,

inputParticles: str,

TruthEstimatedSeedingAlgorithmConfigArg: TruthEstimatedSeedingAlgorithmConfigArg,

particleHypothesis: Optional[acts.ParticleHypothesis] = None,

logLevel: acts.logging.Level = None,

):

"""adds truth seeding

For parameters description see addSeeding

"""

logLevel = acts.examples.defaultLogging(sequence, logLevel)()

truthSeeding = acts.examples.TruthSeedingAlgorithm(

level=logLevel,

inputParticles=inputParticles,

inputParticleMeasurementsMap="particle_measurements_map",

inputSpacePoints=spacePoints,

inputSimHits="simhits",

inputMeasurementSimHitsMap="measurement_simhits_map",

outputParticles="truth_seeded_particles",

outputProtoTracks="truth_particle_tracks",

outputSeeds="seeds",

outputParticleHypotheses="seed_particle_hypotheses",

**acts.examples.defaultKWArgs(

deltaRMin=TruthEstimatedSeedingAlgorithmConfigArg.deltaR[0],

deltaRMax=TruthEstimatedSeedingAlgorithmConfigArg.deltaR[1],

particleHypothesis=particleHypothesis,

),

)

sequence.addAlgorithm(truthSeeding)

return truthSeeding.config.outputSeeds, truthSeeding.config.outputParticleHypotheses

def addSpacePointsMaking(

sequence: acts.examples.Sequencer,

trackingGeometry: acts.TrackingGeometry,

geoSelectionConfigFile: Union[Path, str],

stripGeoSelectionConfigFile: Union[Path, str],

logLevel: acts.logging.Level = None,

prefix: str = "",

):

"""adds space points making

For parameters description see addSeeding

"""

logLevel = acts.examples.defaultLogging(sequence, logLevel)()

spAlg = acts.examples.SpacePointMaker(

level=logLevel,

inputMeasurements=f"{prefix}measurement_subset",

outputSpacePoints=f"{prefix}spacepoints",

trackingGeometry=trackingGeometry,

geometrySelection=acts.examples.json.readJsonGeometryList(

str(geoSelectionConfigFile)

),

stripGeometrySelection=(

acts.examples.json.readJsonGeometryList(str(stripGeoSelectionConfigFile))

if stripGeoSelectionConfigFile

else []

),

)

sequence.addAlgorithm(spAlg)

return spAlg.config.outputSpacePoints

def addStandardSeeding(

sequence: acts.examples.Sequencer,

spacePoints: str,

seedingAlgorithmConfigArg: SeedingAlgorithmConfigArg,

seedFinderConfigArg: SeedFinderConfigArg,

seedFinderOptionsArg: SeedFinderOptionsArg,

seedFilterConfigArg: SeedFilterConfigArg,

spacePointGridConfigArg: SpacePointGridConfigArg,

logLevel: acts.logging.Level = None,

outputSeeds: str = "seeds",

):

"""adds standard seeding

For parameters description see addSeeding

"""

logLevel = acts.examples.defaultLogging(sequence, logLevel)()

seedFinderConfig = acts.examples.SeedFinderConfig(

**acts.examples.defaultKWArgs(

rMin=seedFinderConfigArg.r[0],

rMax=seedFinderConfigArg.r[1],

deltaRMin=seedFinderConfigArg.deltaR[0],

deltaRMax=seedFinderConfigArg.deltaR[1],

deltaRMinTopSP=(

seedFinderConfigArg.deltaR[0]

if seedFinderConfigArg.deltaRTopSP[0] is None

else seedFinderConfigArg.deltaRTopSP[0]

),

deltaRMaxTopSP=(

seedFinderConfigArg.deltaR[1]

if seedFinderConfigArg.deltaRTopSP[1] is None

else seedFinderConfigArg.deltaRTopSP[1]

),

deltaRMinBottomSP=(

seedFinderConfigArg.deltaR[0]

if seedFinderConfigArg.deltaRBottomSP[0] is None

else seedFinderConfigArg.deltaRBottomSP[0]

),

deltaRMaxBottomSP=(

seedFinderConfigArg.deltaR[1]

if seedFinderConfigArg.deltaRBottomSP[1] is None

else seedFinderConfigArg.deltaRBottomSP[1]

),

deltaRMiddleMinSPRange=seedFinderConfigArg.deltaRMiddleSPRange[0],

deltaRMiddleMaxSPRange=seedFinderConfigArg.deltaRMiddleSPRange[1],

collisionRegionMin=seedFinderConfigArg.collisionRegion[0],

collisionRegionMax=seedFinderConfigArg.collisionRegion[1],

zMin=seedFinderConfigArg.z[0],

zMax=seedFinderConfigArg.z[1],

maxSeedsPerSpM=seedFinderConfigArg.maxSeedsPerSpM,

cotThetaMax=seedFinderConfigArg.cotThetaMax,

sigmaScattering=seedFinderConfigArg.sigmaScattering,

radLengthPerSeed=seedFinderConfigArg.radLengthPerSeed,

minPt=seedFinderConfigArg.minPt,

impactMax=seedFinderConfigArg.impactMax,

interactionPointCut=seedFinderConfigArg.interactionPointCut,

deltaZMax=seedFinderConfigArg.deltaZMax,

maxPtScattering=seedFinderConfigArg.maxPtScattering,

zBinEdges=seedFinderConfigArg.zBinEdges,

zBinsCustomLooping=seedFinderConfigArg.zBinsCustomLooping,

rRangeMiddleSP=seedFinderConfigArg.rRangeMiddleSP,

useVariableMiddleSPRange=seedFinderConfigArg.useVariableMiddleSPRange,

binSizeR=seedFinderConfigArg.binSizeR,

seedConfirmation=seedFinderConfigArg.seedConfirmation,

centralSeedConfirmationRange=seedFinderConfigArg.centralSeedConfirmationRange,

forwardSeedConfirmationRange=seedFinderConfigArg.forwardSeedConfirmationRange,

),

)

seedFinderOptions = acts.SeedFinderOptions(

**acts.examples.defaultKWArgs(

beamPos=(

acts.Vector2(0.0, 0.0)

if seedFinderOptionsArg.beamPos == (None, None)

else acts.Vector2(

seedFinderOptionsArg.beamPos[0], seedFinderOptionsArg.beamPos[1]

)

),

bFieldInZ=seedFinderOptionsArg.bFieldInZ,

)

)

seedFilterConfig = acts.SeedFilterConfig(

**acts.examples.defaultKWArgs(

maxSeedsPerSpM=seedFinderConfig.maxSeedsPerSpM,

deltaRMin=(

seedFinderConfig.deltaRMin

if seedFilterConfigArg.deltaRMin is None

else seedFilterConfigArg.deltaRMin

),

impactWeightFactor=seedFilterConfigArg.impactWeightFactor,

zOriginWeightFactor=seedFilterConfigArg.zOriginWeightFactor,

compatSeedWeight=seedFilterConfigArg.compatSeedWeight,

compatSeedLimit=seedFilterConfigArg.compatSeedLimit,

numSeedIncrement=seedFilterConfigArg.numSeedIncrement,

seedWeightIncrement=seedFilterConfigArg.seedWeightIncrement,

seedConfirmation=seedFilterConfigArg.seedConfirmation,

centralSeedConfirmationRange=seedFinderConfig.centralSeedConfirmationRange,

forwardSeedConfirmationRange=seedFinderConfig.forwardSeedConfirmationRange,

maxSeedsPerSpMConf=seedFilterConfigArg.maxSeedsPerSpMConf,

maxQualitySeedsPerSpMConf=seedFilterConfigArg.maxQualitySeedsPerSpMConf,

useDeltaRorTopRadius=seedFilterConfigArg.useDeltaRorTopRadius,

)

)

gridConfig = acts.SpacePointGridConfig(

**acts.examples.defaultKWArgs(

minPt=seedFinderConfig.minPt,

rMax=(

seedFinderConfig.rMax

if spacePointGridConfigArg.rMax is None

else spacePointGridConfigArg.rMax

),

zMax=seedFinderConfig.zMax,

zMin=seedFinderConfig.zMin,

deltaRMax=(

seedFinderConfig.deltaRMax

if spacePointGridConfigArg.deltaRMax is None

else spacePointGridConfigArg.deltaRMax

),

cotThetaMax=seedFinderConfig.cotThetaMax,

phiMin=spacePointGridConfigArg.phi[0],

phiMax=spacePointGridConfigArg.phi[1],

maxPhiBins=spacePointGridConfigArg.maxPhiBins,

impactMax=spacePointGridConfigArg.impactMax,

zBinEdges=spacePointGridConfigArg.zBinEdges,

phiBinDeflectionCoverage=spacePointGridConfigArg.phiBinDeflectionCoverage,

)

)

gridOptions = acts.SpacePointGridOptions(

**acts.examples.defaultKWArgs(

bFieldInZ=seedFinderOptions.bFieldInZ,

)

)

seedingAlg = acts.examples.SeedingAlgorithm(

level=logLevel,

inputSpacePoints=spacePoints,

outputSeeds=outputSeeds,

**acts.examples.defaultKWArgs(

allowSeparateRMax=seedingAlgorithmConfigArg.allowSeparateRMax,

zBinNeighborsTop=seedingAlgorithmConfigArg.zBinNeighborsTop,

zBinNeighborsBottom=seedingAlgorithmConfigArg.zBinNeighborsBottom,

numPhiNeighbors=seedingAlgorithmConfigArg.numPhiNeighbors,

useExtraCuts=seedingAlgorithmConfigArg.useExtraCuts,

),

gridConfig=gridConfig,

gridOptions=gridOptions,

seedFilterConfig=seedFilterConfig,

seedFinderConfig=seedFinderConfig,

seedFinderOptions=seedFinderOptions,

)

sequence.addAlgorithm(seedingAlg)

return seedingAlg.config.outputSeeds

def addGridTripletSeeding(

sequence: acts.examples.Sequencer,

spacePoints: str,

seedingAlgorithmConfigArg: SeedingAlgorithmConfigArg,

seedFinderConfigArg: SeedFinderConfigArg,

seedFinderOptionsArg: SeedFinderOptionsArg,

seedFilterConfigArg: SeedFilterConfigArg,

spacePointGridConfigArg: SpacePointGridConfigArg,

logLevel: acts.logging.Level = None,

outputSeeds: str = "seeds",

):

"""adds grid triplet seeding

For parameters description see addSeeding

"""

logLevel = acts.examples.defaultLogging(sequence, logLevel)()

seedingAlg = acts.examples.GridTripletSeedingAlgorithm(

level=logLevel,

inputSpacePoints=spacePoints,

outputSeeds=outputSeeds,

**acts.examples.defaultKWArgs(

bFieldInZ=seedFinderOptionsArg.bFieldInZ,

minPt=seedFinderConfigArg.minPt,

cotThetaMax=seedFinderConfigArg.cotThetaMax,

impactMax=seedFinderConfigArg.impactMax,

deltaRMin=seedFinderConfigArg.deltaR[0],

deltaRMax=seedFinderConfigArg.deltaR[1],

deltaRMinTop=(

seedFinderConfigArg.deltaR[0]

if seedFinderConfigArg.deltaRTopSP[0] is None

else seedFinderConfigArg.deltaRTopSP[0]

),

deltaRMaxTop=(

seedFinderConfigArg.deltaR[1]

if seedFinderConfigArg.deltaRTopSP[1] is None

else seedFinderConfigArg.deltaRTopSP[1]

),

deltaRMinBottom=(

seedFinderConfigArg.deltaR[0]

if seedFinderConfigArg.deltaRBottomSP[0] is None

else seedFinderConfigArg.deltaRBottomSP[0]

),

deltaRMaxBottom=(

seedFinderConfigArg.deltaR[1]

if seedFinderConfigArg.deltaRBottomSP[1] is None

else seedFinderConfigArg.deltaRBottomSP[1]

),

rMin=seedFinderConfigArg.r[0],

rMax=seedFinderConfigArg.r[1],

zMin=seedFinderConfigArg.z[0],

zMax=seedFinderConfigArg.z[1],

phiMin=spacePointGridConfigArg.phi[0],

phiMax=spacePointGridConfigArg.phi[1],

phiBinDeflectionCoverage=spacePointGridConfigArg.phiBinDeflectionCoverage,

maxPhiBins=spacePointGridConfigArg.maxPhiBins,

zBinEdges=spacePointGridConfigArg.zBinEdges,

zBinsCustomLooping=seedFinderConfigArg.zBinsCustomLooping,

rMinMiddle=seedFinderConfigArg.rMinMiddle,

rMaxMiddle=seedFinderConfigArg.rMaxMiddle,

useVariableMiddleSPRange=seedFinderConfigArg.useVariableMiddleSPRange,

rRangeMiddleSP=seedFinderConfigArg.rRangeMiddleSP,

deltaRMiddleMinSPRange=seedFinderConfigArg.deltaRMiddleSPRange[0],

deltaRMiddleMaxSPRange=seedFinderConfigArg.deltaRMiddleSPRange[1],

deltaZMin=None,

deltaZMax=None,

interactionPointCut=seedFinderConfigArg.interactionPointCut,

collisionRegionMin=seedFinderConfigArg.collisionRegion[0],

collisionRegionMax=seedFinderConfigArg.collisionRegion[1],

helixCutTolerance=None,

sigmaScattering=seedFinderConfigArg.sigmaScattering,

radLengthPerSeed=seedFinderConfigArg.radLengthPerSeed,

toleranceParam=None,

deltaInvHelixDiameter=None,

compatSeedWeight=seedFilterConfigArg.compatSeedWeight,

impactWeightFactor=seedFilterConfigArg.impactWeightFactor,

zOriginWeightFactor=seedFilterConfigArg.zOriginWeightFactor,

maxSeedsPerSpM=seedFinderConfigArg.maxSeedsPerSpM,

compatSeedLimit=seedFilterConfigArg.compatSeedLimit,

seedWeightIncrement=seedFilterConfigArg.seedWeightIncrement,

numSeedIncrement=seedFilterConfigArg.numSeedIncrement,

seedConfirmation=seedFinderConfigArg.seedConfirmation,

centralSeedConfirmationRange=seedFinderConfigArg.centralSeedConfirmationRange,

forwardSeedConfirmationRange=seedFinderConfigArg.forwardSeedConfirmationRange,

maxSeedsPerSpMConf=seedFilterConfigArg.maxSeedsPerSpMConf,

maxQualitySeedsPerSpMConf=seedFilterConfigArg.maxQualitySeedsPerSpMConf,

useDeltaRinsteadOfTopRadius=seedFilterConfigArg.useDeltaRorTopRadius,

useExtraCuts=seedingAlgorithmConfigArg.useExtraCuts,

),

)

sequence.addAlgorithm(seedingAlg)

return seedingAlg.config.outputSeeds

def addOrthogonalTripletSeeding(

sequence: acts.examples.Sequencer,

spacePoints: str,

seedingAlgorithmConfigArg: SeedingAlgorithmConfigArg,

seedFinderConfigArg: SeedFinderConfigArg,

seedFinderOptionsArg: SeedFinderOptionsArg,

seedFilterConfigArg: SeedFilterConfigArg,

spacePointGridConfigArg: SpacePointGridConfigArg,

logLevel: acts.logging.Level = None,

outputSeeds: str = "seeds",

):

"""adds orthogonal triplet seeding

For parameters description see addSeeding

"""

logLevel = acts.examples.defaultLogging(sequence, logLevel)()

seedingAlg = acts.examples.OrthogonalTripletSeedingAlgorithm(

level=logLevel,

inputSpacePoints=spacePoints,

outputSeeds=outputSeeds,

**acts.examples.defaultKWArgs(

bFieldInZ=seedFinderOptionsArg.bFieldInZ,

minPt=seedFinderConfigArg.minPt,

cotThetaMax=seedFinderConfigArg.cotThetaMax,

impactMax=seedFinderConfigArg.impactMax,

deltaRMin=seedFinderConfigArg.deltaR[0],

deltaRMax=seedFinderConfigArg.deltaR[1],

deltaRMinTop=(

seedFinderConfigArg.deltaR[0]

if seedFinderConfigArg.deltaRTopSP[0] is None