EIC code displayed by LXR master/​acts/​Core/​include/​Acts/​Seeding/​SeedFinderOrthogonalConfig.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-10-30 07:53:48

 // This file is part of the ACTS project.
 //
 // Copyright (C) 2016 CERN for the benefit of the ACTS project
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 #pragma once
 
 #include "Acts/Definitions/Units.hpp"
 #include "Acts/Material/Interactions.hpp"
 #include "Acts/Seeding/SeedConfirmationRangeConfig.hpp"
 #include "Acts/Utilities/Delegate.hpp"
 
 #include <cmath>
 #include <memory>
 #include <numbers>
 
 namespace Acts {
 
 // forward declaration to avoid cyclic dependence
 template <typename T>
 class SeedFilter;
 
 /// @brief Structure that holds configuration parameters for the orthogonal seed finder algorithm
 template <typename SpacePoint>
 struct SeedFinderOrthogonalConfig {
   /// Shared pointer to the seed filter for quality assessment
   std::shared_ptr<Acts::SeedFilter<SpacePoint>> seedFilter;
 
   /// Seeding parameters for geometry settings and detector ROI
 
   // Limiting location of all measurements
   float phiMin = -std::numbers::pi_v<float>;
   /// Maximum phi angle for space-point selection
   float phiMax = std::numbers::pi_v<float>;
   /// limiting location of measurements
   float zMin = -2800 * Acts::UnitConstants::mm;
   /// Maximum z coordinate for space-point selection
   float zMax = 2800 * Acts::UnitConstants::mm;
   /// Maximum radius for space-point selection
   float rMax = 600 * Acts::UnitConstants::mm;
   /// @warning If rMin is smaller than impactMax, the bin size will be 2*pi,
   /// which will make seeding very slow!
   float rMin = 33 * Acts::UnitConstants::mm;
 
   /// Seeding parameters used to define the region of interest for middle
   /// space-point
 
   /// Radial range for middle space-point
   /// The range can be defined manually with (rMinMiddle, rMaxMiddle). If
   /// useVariableMiddleSPRange is set to false and the vector rRangeMiddleSP is
   /// empty, we use (rMinMiddle, rMaxMiddle) to cut the middle space-points
   float rMinMiddle = 60.f * Acts::UnitConstants::mm;
   /// Maximum radius for middle space-point selection
   float rMaxMiddle = 120.f * Acts::UnitConstants::mm;
   /// If useVariableMiddleSPRange is set to false, the vector rRangeMiddleSP can
   /// be used to define a fixed r range for each z bin: {{rMin, rMax}, ...}
   bool useVariableMiddleSPRange = true;
   /// Range defined in vector for each z bin
   std::vector<std::vector<float>> rRangeMiddleSP;
   /// If useVariableMiddleSPRange is true, the radial range will be calculated
   /// based on the maximum and minimum r values of the space-points in the event
   /// and a deltaR (deltaRMiddleMinSPRange, deltaRMiddleMaxSPRange)
   float deltaRMiddleMinSPRange = 10. * Acts::UnitConstants::mm;
   /// Maximum delta R for variable middle SP range calculation
   float deltaRMiddleMaxSPRange = 10. * Acts::UnitConstants::mm;
 
   /// Vector containing minimum and maximum z boundaries for cutting middle
   /// space-points
   std::pair<float, float> zOutermostLayers{-2700 * Acts::UnitConstants::mm,
                                            2700 * Acts::UnitConstants::mm};
 
   /// Seeding parameters used to define the cuts on space-point doublets
 
   /// Minimum radial distance between middle-outer doublet components
   float deltaRMinTopSP = std::numeric_limits<float>::quiet_NaN();
   /// Maximum radial distance between middle-outer doublet components
   float deltaRMaxTopSP = std::numeric_limits<float>::quiet_NaN();
   /// Minimum radial distance between inner-middle doublet components
   float deltaRMinBottomSP = std::numeric_limits<float>::quiet_NaN();
   /// Maximum radial distance between inner-middle doublet components
   float deltaRMaxBottomSP = std::numeric_limits<float>::quiet_NaN();
 
   /// Shrink the phi range of middle space-point (analogous to phi bin size in
   /// grid from default seeding + number of phi bins used in search)
   float deltaPhiMax = 0.085;
 
   /// Maximum value of z-distance between space-points in doublet
   float deltaZMax =
       std::numeric_limits<float>::infinity() * Acts::UnitConstants::mm;
 
   /// Maximum allowed cotTheta between two space-points in doublet, used to
   /// check if forward angle is within bounds
   float cotThetaMax = 10.01788;  // equivalent to eta = 3 (pseudorapidity)
 
   /// Limiting location of collision region in z-axis used to check if doublet
   /// origin is within reasonable bounds
   float collisionRegionMin = -150 * Acts::UnitConstants::mm;
   /// Maximum z extent of collision region for doublet validation
   float collisionRegionMax = +150 * Acts::UnitConstants::mm;
 
   /// Enable cut on the compatibility between interaction point and doublet,
   /// this is an useful approximation to speed up the seeding
   bool interactionPointCut = false;
 
   /// Seeding parameters used to define the cuts on space-point triplets
 
   /// Minimum transverse momentum (pT) used to check the r-z slope compatibility
   /// of triplets with maximum multiple scattering effect (produced by the
   /// minimum allowed pT particle) + a certain uncertainty term. Check the
   /// documentation for more information
   /// https://acts.readthedocs.io/en/latest/core/reconstruction/pattern_recognition/seeding.html
   float minPt = 400. * Acts::UnitConstants::MeV;
   /// Number of sigmas of scattering angle to be considered in the minimum pT
   /// scattering term
   float sigmaScattering = 5;
   /// Term that accounts for the thickness of scattering medium in radiation
   /// lengths in the Lynch & Dahl correction to the Highland equation default is
   /// 5%
   /// TODO: necessary to make amount of material dependent on detector region?
   float radLengthPerSeed = 0.05;
   /// Maximum transverse momentum for scattering calculation
   float maxPtScattering = 10 * Acts::UnitConstants::GeV;
   /// Maximum value of impact parameter estimation of the seed candidates
   float impactMax = 20. * Acts::UnitConstants::mm;
   /// Parameter which can loosen the tolerance of the track seed to form a
   /// helix. This is useful for e.g. misaligned seeding.
   float helixCutTolerance = 1.;
 
   /// Seeding parameters used for quality seed confirmation
 
   /// Enable quality seed confirmation, this is different than default seeding
   /// confirmation because it can also be defined for different (r, z) regions
   /// of the detector (e.g. forward or central region) by SeedConfirmationRange.
   /// Seeds are classified as "high-quality" seeds and normal quality seeds.
   /// Normal quality seeds are only selected if no other "high-quality" seeds
   /// has been found for that inner-middle doublet.
   bool seedConfirmation = false;
   /// Contains parameters for central seed confirmation
   SeedConfirmationRangeConfig centralSeedConfirmationRange;
   /// Contains parameters for forward seed confirmation
   SeedConfirmationRangeConfig forwardSeedConfirmationRange;
   /// Maximum number (minus one) of accepted seeds per middle space-point
   unsigned int maxSeedsPerSpM = 5;
 
   /// Other parameters
 
   /// derived values, set on SeedFinder construction
   float highland = 0;
   /// Squared maximum scattering angle for track validation
   float maxScatteringAngle2 = 0;
 
   /// Delegate to apply experiment specific cuts during seeding
   Delegate<bool(float /*bottomRadius*/, float /*cotTheta*/)> experimentCuts{
       DelegateFuncTag<&noopExperimentCuts>{}};
 
   /// defaults experimental cuts to no operation in both seeding algorithms
   /// @return Always returns true (no cuts applied)
   static bool noopExperimentCuts(float /*bottomRadius*/, float /*cotTheta*/) {
     return true;
   }
 
   /// Flag indicating whether configuration uses ACTS internal units
   bool isInInternalUnits = true;
 
   /// Convert to internal units (deprecated, already in internal units)
   /// @return Copy of this configuration (already in internal units)
   //[[deprecated("SeedFinderOrthogonalConfig uses internal units")]]
   SeedFinderOrthogonalConfig toInternalUnits() const { return *this; }
 
   /// Calculate derived quantities from the basic configuration parameters
   /// @return New configuration with derived quantities calculated
   SeedFinderOrthogonalConfig calculateDerivedQuantities() const {
     SeedFinderOrthogonalConfig config = *this;
     config.highland = approximateHighlandScattering(config.radLengthPerSeed);
     config.maxScatteringAngle2 = std::pow(config.highland / config.minPt, 2);
     return config;
   }
 };
 
 }  // namespace Acts

This page was automatically generated by the 2.3.7 LXR engine. The LXR team