import os

import sys

import math

from pathlib import Path

from typing import Optional

import acts

import acts.examples

import acts.tgeo

from acts import root

import warnings

def getOpenDataDetectorDirectory():

odd_dir = os.environ.get("ODD_PATH")

if odd_dir is None:

raise RuntimeError("ODD_PATH environment variable not set")

odd_dir = Path(odd_dir)

return odd_dir

def getOpenDataDetector(

materialDecorator=None,

misaligned=False,

odd_dir: Optional[Path] = None,

logLevel=acts.logging.INFO,

gen3=False,

constructionMethod=None,

):

"""This function sets up the open data detector. Requires DD4hep.

Parameters

----------

materialDecorator: Material Decorator, take RootMaterialDecorator if non is given

odd_dir: if not given, try to get via ODD_PATH environment variable

logLevel: logging level

constructionMethod: Gen3 conversion method enum value of

OpenDataDetector.Config.ConstructionMethod

use `ConstructionMethod.TGeo` for the TGeo-backed Gen3 path

"""

import acts.examples.dd4hep

customLogLevel = acts.examples.defaultLogging(logLevel=logLevel)

if odd_dir is None:

odd_dir = getOpenDataDetectorDirectory()

if not odd_dir.exists():

raise RuntimeError(f"OpenDataDetector not found at {odd_dir}")

odd_xml = odd_dir / "xml" / "OpenDataDetector.xml"

if not odd_xml.exists():

raise RuntimeError(f"OpenDataDetector.xml not found at {odd_xml}")

env_vars = []

map_name = "libOpenDataDetector.components"

lib_name = None

if sys.platform == "linux":

env_vars = ["LD_LIBRARY_PATH"]

lib_name = "libOpenDataDetector.so"

elif sys.platform == "darwin":

env_vars = ["DYLD_LIBRARY_PATH", "DD4HEP_LIBRARY_PATH"]

lib_name = "libOpenDataDetector.dylib"

if lib_name is not None and len(env_vars) > 0:

found = False

for env_var in env_vars:

for lib_dir in os.environ.get(env_var, "").split(":"):

lib_dir = Path(lib_dir)

if (lib_dir / map_name).exists() and (lib_dir / lib_name).exists():

found = True

break

if not found:

msg = (

"Unable to find OpenDataDetector factory library. "

f"You might need to point {'/'.join(env_vars)} to the ODD install location."

f"It might be at {odd_dir / 'factory'}"

)

raise RuntimeError(msg)

if materialDecorator is None:

materialDecorator = acts.root.RootMaterialDecorator(

fileName=str(odd_dir / "data/odd-material-maps.root"),

level=customLogLevel(minLevel=acts.logging.WARNING),

)

if gen3:

if misaligned:

raise InvalidArgumentError(

"Gen3 ODD currently does not support misalignment"

)

oddConfig = acts.examples.dd4hep.OpenDataDetector.Config(

xmlFileNames=[str(odd_xml)],

name="OpenDataDetector",

logLevel=customLogLevel(),

dd4hepLogLevel=customLogLevel(minLevel=acts.logging.WARNING),

)

if constructionMethod is not None:

oddConfig.constructionMethod = constructionMethod

# Use default constructed geometry context. This will have to change if DD4hep gains alignment awareness.

gctx = acts.GeometryContext.dangerouslyDefaultConstruct()

with warnings.catch_warnings():

warnings.simplefilter("ignore")

detector = acts.examples.dd4hep.OpenDataDetector(

config=oddConfig, gctx=gctx

)

return detector

else:

volumeRadiusCutsMap = {

28: [850.0], # LStrip negative z

30: [850.0], # LStrip positive z

23: [400.0, 550.0], # SStrip negative z

25: [400.0, 550.0], # SStrip positive z

16: [100.0], # Pixels negative z

18: [100.0], # Pixels positive z

}

def geoid_hook(geoid, surface):

gctx = acts.GeometryContext.dangerouslyDefaultConstruct()

if geoid.volume in volumeRadiusCutsMap:

r = math.sqrt(

surface.center(gctx)[0] ** 2 + surface.center(gctx)[1] ** 2

)

geoid.extra = 1

for cut in volumeRadiusCutsMap[geoid.volume]:

if r > cut:

geoid.extra += 1

return geoid

dd4hepConfig = acts.examples.dd4hep.DD4hepDetector.Config(

xmlFileNames=[str(odd_xml)],

name="OpenDataDetector",

logLevel=customLogLevel(),

dd4hepLogLevel=customLogLevel(minLevel=acts.logging.WARNING),

geometryIdentifierHook=acts.GeometryIdentifierHook(geoid_hook),

materialDecorator=materialDecorator,

)

if misaligned:

dd4hepConfig.detectorElementFactory = (

acts.examples.dd4hep.alignedDD4hepDetectorElementFactory

)

with warnings.catch_warnings():

warnings.simplefilter("ignore")

detector = acts.examples.dd4hep.DD4hepDetector(dd4hepConfig)

return detector