pygeoml1000 package

Subpackages

Submodules

pygeoml1000.cavern_and_labs module

pygeoml1000.cavern_and_labs.construct_and_place_cavern_and_labs(instr)

Construct and place the cavern and labs.

Parameters:

instr (InstrumentationData)

Return type:

None

pygeoml1000.cavern_and_labs.construct_cavern(material, registry, world_lv, cavern_max_height, rock_depth_below, rock_depth_above)

Construct the cavern geometry.

Positive x-axis is pointing towards north.

Parameters:
Return type:

LogicalVolume

pygeoml1000.cavern_and_labs.construct_rock(material, registry, world_lv, cavern_max_height, rock_depth_below, rock_depth_above)
Parameters:
Return type:

LogicalVolume

pygeoml1000.cli module

pygeoml1000.cli.dump_gdml_cli()
Return type:

None

pygeoml1000.config_compilation module

pygeoml1000.config_compilation._convert_numpy_types(obj)

Convert numpy types to native Python types recursively.

pygeoml1000.config_compilation.calculate_and_place_pmts(channelmap, configs)
Parameters:
Return type:

None

pygeoml1000.config_compilation.copy_raw_configs(destination_folder)

Copy raw config files to a custom folder.

Parameters:

destination_folder (str)

Return type:

None

pygeoml1000.config_compilation.generate_channelmap(string_idx, hpge_names, hpge_rawid, configs)

Generate channelmap.json file.

Parameters:
Return type:

dict

pygeoml1000.config_compilation.generate_dummy_metadata(input_config_folder='')

Generate dummy metadata objects without writing files.

Returns:

tuple: (channelmap_dict, special_metadata_dict)

Parameters:

input_config_folder (str)

Return type:

tuple[dict, dict]

pygeoml1000.config_compilation.generate_special_metadata(string_idx, hpge_names, configs)

Generate special_metadata.yaml file.

Parameters:
Return type:

dict

pygeoml1000.config_compilation.setup_config_file(input_config_folder='', output_config='')

Generate and write dummy metadata files to disk.

Parameters:

  • input_config_folder (str)

  • output_config (str)

Return type:

None

pygeoml1000.core module

class pygeoml1000.core.InstrumentationData(mother_lv, mother_pv, mother_z_displacement, mother_x_displacement, materials, registry, channelmap, special_metadata, runtime_config, detail)

Bases: NamedTuple

Create new instance of InstrumentationData(mother_lv, mother_pv, mother_z_displacement, mother_x_displacement, materials, registry, channelmap, special_metadata, runtime_config, detail)

Parameters:
channelmap: AttrsDict

LEGEND-1000 channel map containing germanium/spms detectors configuration in the string and their geometry.

detail: AttrsDict

The chosen detail level by the user. Used to navigate to the corresponding entry in the special metadata.

materials: OpticalMaterialRegistry

Material properties for common materials

mother_lv: LogicalVolume

Argon LogicalVolume instance in which all components are to be placed.

mother_pv: PhysicalVolume

Argon PhysicalVolume instance in which all components are to be placed.

mother_x_displacement: float

The x-displacement of the mother volume.

mother_z_displacement: float

The z-displacement of the mother volume.

registry: Registry

pyg4ometry registry instance.

runtime_config: AttrsDict

Volatile runtime config, settings that are not tied to a specific detector configuration.

special_metadata: AttrsDict

LEGEND-1000 special geometry metadata file. Used to reconstruct the spatial position of each string, detector and calibration tube.

pygeoml1000.core._assign_common_copper_surface(b)
Parameters:

b (InstrumentationData)

Return type:

None

pygeoml1000.core.construct(assemblies=None, detail_level='radiogenic', config=None, input_config_folder='')

Construct the LEGEND-1000 geometry and return the pyg4ometry Registry containing the world volume.

Parameters:

  • assemblies (list[str] | None)

  • detail_level (str)

  • config (dict | None)

  • input_config_folder (str)

Return type:

Registry

pygeoml1000.cryo module

Updated to the CAD status shown by Matthew Busch on 2025-11-05 LEGEND Collaboration Meeting.

pygeoml1000.cryo.construct_and_place_cryostat(instr)
Parameters:

instr (InstrumentationData)

Return type:

InstrumentationData

pygeoml1000.cryo.construct_atmospheric_lar(lar_material, reg, atmlar_r, atmlar_z)
Parameters:
Return type:

LogicalVolume

pygeoml1000.cryo.construct_inner_cryostat(cryostat_material, reg, icryo_r, icryo_z)
Parameters:
Return type:

LogicalVolume

pygeoml1000.cryo.construct_moderator_simple(mod_material, reg, mod_r_inner, mod_r_outer, mod_z, mod_n_sides, mother_lv)
Parameters:
pygeoml1000.cryo.construct_outer_cryostat(cryostat_material, reg, ocryo_r, ocryo_z)
Parameters:
Return type:

LogicalVolume

pygeoml1000.cryo.construct_reentrance_tube_with_layers(materials, reg, atmlar_lv, atmlar_pv, neck_radius, tube_height, total_height, curve_fraction, wls_height, ofhc_start_height, ofhc_end_height, ss_start_height)

Construct reentrance tube with WLSR, OFHC Cu, and 316L SS layers.

All layers are always present in the geometry: - Copper tube with variable thickness - OFHC copper layer (2179-4184mm height) - 316L stainless steel layer (4184mm-top) - Inner WLSR (TPB + Tetratex) in underground argon - Outer WLSR (TPB + Tetratex) in atmospheric argon

Returns:

Tuple of (underground_argon_lv, underground_argon_pv)

Parameters:
Return type:

tuple[LogicalVolume, PhysicalVolume]

pygeoml1000.cryo.construct_vacuum_gap(vac_material, reg, vac_r, vac_z)
Parameters:
Return type:

LogicalVolume

pygeoml1000.cryo.log = <Logger pygeoml1000.cryo (INFO)>

The cryostat consists of three main pieces: The top piece which encloses the reentrance tube, separating it from the water volume (the “neck”) The central piece, which encloses the LAr shielding (I call this the “body”, although the name is up for debate) The bottom piece, which supports the body and separates the “pillbox” water volume from the rest of the volume. I call this the “skirt”, but again, name is debatable. The skirt technically isn’t part of the cryostat - but, well, it’s not really part of anything else, either. Since it’s made of steel, connected to the cryostat, and enclosed by the water, we include it here anyways. The skirt also has a square support at the bottom, which I call the “foot”.

The body also consists of three sections: the curved top section, the cylindrical middle section, and the curved bottom section. I call these the “shoulder”, the “barrel”, and the “bottom”.

Unless stated otherwise, all radii and heights are from the outermost edge of each volume, not the inner. Unless stated otherwise, all radii and heights are measured from the outside of each object.

Only two radii need to be explicitly defined: the radius of the neck and the radius of the barrel. The neck’s radius stays constant, and the body’s top radius = neck radius, while the bottom radius tapers to 0.

There are multiple z points to consider: top of the neck, bottom of the neck/top of the shoulder, top and bottom of the body’s barrel (basically where the constant radius piece of the body begins and ends), bottom of the bottom (where the radius tapers to 0), and the height/width of the skirt’s “foot”.

I will also note that the top of the skirt is connected to the bottom of the barrel. The bottom z value of the skirt is fixed by the water tank height and should always connect with the floor. For now, I’ll just set a hard value for the total height, and at the end, the skirt can have what’s left to work with in the z direction.

The inner cryostat is a separate thing altogether, with its own curve, thicknesses and r/z values. These, too, will mostly be computed automatically from the outer cryostat values. The only inputs needed are the gaps between the inner and outer cryostat at some key points, and thickness. Let’s say, at the neck, at the barrel, and at the bottom.

pygeoml1000.cryo.make_moderator_z_r_r(mod_height, mod_radius, mod_thickness, tube_radius)
Parameters:
Return type:

tuple[list, list, list]

pygeoml1000.cryo.make_z_and_r(total_height, neck_height, body_height, neck_radius, barrel_radius, shoulder_fraction, bottom_fraction)
Parameters:
Return type:

tuple[list, list]

pygeoml1000.fibers module

class pygeoml1000.fibers.FiberModuleData(barrel: 'str', name: 'str', tpb_thickness: 'float', channel_top_name: 'str | None' = None, channel_bottom_name: 'str | None' = None, channel_top_rawid: 'str | None' = None, channel_bottom_rawid: 'str | None' = None, x_position_mm: 'float' = 0, y_position_mm: 'float' = 0, module_num: 'int' = 0, string_id: 'int' = 0)

Bases: object

Parameters:

  • barrel (str)

  • name (str)

  • tpb_thickness (float)

  • channel_top_name (str | None)

  • channel_bottom_name (str | None)

  • channel_top_rawid (str | None)

  • channel_bottom_rawid (str | None)

  • x_position_mm (float)

  • y_position_mm (float)

  • module_num (int)

  • string_id (int)

barrel: str
channel_bottom_name: str | None = None
channel_bottom_rawid: str | None = None
channel_top_name: str | None = None
channel_top_rawid: str | None = None
module_num: int = 0
name: str
string_id: int = 0
tpb_thickness: float
x_position_mm: float = 0
y_position_mm: float = 0
class pygeoml1000.fibers.ModuleFactoryBase(radius_mm, fiber_length_mm, fiber_count_per_shroud, bend_radius_mm, number_of_sipm_modules, z_displacement_mm, materials, registry, runtime_config)

Bases: ABC

Create a fiber module factory.

Parameters:

  • radius_mm (float) – radius of the fiber barrel

  • fiber_length_mm (float) – length of the straight section of this fiber module

  • fiber_count_per_shroud (int) – number of single fibers per module

  • bend_radius_mm (float | None) – radius of the bottom bend, or None if the fibers are not bent at the bottom end.

  • number_of_sipm_modules (int) – number of modules that cover the full circle

  • z_displacement_mm (float) – displacement of the top of the fiber barrel, relative to the global zero point.

  • materials (materials.OpticalMaterialRegistry)

  • registry (g4.Registry)

  • runtime_config (AttrsDict)

ANGLE_BETWEEN_MODULE_OTHERWISE = np.float64(0.017453292519943295)
ANGLE_PER_HOLDING_STRUCTURE = np.float64(0.20943951023931956)
ANGLE_SAFETY = 1e-09
FIBER_DIM = 1
FIBER_THICKNESS_CL1 = 0.04
FIBER_THICKNESS_CL2 = 0.02
N_FIBER_SHROUDS_PER_SIPM = 3
SIPM_GAP = 0.05
SIPM_GAP_SIDE = 0.02
SIPM_HEIGHT = 1
SIPM_OUTER_EXTRA = 0.2
SIPM_OVERLAP = 0.3
_abc_impl = <_abc._abc_data object>
_add_tpb_surfaces(fiber_pvs, mother_pv)
Parameters:
_cached_sipm_volumes()

Creates (dummy) SiPM volumes for use at the top/bottom of straight fiber sections.

Return type:

None

_create_sipm(mod, b, module_num, fibers, is_top, mother_lv, mother_pv, sipm_name, sipm_detector_id, z_displacement_straight, x_position_mm, y_position_mm)

Creates a (dummy) SiPM physical volume for use at the top/bottom of straight fiber sections.

Parameters:
Return type:

None

abstractmethod create_module(mod, b, x_position_mm, y_position_mm, module_num)
Parameters:
Return type:

None

start_angle(module_num, fiber_shroud_num)
Parameters:

  • module_num (int)

  • fiber_shroud_num (int)

Return type:

float

class pygeoml1000.fibers.ModuleFactorySegment(radius_mm, fiber_length_mm, fiber_count_per_shroud, bend_radius_mm, number_of_sipm_modules, z_displacement_mm, materials, registry, runtime_config)

Bases: ModuleFactoryBase

Create a fiber module factory.

Parameters:

  • radius_mm (float) – radius of the fiber barrel

  • fiber_length_mm (float) – length of the straight section of this fiber module

  • fiber_count_per_shroud (int) – number of single fibers per module

  • bend_radius_mm (float | None) – radius of the bottom bend, or None if the fibers are not bent at the bottom end.

  • number_of_sipm_modules (int) – number of modules that cover the full circle

  • z_displacement_mm (float) – displacement of the top of the fiber barrel, relative to the global zero point.

  • materials (materials.OpticalMaterialRegistry)

  • registry (g4.Registry)

  • runtime_config (AttrsDict)

_abc_impl = <_abc._abc_data object>
_cached_fiber_volumes()

Create solids, logical and physical volumes for the fibers, as specified by the parameters of this instance.

Return type:

None

_cached_sipm_volumes_bend()

Creates (dummy) SiPM volumes for use at the bottom of bent fiber sections.

Return type:

None

_cached_tpb_coating_volume(tpb_thickness_nm, bend=False)

Create and cache a TPB coating layer of the specified thickness.

The TPB-Layer is dependent on the module (i.e. the applied thickness varies slightly), so we cannot cache it globally on this instance.

Parameters:
Return type:

LogicalVolume

_get_bend_polycone(inner_r, outer_r)

In the segmented model, there is no fundamental shape for the fiber bent available, so we use a polycone as a replacement.

Parameters:
Return type:

tuple[ArrayLike, ArrayLike]

create_module(mod, b)
Parameters:
Return type:

None

class pygeoml1000.fibers.ModuleFactorySingleFibers(radius_mm, fiber_length_mm, fiber_count_per_shroud, bend_radius_mm, number_of_sipm_modules, z_displacement_mm, materials, registry, runtime_config)

Bases: ModuleFactoryBase

Create a fiber module factory.

Parameters:

  • radius_mm (float) – radius of the fiber barrel

  • fiber_length_mm (float) – length of the straight section of this fiber module

  • fiber_count_per_shroud (int) – number of single fibers per module

  • bend_radius_mm (float | None) – radius of the bottom bend, or None if the fibers are not bent at the bottom end.

  • number_of_sipm_modules (int) – number of modules that cover the full circle

  • z_displacement_mm (float) – displacement of the top of the fiber barrel, relative to the global zero point.

  • materials (materials.OpticalMaterialRegistry)

  • registry (g4.Registry)

  • runtime_config (AttrsDict)

ALLOWED_DELTA_LENGTHS = (-6.96, -5.22, -3.48, -1.74, 0, 1.74, 3.48, 5.22, 6.96)
_abc_impl = <_abc._abc_data object>
_cached_fiber_volumes()

Create solids, logical and physical volumes for the fibers, as specified by the parameters of this instance.

Return type:

None

_cached_sipm_volumes_bend()

Creates (dummy) SiPM volumes for use at the bottom of bent fiber sections.

Return type:

None

_cached_tpb_coating_volume(tpb_thickness_nm, bend=False, delta_length=0)

Create and cache a TPB coating layer of the specified thickness.

The TPB-Layer is dependent on the module (i.e. the applied thickness varies slightly), so we cannot cache it globally on this instance.

Parameters:
Return type:

LogicalVolume

create_module(mod, b)
Parameters:
Return type:

None

pygeoml1000.fibers.place_fiber_modules(b)

Construct LEGEND-1000 HPGe strings.

detail options:

“segmented” or “detailed”

Switch between an implementation of single fibers (“detailed”) or slabs of fiber material (“segmented”).

Parameters:

b (InstrumentationData)

Return type:

None

pygeoml1000.hpge_strings module

class pygeoml1000.hpge_strings.HPGeDetUnit(name: 'str', manufacturer: 'str', rawid: 'int', lv: 'geant4.LogicalVolume', height: 'float', radius: 'float', baseplate: 'str', rodlength: 'float', meta: 'AttrsDict')

Bases: object

Parameters:
baseplate: str
height: float
lv: LogicalVolume
manufacturer: str
meta: AttrsDict
name: str
radius: float
rawid: int
rodlength: float
pygeoml1000.hpge_strings._add_pen_surfaces(pen_pv, mother_pv, mats, reg)
Parameters:
pygeoml1000.hpge_strings._get_hv_cable(name, cable_thickness, clamp_thickness, cable_length, materials, mother_pv, reg)
Parameters:
pygeoml1000.hpge_strings._get_pen_plate(size, materials, registry)
Parameters:
Return type:

LogicalVolume

pygeoml1000.hpge_strings._get_signal_cable_and_asic(name, cable_thickness, clamp_thickness, cable_length, materials, mother_pv, reg)
Parameters:
pygeoml1000.hpge_strings._get_support_structure(size, materials, registry)

Get the (simplified) support structure and the tristar of the requested size.

Note

Both models’ coordinate origins are a the top face of the tristar structure.

Parameters:
Return type:

tuple[LogicalVolume, LogicalVolume]

pygeoml1000.hpge_strings._get_weldment_and_insulator(det_unit, weldment_top_flap_thickness, insulator_du_holder_flap_thickness, insulator_top_length, materials, reg)
Parameters:
pygeoml1000.hpge_strings._place_front_end_and_insulators(det_unit, unit_length, string_info, b, z_pos, thickness, parts_origin)
Parameters:
pygeoml1000.hpge_strings._place_hpge_string(string_id, string_slots, b)

Place a single HPGe detector string.

This includes all PEN plates and the nylon shroud around the string.

Parameters:
pygeoml1000.hpge_strings._place_hpge_unit(z_unit_bottom, det_unit, unit_length, string_info, thicknesses, b)
Parameters:
pygeoml1000.hpge_strings.calculate_string_rotation(string_id, b)
Parameters:
Return type:

float

pygeoml1000.hpge_strings.place_hpge_strings(b)

Construct LEGEND-1000 HPGe strings.

Parameters:

b (InstrumentationData)

Return type:

None

pygeoml1000.rt_profiles module

Profile generation functions for L1000 geometry components.

This module contains functions to generate z-r profile coordinates for: - Reentrance tube outer and inner boundaries - Wavelength-shifting reflector (WLSR) layers (TPB and Tetratex) - OFHC copper structural layers - 316L stainless steel layers

The profiles define GenericPolycone geometries with proper closure conditions and protection gaps to prevent overlapping volumes in Geant4.

class pygeoml1000.rt_profiles.WLSRProfiles(tpb_outer_z, tpb_outer_r, tpb_inner_z, tpb_inner_r, ttx_outer_z, ttx_outer_r, ttx_inner_z, ttx_inner_r)

Bases: NamedTuple

Create new instance of WLSRProfiles(tpb_outer_z, tpb_outer_r, tpb_inner_z, tpb_inner_r, ttx_outer_z, ttx_outer_r, ttx_inner_z, ttx_inner_r)

Parameters:
tpb_inner_r: list[float]

Alias for field number 3

tpb_inner_z: list[float]

Alias for field number 2

tpb_outer_r: list[float]

Alias for field number 1

tpb_outer_z: list[float]

Alias for field number 0

ttx_inner_r: list[float]

Alias for field number 7

ttx_inner_z: list[float]

Alias for field number 6

ttx_outer_r: list[float]

Alias for field number 5

ttx_outer_z: list[float]

Alias for field number 4

pygeoml1000.rt_profiles._steel_thickness_from_top(distance_from_top, tube_height)

Calculate steel thickness at given distance from top of tube.

Parameters:
Return type:

float

pygeoml1000.rt_profiles.ensure_closed_bottom(z_list, r_list, bottom_z, closure_thickness=None, gap_threshold=1e-06)

Ensure proper bottom closure by adding intermediate conical points.

Args:

z_list: list of z coordinates r_list: list of r coordinates bottom_z: z coordinate where closure should occur closure_thickness: if provided, close at bottom_z + closure_thickness gap_threshold: minimum gap size (in mm) to trigger point insertion (default 0.0001 = 100 nm)

Returns:

Tuple of (z_list, r_list) with proper closure points added

Parameters:
Return type:

tuple[list[float], list[float]]

pygeoml1000.rt_profiles.make_316l_ss_profiles(neck_radius, tube_height, total_height, curve_fraction, ss_start_height, outer_z, outer_r, inner_z, inner_r)

Create 316L stainless steel profiles with protection gap on all sides.

Returns:

Tuple of (outer_z, outer_r, inner_z, inner_r)

Parameters:
Return type:

tuple[list[float], list[float], list[float], list[float]]

pygeoml1000.rt_profiles.make_inner_profile(neck_radius, tube_height, total_height, curve_fraction, wls_height=2179, outer_z=None, outer_r=None)

Create inner profile with constant wall thickness. Inner surface closes at higher z than outer to maintain thickness.

Returns:

Tuple of (z_coordinates, r_coordinates)

Parameters:
Return type:

tuple[list[float], list[float]]

pygeoml1000.rt_profiles.make_inner_wlsr_profiles(neck_radius, tube_height, total_height, curve_fraction, wls_height=2179, inner_z=None, inner_r=None)

Create inner WLSR profiles…

Parameters:
Return type:

WLSRProfiles

pygeoml1000.rt_profiles.make_ofhc_cu_profiles(neck_radius, tube_height, total_height, curve_fraction, ofhc_start_height, ofhc_end_height, outer_z, outer_r, inner_z, inner_r)

Create OFHC copper profiles as SOLID volume with protection gap from steel.

Returns:

Tuple of (outer_z, outer_r, inner_z, inner_r)

Parameters:
Return type:

tuple[list[float], list[float], list[float], list[float]]

pygeoml1000.rt_profiles.make_outer_profile(neck_radius, tube_height, total_height, curve_fraction, wls_height=2179)

Create complete outer profile with filled cylindrical section.

Returns:

Tuple of (z_coordinates, r_coordinates)

Parameters:
Return type:

tuple[list[float], list[float]]

pygeoml1000.rt_profiles.make_outer_wlsr_profiles(neck_radius, tube_height, total_height, curve_fraction, wls_height=2179, outer_z=None, outer_r=None)

Create outer WLSR profiles…

Parameters:
Return type:

WLSRProfiles

pygeoml1000.watertank module

Construct the LEGEND-1000 water tank including the water volume.

Dimensions from technical drawings ‘Water Tank 12m Dia - Pit Version’ approved by M. Busch 16 July 2024.

Latest Changes: 24.01.2025 Eric Esch

pygeoml1000.watertank.construct_and_place_tank(instr)
Parameters:

instr (InstrumentationData)

Return type:

InstrumentationData

pygeoml1000.watertank.construct_base(name, reg, v_wall=0.0, h_wall=0.0, neck_safety=0.0)

Construct the base shape of the tank.

name: Prefix to add to the volume name v_wall: The thickness of the vertical walls of the tank h_wall: The thickness of the horizontal walls of the tank

The returned polycone will be the base of the tank with the vertical and horizontal walls ‘shaved’ off.

Parameters:
Return type:

<module ‘pyg4ometry.geant4.solid’ from ‘/home/docs/checkouts/readthedocs.org/user_builds/legend-pygeom-l1000/checkouts/latest/.venv/lib/python3.12/site-packages/pyg4ometry/geant4/solid/__init__.py’>

pygeoml1000.watertank.construct_bulge(name, base, reg, v_wall=0.0, h_wall=0.0)

Construct the bulge on top of the tank.

name: Prefix to add to the volume name base: The base to which this bulge will be added (or rather subtracted) v_wall: The thickness of the vertical walls of the tank h_wall: The thickness of the horizontal walls of the tank

Parameters:

  • name (str)

  • base (<module 'pyg4ometry.geant4.solid' from '/home/docs/checkouts/readthedocs.org/user_builds/legend-pygeom-l1000/checkouts/latest/.venv/lib/python3.12/site-packages/pyg4ometry/geant4/solid/__init__.py'>)

  • reg (Registry)

  • v_wall (float)

  • h_wall (float)

Return type:

<module ‘pyg4ometry.geant4.solid’ from ‘/home/docs/checkouts/readthedocs.org/user_builds/legend-pygeom-l1000/checkouts/latest/.venv/lib/python3.12/site-packages/pyg4ometry/geant4/solid/__init__.py’>

pygeoml1000.watertank.construct_flange(base, reg, n=4)

Construct the flange solid to be placed on top of the tank. Constructed from 6 boolean operations and therefore probably not very run-time efficient in G4.

base: The base of the tank to which the flanges will be added. n: Number of flanges to add to the tank. Default is 4.

Parameters:

  • base (<module 'pyg4ometry.geant4.solid' from '/home/docs/checkouts/readthedocs.org/user_builds/legend-pygeom-l1000/checkouts/latest/.venv/lib/python3.12/site-packages/pyg4ometry/geant4/solid/__init__.py'>)

  • reg (Registry)

  • n (int)

Return type:

<module ‘pyg4ometry.geant4.solid’ from ‘/home/docs/checkouts/readthedocs.org/user_builds/legend-pygeom-l1000/checkouts/latest/.venv/lib/python3.12/site-packages/pyg4ometry/geant4/solid/__init__.py’>

pygeoml1000.watertank.construct_manhole(base, reg)

Construct the manhole solid.

base: The base of the tank to which the manhole will be added.

Parameters:

  • base (<module 'pyg4ometry.geant4.solid' from '/home/docs/checkouts/readthedocs.org/user_builds/legend-pygeom-l1000/checkouts/latest/.venv/lib/python3.12/site-packages/pyg4ometry/geant4/solid/__init__.py'>)

  • reg (Registry)

pygeoml1000.watertank.construct_tank(tank_material, reg, detail='simple')

Construct the tank volume.

detail: Level of tank detail. Can be ‘simple’ or ‘detailed’. simple: Only the base polycone of the tank is constructed. detailed: Base, Bulge, Manhole and Flanges are constructed.

Parameters:
Return type:

LogicalVolume

pygeoml1000.watertank.construct_water(water_material, reg, detail='simple')

Construct the water volume.

detail: Level of tank detail. Can be ‘simple’ or ‘detailed’. simple: Only the base polycone of the water is constructed. detailed: The base polycone and the bulge on top of the tank are constructed.

Parameters:
Return type:

LogicalVolume

pygeoml1000.watertank_instrumentation module

Construct the instrumentation inside of the water tank.

Dimensions from latest CAD from 2025-01-24.

pygeoml1000.watertank_instrumentation.construct_PMT_back(base_mat, reg)
Parameters:
Return type:

LogicalVolume

pygeoml1000.watertank_instrumentation.construct_PMT_front(vac_mat, surfaces, reg)

Construct the solids for the front part of the PMT. Consists of glass window, vacuum and cathode. These solids should be placed as mother-to-daughter: window <- vacuum <- cathode

Parameters:
Return type:

LogicalVolume

pygeoml1000.watertank_instrumentation.construct_and_place_instrumentation(instr)

Construct and place the instrumentation inside of the water tank.

Parameters:

instr (core.InstrumentationData) – The instrumentation data object containing the current state of the geometry.

Return type:

PhysicalVolume

pygeoml1000.watertank_instrumentation.construct_tyvek_foil(mat, instr)
Parameters:
Return type:

LogicalVolume

pygeoml1000.watertank_instrumentation.get_euler_angles(target_direction)

Calculate the Euler angles to rotate the default direction to the target direction. The default direction is [0, 0, 1]

Parameters:

target_direction (array)

pygeoml1000.watertank_instrumentation.place_PMT_front(rotation, translation, pmt_volumes, name, mother_lv, reg, instr, rawid)

Since the PMT is a compound volume, we need to place the PMT window, vacuum and cathode separately. Due to the Geant4 handles copies of Logical Volumes, we need to create new Logical Volumes for each sensitive PMT.

Parameters:
Return type:

PhysicalVolume

pygeoml1000.watertank_instrumentation.place_floor_pmts(pmt_volumes, pmt_base_lv, instr)
Parameters:
pygeoml1000.watertank_instrumentation.place_wall_pmts(pmt_volumes, instr)
Parameters:

pygeoml1000.wlsr module

WLSR placement with TPB as parent volume and TTX as daughter

pygeoml1000.wlsr._add_wls_surfaces(materials, reg, tpb_pv, tetratex_pv, lar_pv, prefix='')

Add optical border surfaces for WLS layers.

Parameters:
Return type:

None

pygeoml1000.wlsr.place_inner_wlsr_in_argon(materials, registry, lar_cavity_lv, lar_cavity_pv, neck_radius, tube_height, total_height, curve_fraction, wls_height, inner_z, inner_r, outer_z, outer_r)

Place inner WLS layers in the underground argon.

Parameters:
Return type:

None

pygeoml1000.wlsr.place_outer_wlsr_in_atmospheric(materials, registry, lar_mother_lv, lar_mother_pv, neck_radius, tube_height, total_height, curve_fraction, wls_height, outer_z, outer_r)

Place outer WLS layers in the atmospheric argon.

Parameters:
Return type:

None