gwsim 0.1.0__py3-none-any.whl

gwsim/utils/io.py

@@ -0,0 +1,167 @@
+"""Utility functions for file input/output operations with safety checks."""
+
+from __future__ import annotations
+
+import itertools
+import logging
+import re
+from functools import wraps
+from pathlib import Path
+
+import numpy as np
+from astropy.units import Quantity
+from numpy.typing import NDArray
+
+logger = logging.getLogger("gwsim")
+
+
+def check_file_overwrite():
+    """A decorator to check the existence of the file,
+    and avoid overwriting it unintentionally.
+
+    Provides safe file handling with clear error messages and logging.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, file_name: str | Path, overwrite: bool = False, **kwargs):
+            file_name = Path(file_name)
+
+            # Create parent directories if they don't exist
+            file_name.parent.mkdir(parents=True, exist_ok=True)
+
+            if file_name.exists():
+                if not overwrite:
+                    raise FileExistsError(
+                        f"File '{file_name}' already exists. "
+                        f"Use overwrite=True or --overwrite flag to overwrite it."
+                    )
+                file_size = file_name.stat().st_size
+                logger.warning("File '%s' already exists (size: %d bytes). Overwriting...", file_name, file_size)
+
+            return func(*args, file_name=file_name, overwrite=overwrite, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def check_file_exist():
+    """A decorator to check the existence of a file."""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, file_name: str | Path, **kwargs):
+            file_name = Path(file_name)
+            if not file_name.is_file():
+                raise FileNotFoundError(f"File {file_name} does not exist.")
+            return func(*args, file_name=file_name, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def get_file_name_from_template(  # pylint: disable=too-many-locals
+    template: str,
+    instance: object | None = None,
+    output_directory: str | Path | None = None,
+    exclude: set[str] | None = None,
+) -> Path | NDArray[Path]:
+    """Get the file name(s) from a template string.
+
+    The template string uses double curly brackets for placeholders (e.g., '{{ x }}-{{ y }}.txt').
+    If any placeholder refers to an array-like attribute (list, tuple, or iterable),
+    the function generates all combinations of file names by iterating over the Cartesian product.
+    For example, '{{ non-list }}-{{ list-A }}-{{ list-B }}' with list-A having X elements
+    and list-B having Y elements returns a list of X * Y file names.
+
+    Excluded placeholders are left unsubstituted (e.g., '{{ excluded }}' remains as-is).
+
+    Args:
+        template (str): A template string with placeholders.
+        instance (object): An instance from which to retrieve attribute values.
+        output_directory (str | Path | None): Optional output directory to prepend to the file names.
+        exclude (set[str] | None): Set of attribute names to exclude from expansion. Defaults to None.
+
+    Returns:
+        str | np.ndarray: A single file name string if no array-like attributes are used,
+        otherwise a nested list structure matching the dimensionality of the array placeholders.
+
+    Raises:
+        ValueError: If a placeholder refers to a non-existent attribute.
+    """
+    if exclude is None:
+        exclude = set()
+
+    # Find all unique placeholders in the template
+    placeholders = list(dict.fromkeys(re.findall(r"\{\{\s*(\w+)\s*\}\}", template)))
+
+    # Remove excluded placeholders from the list
+    placeholders = [p for p in placeholders if p not in exclude]
+
+    # Collect values for each placeholder
+    values_dict = {}
+    for label in placeholders:
+        if label in exclude:
+            continue
+        try:
+            value = getattr(instance, label)
+        except AttributeError as e:
+            raise ValueError(f"Attribute '{label}' not found in instance of type {type(instance).__name__}") from e
+
+        if isinstance(value, Quantity):
+            x = value.value
+            if x.is_integer():
+                x = int(x)
+            values_dict[label] = [str(x)]
+        # Check if value is array-like (list, tuple, or iterable but not str)
+        elif isinstance(value, (list, tuple)) or (hasattr(value, "__iter__") and not isinstance(value, str)):
+            values_dict[label] = [str(ele) for ele in list(value)]
+        else:
+            values_dict[label] = [str(value)]
+
+    # Prepare lists for Cartesian product
+    product_lists = [values_dict[label] for label in placeholders]
+
+    # Generate all combinations
+    combinations = list(itertools.product(*product_lists))
+
+    # Helper function for substitution
+    def substitute_template(combo_dict: dict) -> str:
+        def replace(matched):
+            label = matched.group(1).strip()
+            if label in exclude:
+                return matched.group(0)  # Return the original placeholder unchanged
+            return str(combo_dict[label])
+
+        return re.sub(r"\{\{\s*(\w+)\s*\}\}", replace, template)
+
+    # Substitute for each combination
+    results = [Path(substitute_template(dict(zip(placeholders, combo, strict=False)))) for combo in combinations]
+
+    if output_directory is not None:
+        output_directory = Path(output_directory)
+        results = [output_directory / result for result in results]
+
+    # Reshape into nested list if there are array placeholders
+    array_placeholders = [p for p in placeholders if len(values_dict[p]) > 1]
+    if array_placeholders:
+        lengths = [len(values_dict[p]) for p in array_placeholders]
+
+        def reshape_to_nested(flat_list: list, lengths: list[int]):
+            if not lengths:
+                return flat_list[0] if flat_list else ""
+            size = lengths[0]
+            sub_size = len(flat_list) // size
+            nested = []
+            for i in range(size):
+                start = i * sub_size
+                end = (i + 1) * sub_size
+                sub_list = flat_list[start:end]
+                nested.append(reshape_to_nested(sub_list, lengths[1:]))
+            return nested
+
+        return np.array(reshape_to_nested(results, lengths))
+    # No arrays: return single string
+    return results[0] if results else Path("")

gwsim/utils/log.py

@@ -0,0 +1,145 @@
+"""Utility functions for logging."""
+
+from __future__ import annotations
+
+import logging
+from importlib.metadata import PackageNotFoundError, distribution
+from importlib.metadata import version as get_package_version
+from pathlib import Path
+
+from gwsim.version import __version__
+
+logger = logging.getLogger("gwsim")
+
+
+def get_version_information() -> str:
+    """Get the version information.
+
+    Returns:
+        str: Version information.
+    """
+    return __version__
+
+
+def _get_dependencies_from_distribution() -> list[str]:
+    """Extract main dependencies from the installed gwsim distribution.
+
+    This uses importlib.metadata to query the installed package metadata,
+    which works in both development and installed environments.
+
+    Returns:
+        List of package names from the distribution's requires metadata.
+        Returns empty list if gwsim distribution cannot be found.
+    """
+    try:
+        dist = distribution("gwsim")
+        if dist.requires is None:
+            return []
+
+        # Parse dependency specifiers from the requires list
+        # Format: "package_name (>=version); extra == 'condition'" or "package_name>=version"
+        package_names = []
+        for req in dist.requires:
+            # Remove version specifiers and extras
+            # Split on common delimiters: >, <, =, !, [, ;, space
+            package_name = (
+                req.split(">")[0].split("<")[0].split("=")[0].split("!")[0].split("[")[0].split(";")[0].strip()
+            )
+            if package_name and package_name not in package_names:  # Avoid duplicates
+                package_names.append(package_name)
+
+        return package_names
+    except PackageNotFoundError:
+        logger.debug("gwsim distribution not found - unable to extract dependencies")
+        return []
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logger.debug("Failed to extract dependencies from distribution: %s", e)
+        return []
+
+
+def get_dependency_versions() -> dict[str, str | None]:
+    """Get versions of gwsim and its main dependencies.
+
+    This retrieves version information for gwsim and all dependencies listed
+    in the installed distribution's metadata (from pyproject.toml at build time),
+    useful for metadata and reproducibility tracking.
+
+    Works in both development and installed environments since it queries
+    the installed distribution metadata rather than the source pyproject.toml.
+
+    Returns:
+        Dictionary with package names as keys and version strings as values.
+        If a package version cannot be determined, the value is None.
+        Always includes 'gwsim' as the first key.
+    """
+    versions: dict[str, str | None] = {}
+
+    # Always include gwsim first
+    try:
+        versions["gwsim"] = get_package_version("gwsim")
+    except PackageNotFoundError:
+        versions["gwsim"] = None
+
+    # Get dependencies from the installed distribution metadata
+    dependencies = _get_dependencies_from_distribution()
+
+    for package in dependencies:
+        try:
+            versions[package] = get_package_version(package)
+        except PackageNotFoundError:
+            # Package not installed or version cannot be determined
+            versions[package] = None
+
+    return versions
+
+
+def setup_logger(
+    outdir: str = ".", label: str | None = None, log_level: str | int = "INFO", print_version: bool = False
+):
+    """Setup logging output: call at the start of the script to use
+
+    Args:
+        outdir (str, optional): If supplied, write the logging output to outdir/label.log. Defaults to '.'.
+        label (str, optional): If supplied, write the logging output to outdir/label.log. Defaults to None.
+        log_level (str, optional): ['debug', 'info', 'warning']
+            Either a string from the list above, or an integer as specified
+            in https://docs.python.org/2/library/logging.html#logging-levels
+            Defaults to 'INFO'.
+        print_version (bool): If true, print version information. Defaults to False.
+    """
+
+    if isinstance(log_level, str):
+        try:
+            level = getattr(logging, log_level.upper())
+        except AttributeError as err:
+            raise ValueError(f"log_level {log_level} not understood") from err
+    else:
+        level = int(log_level)
+
+    logger.propagate = False
+    logger.setLevel(level)
+
+    if not any(isinstance(h, logging.StreamHandler) for h in logger.handlers):
+        stream_handler = logging.StreamHandler()
+        stream_handler.setFormatter(
+            logging.Formatter("%(asctime)s %(name)s %(levelname)-8s: %(message)s", datefmt="%H:%M")
+        )
+        stream_handler.setLevel(level)
+        logger.addHandler(stream_handler)
+
+    if not any(isinstance(h, logging.FileHandler) for h in logger.handlers):
+        if label:
+            Path(outdir).mkdir(parents=True, exist_ok=True)
+            log_file = f"{outdir}/{label}.log"
+            file_handler = logging.FileHandler(log_file)
+            file_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s: %(message)s", datefmt="%H:%M"))
+
+            file_handler.setLevel(level)
+            logger.addHandler(file_handler)
+
+    for handler in logger.handlers:
+        handler.setLevel(level)
+
+    if print_version:
+        version = get_version_information()
+        logger.info("Running gwsim version: %s", version)

gwsim/utils/population.py

@@ -0,0 +1,48 @@
+"""Utility functions for reading population files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import h5py
+import pandas as pd
+
+
+def read_pycbc_population_file(file_name):
+    """
+    Read a PyCBC population file (.hdf, .h5) and return a pandas DataFrame.
+
+    Supports:
+      - HDF5 population files from pycbc_population
+    Parameters
+    ----------
+    file_name : Path or str
+        Path to the PyCBC population file.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame containing population parameters.
+    """
+    file_path = Path(file_name)
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    suffix = file_path.suffix.lower()
+
+    # --- HDF5 (.hdf or .h5) ---
+    if suffix in {".hdf", ".h5"}:
+        with h5py.File(file_path, "r") as f:
+
+            # PyCBC stores parameters as datasets
+            data = {key: value[()] for key, value in f.items()}
+
+            # Collect attributes (Include static parameters in config files)
+            attrs = dict(f.attrs.items())
+
+        df = pd.DataFrame(data)
+        df.attrs.update(attrs)  # Attach metadata
+    else:
+        raise ValueError(f"Unsupported file type: {suffix}")
+
+    return df

gwsim/utils/random.py

@@ -0,0 +1,69 @@
+"""A random number manager."""
+
+from __future__ import annotations
+
+from numpy.random import Generator, SeedSequence, default_rng
+
+
+class RandomManager:
+    """Singleton manager for random number generation."""
+
+    _rng = default_rng()
+
+    @classmethod
+    def get_rng(cls) -> Generator:
+        """Get the random number generator.
+
+        Returns:
+            Generator: Random number generator.
+        """
+        return cls._rng
+
+    @classmethod
+    def seed(cls, seed_: int):
+        """Set the seed of the random number generator.
+
+        Args:
+            seed_ (int): Seed.
+        """
+        cls._rng = default_rng(seed_)
+
+    @classmethod
+    def generate_seeds(cls, n_seeds: int) -> list:
+        """Generate the seeds using the numpy SeedSequence class such that
+        the BitGenerators are independent and very probably non-overlapping.
+
+        Args:
+            n_seeds (int): Number of seeds.
+
+        Returns:
+            list: A list of SeedSequence.
+        """
+        return SeedSequence(cls._rng.integers(0, 2**63 - 1, size=4)).spawn(n_seeds)
+
+    @classmethod
+    def get_state(cls) -> dict:
+        """Get the current state of the random number generator.
+
+        Returns:
+            dict: The state of the RNG's bit generator.
+        """
+        return cls._rng.bit_generator.state
+
+    @classmethod
+    def set_state(cls, state: dict):
+        """Set the state of the random number generator.
+
+        Args:
+            state (dict): The state of the RNG's bit generator.
+        """
+        cls._rng = default_rng()  # Create new generator to avoid state conflicts
+        cls._rng.bit_generator.state = state
+
+
+# Alias for easy  access
+get_rng = RandomManager.get_rng
+set_seed = RandomManager.seed
+generate_seeds = RandomManager.generate_seeds
+get_state = RandomManager.get_state
+set_state = RandomManager.set_state

gwsim/utils/retry.py

@@ -0,0 +1,75 @@
+"""Retry decorator for handling transient failures."""
+
+from __future__ import annotations
+
+import functools
+import logging
+import time
+from collections.abc import Callable
+from typing import Any
+
+logger = logging.getLogger("gwsim")
+
+
+def retry_on_failure(
+    max_retries: int = 3,
+    initial_delay: float = 1.0,
+    backoff_factor: float = 2.0,
+    exceptions: tuple[type[Exception], ...] = (Exception,),
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Decorator to retry a function on failure with exponential backoff.
+
+    Retries the decorated function up to `max_retries` times on specified exceptions,
+    with exponential backoff between attempts. Useful for handling transient I/O errors.
+
+    Args:
+        max_retries: Maximum number of retry attempts (default: 3).
+        initial_delay: Initial delay in seconds before the first retry (default: 1.0).
+        backoff_factor: Factor by which the delay increases after each retry (default: 2.0).
+        exceptions: Tuple of exception types to catch and retry on (default: all Exceptions).
+
+    Returns:
+        The decorated function.
+
+    Example:
+        @retry_on_failure(max_retries=5, initial_delay=0.5)
+        def unstable_io_operation():
+            # Code that might fail transiently
+            pass
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            delay = initial_delay
+            last_exception: Exception | None = None
+
+            for attempt in range(max_retries + 1):
+                try:
+                    return func(*args, **kwargs)
+                except exceptions as e:
+                    last_exception = e
+                    if attempt < max_retries:
+                        logger.warning(
+                            "Attempt %d/%d failed for %s: %s. Retrying in %.2f seconds...",
+                            attempt + 1,
+                            max_retries + 1,
+                            func.__name__,
+                            e,
+                            delay,
+                        )
+                        time.sleep(delay)
+                        delay *= backoff_factor
+                    else:
+                        logger.error(
+                            "All %d attempts failed for %s: %s",
+                            max_retries + 1,
+                            func.__name__,
+                            e,
+                        )
+                        raise last_exception from e
+            return None
+
+        return wrapper
+
+    return decorator

gwsim/utils/triangular_et_geometry.py

@@ -0,0 +1,164 @@
+"""Script to compute the ET Triangular geometry at a given location"""
+
+from __future__ import annotations
+
+import numpy as np
+import pymap3d as pm
+from pycbc.detector import Detector, add_detector_on_earth
+
+
+def get_unit_vector_angles(unit_vector: np.ndarray, ellipsoid_position: np.ndarray) -> np.ndarray:
+    """
+    Compute the azimuthal angle and altitude (elevation) of a given unit vector
+    relative to the local tangent plane at the specified ellipsoid position.
+
+    Args:
+        unit vector (np.ndarray): A 3-element array representing the unit vector
+            in geocentric (ECEF) coordinates.
+        ellipsoid_position (np.ndarray): A 3-element array specifying the reference position
+            [latitude (rad), longitude (rad), height (meters)] on the Earth's ellipsoid
+
+    Returns:
+        (np.ndarray): A 2-element array [azimuth (rad), altitude (rad)], where:
+            - azimuth is the angle from local north (0 to 2π, increasing eastward),
+            - altitude is the elevation angle from the local horizontal plane (-π/2 to π/2).
+    """
+    lat, lon, _ = ellipsoid_position
+    normal_vector = np.array([np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)])
+    north_vector = np.array([-np.sin(lat) * np.cos(lon), -np.sin(lat) * np.sin(lon), np.cos(lat)])
+    east_vector = np.array([-np.sin(lon), np.cos(lon), 0])
+    altitude = np.arcsin(np.dot(unit_vector, normal_vector))
+    azimuth = np.mod(np.arctan2(np.dot(unit_vector, east_vector), np.dot(unit_vector, north_vector)), 2 * np.pi)
+
+    return np.array([azimuth, altitude])
+
+
+def add_et_triangular_detector_at_location(  # pylint: disable=too-many-locals,duplicate-code
+    e1_latitude: float, e1_longitude: float, e1_height: float, location_name: str, et_arm_l: float = 10000
+) -> tuple[Detector, Detector, Detector]:
+    """
+    Add the triangular Einstein Telescope detector with PyCBC at a given location and height.
+    The ET triangular configuration follows T1400308.
+    The arms 1 and 2 of E1 are defined on the tangent plane at the E1 vertex position.
+    The arm 1 has the same azimuth angle and altitude of the Virgo arm 1
+    in the local horizontal coordinate system center at the E1 vertex.
+
+    Args:
+        E1_latitude (float): E1 vertex latitude (rad)
+        E1_longitude (float): E1 vertex longitude (rad)
+        E1_height (float): E1 vertex height above the standard reference ellipsoidal earth (meters)
+        location_name (str): Name of the ET location (e.g., Sardinia, EMR, Cascina, ...)
+            for detector naming convention
+        ETArmL (float, optional): ET arm length (meters). Default to 10000 meters.
+
+    Returns:
+        (Detector, Detector, Detector): pycbc.detector.Detector objects for E1, E2 and E3.
+    """
+
+    e1_ellipsoid = [e1_latitude, e1_longitude, e1_height]
+
+    # E1 vertex location in geocentric (ECEF) coordinates
+    e1 = np.array(pm.geodetic2ecef(*e1_ellipsoid, deg=False))
+
+    # Normal vector to the tangent plane at the E1 vertex (ECEF coordinates)
+    e1_norm_vec = np.array(
+        [np.cos(e1_latitude) * np.cos(e1_longitude), np.cos(e1_latitude) * np.sin(e1_longitude), np.sin(e1_latitude)]
+    )
+
+    # Azimuth and altitude of Virgo arm 1 from LAL
+    v1_arm1_az = 0.3391628563404083
+    v1_arm1_alt = 0.0
+
+    # Define the arm 1 of E1 with the same azimuth and altitude of the Virgo arm 1 (ECEF coordinates)
+    e1_arm1 = np.array(
+        pm.aer2ecef(
+            az=v1_arm1_az, el=v1_arm1_alt, srange=1, lat0=e1_latitude, lon0=e1_longitude, alt0=e1_height, deg=False
+        )
+        - e1
+    )
+
+    # E2 vertex location
+    e2 = e1 + (et_arm_l * e1_arm1)
+
+    # Calculating rotation matrix to define E2 and E3 arms
+    ux, uy, uz = e1_norm_vec
+    theta = 60
+    cos_t = np.cos(np.deg2rad(theta))
+    sin_t = np.sin(np.deg2rad(theta))
+    re1 = np.array(
+        [
+            [cos_t + ux**2 * (1 - cos_t), ux * uy * (1 - cos_t) - uz * sin_t, ux * uz * (1 - cos_t) + uy * sin_t],
+            [ux * uy * (1 - cos_t) + uz * sin_t, cos_t + uy**2 * (1 - cos_t), uy * uz * (1 - cos_t) - ux * sin_t],
+            [ux * uz * (1 - cos_t) - uy * sin_t, uy * uz * (1 - cos_t) + ux * sin_t, cos_t + uz**2 * (1 - cos_t)],
+        ]
+    )
+
+    # Apply rotational matrix to E1 arm 1 vector to define E1 arm 2
+    e1_arm2 = re1 @ e1_arm1
+
+    # E3 vertex location
+    e3 = e1 + (et_arm_l * e1_arm2)
+
+    # E2 arm vectors
+    e2_arm1 = -e1_arm1 + e1_arm2
+    e2_arm2 = -e1_arm1
+
+    # E3 arm vectors
+    e3_arm1 = -e1_arm2
+    e3_arm2 = -e2_arm1
+
+    # Calculate the vertex positions in geodetic (ellipsoidal) coordinates
+    e2_ellipsoid = np.array(pm.ecef2geodetic(*e2, deg=False))
+    e3_ellipsoid = np.array(pm.ecef2geodetic(*e3, deg=False))
+
+    # Calculate the unit vector angles (azimuth and altitude)
+    e1_arm1_angles = get_unit_vector_angles(e1_arm1, e1_ellipsoid)
+    e1_arm2_angles = get_unit_vector_angles(e1_arm2, e1_ellipsoid)
+    e2_arm1_angles = get_unit_vector_angles(e2_arm1, e2_ellipsoid)
+    e2_arm2_angles = get_unit_vector_angles(e2_arm2, e2_ellipsoid)
+    e3_arm1_angles = get_unit_vector_angles(e3_arm1, e3_ellipsoid)
+    e3_arm2_angles = get_unit_vector_angles(e3_arm2, e3_ellipsoid)
+
+    # Add detectors with PyCBC
+    add_detector_on_earth(
+        name="E1_60deg_" + location_name,
+        latitude=e1_ellipsoid[0],
+        longitude=e1_ellipsoid[1],
+        height=e1_ellipsoid[2],
+        xangle=e1_arm1_angles[0],
+        yangle=e1_arm2_angles[0],
+        xaltitude=e1_arm1_angles[1],
+        yaltitude=e1_arm2_angles[1],
+        xlength=et_arm_l,
+        ylength=et_arm_l,
+    )
+    add_detector_on_earth(  # pylint: disable=duplicate-code
+        name="E2_60deg_" + location_name,
+        latitude=e2_ellipsoid[0],
+        longitude=e2_ellipsoid[1],
+        height=e2_ellipsoid[2],
+        xangle=e2_arm1_angles[0],
+        yangle=e2_arm2_angles[0],
+        xaltitude=e2_arm1_angles[1],
+        yaltitude=e2_arm2_angles[1],
+        xlength=et_arm_l,
+        ylength=et_arm_l,
+    )
+    add_detector_on_earth(
+        name="E3_60deg_" + location_name,
+        latitude=e3_ellipsoid[0],
+        longitude=e3_ellipsoid[1],
+        height=e3_ellipsoid[2],
+        xangle=e3_arm1_angles[0],
+        yangle=e3_arm2_angles[0],
+        xaltitude=e3_arm1_angles[1],
+        yaltitude=e3_arm2_angles[1],
+        xlength=et_arm_l,
+        ylength=et_arm_l,
+    )
+
+    return (
+        Detector("E1_60deg_" + location_name),
+        Detector("E2_60deg_" + location_name),
+        Detector("E3_60deg_" + location_name),
+    )

gwsim/version.py

@@ -0,0 +1,7 @@
+"""Version information for gwsim package."""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+__version__ = version("gwsim")

gwsim/waveform/__init__.py

@@ -0,0 +1,7 @@
+"""Init file for waveform module."""
+
+from __future__ import annotations
+
+from gwsim.waveform.pycbc_wrapper import pycbc_waveform_wrapper
+
+__all__ = ["pycbc_waveform_wrapper"]