plaid.containers.sample¶

@model_validator(mode="after")
def initialize_defaults(self) -> "Sample":
    """Initialize the default manager if not already set."""
    if self.defaults is None:
        self.defaults = DefaultManager(self)
    return self

def copy(self) -> Self:  # pyright: ignore[reportIncompatibleMethodOverride]
    """Create a deep copy of the current `Sample` instance.

    Usage of `model_copy(deep=True)` from Pydantic to ensure all internal data is deeply copied.

    Returns:
        A new `Sample` instance with all internal data (scalars, fields, meshes, etc.)
        deeply copied to ensure full isolation from the original.

    Note:
        This operation may be memory-intensive for large samples.
    """
    return self.model_copy(deep=True)

def get_all_features_identifiers_by_type(
    self, feature_type: AUTHORIZED_FEATURE_TYPES_T
) -> list[str]:
    """Get all features identifiers of a given type from the sample.

    Args:
        feature_type (str): Type of features to return

    Returns:
        list[FeatureIdentifier]: A list of dictionaries containing the identifiers of a given type of all features in the sample.
    """
    assert feature_type in AUTHORIZED_FEATURE_TYPES, "feature_type not known"
    if feature_type == "scalar":
        return self.get_global_names()
    elif feature_type == "field":
        return self.get_field_names()
    elif feature_type == "nodes":
        return [
            "Coordinate" + n
            for _, n in zip(range(self.get_physical_dim()), ["X", "Y", "Z"])
        ]

def get_all_features_by_type(self, type: str) -> list[str]:
    """Get the list of all CGNS paths of features of a given type (eg 'field', 'global', 'coordinate', etc...)."""
    flat_tree, _ = CGH.flatten_cgns_tree(self.get_tree())
    out = []
    for path in flat_tree:
        feature_details = get_feature_details_from_path(path)
        if feature_details["type"] == type:
            if type == "global":
                if feature_details["sub_type"] == "scalar":
                    out.append(path)
            else:
                out.append(path)
    return out

def get_feature_by_path(
    self, path: str, time: Optional[float | np.floating] = None
) -> np.number | np.ndarray | None:
    """Retrieve a feature value from the sample's CGNS mesh using a CGNS-style url.

    Args:
        path (str): CGNS node path relative to the mesh root (for example
            "BaseName/ZoneName/GridCoordinates/CoordinateX" or
            "BaseName/ZoneName/Solution/FieldName").
        time (Optional[float | np.floating], optional): Time selection for the mesh. If an integer,
            it is interpreted via the sample time-assignment logic
            (see ``resolve_time``). If None, the default time
            assignment is used. Defaults to None.

    Returns:
        Feature: The value stored at the given CGNS path. This may be a numpy array, a scalar, or None if the node has no value.

    Note:
        - This is a thin wrapper around CGNS.PAT.cgnsutils.getValueByPath and Sample.get_tree(time). Callers should handle a returned None when the path or value does not exist.
        - For field-like features, prefer using Sample.get_field which applies additional validation and selection logic.
    """
    time = self.resolve_time(time)
    return CGU.getValueByPath(self.get_tree(time), path)

def add_feature(
    self,
    feature_path: str,
    feature: ScalarOrArrayOrStr,
) -> Self:
    """Add a feature to current sample.

    This method applies updates to scalars, fields, or nodes
    using feature identifiers, and corresponding feature data.

    Args:
        feature_path (str): A feature path string.
        feature (Feature): Feature value corresponding to ``feature_path``.

    Returns:
        Self: The updated sample

    Raises:
        AssertionError: If types are inconsistent or identifiers contain unexpected keys.
    """
    # feature_type, feature_details = get_feature_type_and_details_from(
    #    feature_identifier
    # )

    from .utils import get_feature_details_from_path

    feature_details = get_feature_details_from_path(feature_path)

    feature_type = feature_details.pop("type")
    _ = feature_details.pop("sub_type", None)

    if feature_type == "global":
        if safe_len(feature) == 1:
            feature = feature[0]
        self.add_global(**feature_details, global_array=feature)
    elif feature_type == "field":
        self.add_field(**feature_details, field=feature, warning_overwrite=False)
    elif feature_type == "coordinate":
        if feature_details.get("name", None) is not None:  # pragma: no cover
            raise ValueError("Must set the 3 coordinate at the same time")
        physical_dim_arg = {
            k: v for k, v in feature_details.items() if k in ["base", "time"]
        }
        phys_dim = self.get_physical_dim(**physical_dim_arg)
        self.set_nodes(**feature_details, nodes=feature.reshape((-1, phys_dim)))
    else:  # pragma: no cover
        print(feature_details)
        raise RuntimeError(f"feature_type not allowed : {feature_type}")

    return self

def del_feature_by_path(self, path: str, time: Optional[float] = None) -> CGNSTree:
    """Delete a feature/node by CGNS-style path from the sample mesh tree.

    Args:
        path (str): CGNS node path relative to the mesh root (for example
            "BaseName/ZoneName/GridCoordinates/CoordinateX" or
            "BaseName/ZoneName/Solution/FieldName").
        time (Optional[int], optional): Time selection for the mesh. If an integer,
            it is interpreted via the sample time-assignment logic
            (see ``resolve_time``). If None, the default time
            assignment is used. Defaults to None.

    Returns:
        Feature: Updated tree after node deletion.

    Note:
        - This method resolves the requested time and deletes the node at
          ``path`` when present.
    """
    time = self.resolve_time(time)
    #        return CGU.getValueByPath(self.get_tree(time), path)

    updated_tree = None
    node = CGU.getNodeByPath(self.get_tree(time), path)
    if node is not None:
        updated_tree = CGU.nodeDelete(self.get_tree(time), node)

    # If the function reaches here, the field was not found
    if updated_tree is None:  # pragma: no cover
        raise KeyError(f"There is no field with name {path} in the specified zone.")

    return updated_tree

def update_features_by_path(
    self,
    feature_identifiers: str | Sequence[str],
    features: Union[ScalarDType, list[ScalarDType]],
    in_place: bool = False,
) -> Self:
    """Update one or several features of the sample by their identifier(s).

    This method applies updates to scalars, fields, or nodes
    using feature identifiers, and corresponding feature data. When `in_place=False`, a deep copy of the sample is created
    before applying updates, ensuring full isolation from the original.

    Args:
        feature_identifiers (FeatureIdentifier or list of FeatureIdentifier): One or more feature identifiers.
        features (dict of Feature or list of Feature): One or more features corresponding
            to the identifiers.
        in_place (bool, optional): If True, modifies the current sample in place.
            If False, returns a deep copy with updated features.

    Returns:
        Self: The updated sample (either the current instance or a new copy).

    Raises:
        AssertionError: If types are inconsistent or identifiers contain unexpected keys.
    """
    if not isinstance(feature_identifiers, list):
        feature_identifiers = [feature_identifiers]
        features = [features]
    assert len(feature_identifiers) == len(features)
    for i_id, feat_id in enumerate(feature_identifiers):
        feature_identifiers[i_id] = str(feat_id)

    sample = self if in_place else self.copy()

    for feat_id, feat in zip(feature_identifiers, features):
        sample.add_feature(feat_id, feat)

    return sample

def save_to_dir(
    self, path: Union[str, Path], overwrite: bool = False, memory_safe: bool = False
) -> None:
    """Save the Sample in directory `path`.

    Args:
        path (Union[str,Path]): relative or absolute directory path.
        overwrite (bool): target directory overwritten if True.
        memory_safe (bool): use pyCGNS save in a subprocess (requires an additional pickle of the sample) if True.
    """
    path = Path(path)

    if path.is_dir():
        if overwrite:
            shutil.rmtree(path)
            logger.warning(f"Existing {path} directory has been reset.")
        elif any(path.iterdir()):
            raise ValueError(
                f"directory {path} already exists and is not empty. Set `overwrite` to True if needed."
            )

    path.mkdir(exist_ok=True)

    mesh_dir = path / "meshes"

    if self.data:
        mesh_dir.mkdir()
        for i, time in enumerate(self.data.keys()):
            outfname = mesh_dir / f"mesh_{i:09d}.cgns"
            if memory_safe:
                tmpfile = mesh_dir / f"mesh_{i:09d}.pkl"
                with open(tmpfile, "wb") as f:
                    pickle.dump(self.data[time], f)

                cmd = [sys.executable, str(CGNS_WORKER), tmpfile, str(outfname)]
                subprocess.run(cmd)
                logger.debug(f"save -> {outfname}")

            else:
                status = CGM.save(str(outfname), self.data[time])
                logger.debug(f"save -> {status=}")

@classmethod
def load_from_dir(cls, path: Union[str, Path]) -> Self:
    """Load the Sample from directory `path`.

    This is a class method, you don't need to instantiate a `Sample` first.

    Args:
        path (Union[str,Path]): Relative or absolute directory path.

    Returns:
        Sample

    Example:
        .. code-block:: python

            from plaid import Sample
            sample = Sample.load_from_dir(dir_path)
            print(sample)
            >>> Sample(2 scalars, 1 timestamp, 5 fields)

    Note:
        It calls :meth:`Sample.load` method during execution.
    """
    path = Path(path)
    instance = cls()
    instance.load(path)
    return instance

def load(self, path: Union[str, Path]) -> None:
    """Load the Sample from directory `path`.

    Args:
        path (Union[str,Path]): Relative or absolute directory path.

    Raises:
        FileNotFoundError: Triggered if the provided directory does not exist.
        FileExistsError: Triggered if the provided path is a file instead of a directory.

    Example:
        .. code-block:: python

            from plaid import Sample
            sample = Sample()
            sample.load(path)
            print(sample)
            >>> Sample(3 scalars, 1 timestamp, 3 fields)

    """
    path = Path(path)

    if not path.exists():
        raise FileNotFoundError(f'Directory "{path}" does not exist. Abort')

    if not path.is_dir():
        raise FileExistsError(f'"{path}" is not a directory. Abort')

    meshes_dir = path / "meshes"
    if meshes_dir.is_dir():
        meshes_names = list(meshes_dir.glob("*"))
        nb_meshes = len(meshes_names)
        for i in range(nb_meshes):
            tree, _, _ = CGM.load(str(meshes_dir / f"mesh_{i:09d}.cgns"))
            time = CGH.get_time_values(tree)

            (self.data[time],) = (tree,)

def __str__(self) -> str:
    """Return a string representation of the sample.

    Returns:
        str: A string representation of the overview of sample content.
    """
    # TODO rewrite using self.get_all_features_identifiers()
    str_repr = "Sample("

    # globals
    nb_globals = len(self.get_global_names())
    str_repr += f"{nb_globals} global{'' if nb_globals == 1 else 's'}, "

    # fields
    times = self.get_all_time_values()
    nb_timestamps = len(times)
    str_repr += f"{nb_timestamps} timestamp{'' if nb_timestamps == 1 else 's'}, "

    field_names = set()
    for time in times:
        ## Need to include all possible location within the count
        base_names = self.get_base_names(time=time)
        for bn in base_names:
            zone_names = self.get_zone_names(base=bn, time=time)
            for zn in zone_names:
                for location in CGNS_FIELD_LOCATIONS:
                    field_names = field_names.union(
                        self.get_field_names(
                            location=location, zone=zn, base=bn, time=time
                        )
                    )
    nb_fields = len(field_names)
    str_repr += f"{nb_fields} field{'' if nb_fields == 1 else 's'}, "

    if str_repr[-2:] == ", ":
        str_repr = str_repr[:-2]
    str_repr = str_repr + ")"

    return str_repr

def summarize(self) -> str:
    """Provide detailed summary of the Sample content, showing feature names and mesh information.

    This provides more detailed information than the __repr__ method,
    including the name of each feature.

    Returns:
        str: A detailed string representation of the sample content.

    Example:
        .. code-block:: bash

            Sample Summary:
            ==================================================
            Scalars (8):
            - Pr: 0.9729006564945664
            - Q: 0.2671142611487964
            - Tr: 0.9983394202616822
            - angle_in: 45.5066666666667
            - angle_out: 61.89519547386746
            - eth_is: 0.21238326882538008
            - mach_out: 0.81003
            - power: 0.0019118127462776008

            Meshes (1 timestamps):
            Time: 0.0
                Base: Base_2_2
                    Nodes (36421)
                    Tags (6): Intrado (122), Extrado (122), Inflow (121), Outflow (121), Periodic_1 (120), Periodic_2 (238)
                    Fields (7): ro, sdf, rou, nut, mach, roe, rov
                    Elements (36000)
                    QUAD_4 (36000)
                Base: Base_1_2
                    Nodes (244)
                    Fields (1): M_iso
                    Elements (242)
                    BAR_2 (242)
    """
    summary = "Sample Summary:\n"
    summary += "=" * 50 + "\n"

    # Scalars with names
    scalar_names = self.get_global_names()
    if scalar_names:
        summary += f"Scalars ({len(scalar_names)}):\n"
        for name in scalar_names:
            value = self.get_global(name)
            summary += f"  - {name}: {value}\n"
        summary += "\n"

    # Mesh information
    times = self.get_all_time_values()
    summary += f"Meshes ({len(times)} timestamps):\n"
    if times:
        for time in times:
            summary += f"    Time: {time}\n"
            base_names = self.get_base_names(time=time)
            for base_name in base_names:
                summary += f"        Base: {base_name}\n"
                zone_names = self.get_zone_names(base=base_name, time=time)
                for zone_name in zone_names:
                    summary += f"            Zone: {zone_name}\n"
                    # Nodes, nodal tags and fields at verticies
                    nodes = self.get_nodes(
                        zone=zone_name, base=base_name, time=time
                    )
                    if nodes is not None:
                        nb_nodes = nodes.shape[0]
                        nodal_tags = self.get_nodal_tags(
                            zone=zone_name, base=base_name, time=time
                        )
                        summary += f"                Nodes ({nb_nodes})\n"
                        if len(nodal_tags) > 0:
                            summary += f"                Tags ({len(nodal_tags)}): {', '.join([f'{k} ({len(v)})' for k, v in nodal_tags.items()])}\n"

                    for location in CGNS_FIELD_LOCATIONS:
                        field_names = self.get_field_names(
                            location=location,
                            zone=zone_name,
                            base=base_name,
                            time=time,
                        )
                        if field_names:
                            summary += f"                Location: {location}\n                    Fields ({len(field_names)}): {', '.join(field_names)}\n"

                    # Elements and fields at elements
                    elements = self.get_elements(
                        zone=zone_name, base=base_name, time=time
                    )
                    summary += f"                Elements ({sum([v.shape[0] for v in elements.values()])})\n"
                    if len(elements) > 0:
                        summary += f"                    {', '.join([f'{k} ({v.shape[0]})' for k, v in elements.items()])}\n"

    return summary

def check_completeness(self) -> str:
    """Check the completeness of features in this sample.

    Returns:
        str: A report on feature completeness.

    Example:
        .. code-block:: bash

            Sample Completeness Check:
            ==============================
            Has scalars: True
            Has meshes: True
            Total unique fields: 8
            Field names: M_iso, mach, nut, ro, roe, rou, rov, sdf
    """
    report = "Sample Completeness Check:\n"
    report += "=" * 30 + "\n"

    # Check if sample has basic features
    has_scalars = len(self.get_global_names()) > 0
    has_meshes = len(self.get_all_time_values()) > 0

    report += f"Has scalars: {has_scalars}\n"
    report += f"Has meshes: {has_meshes}\n"

    if has_meshes:
        times = self.get_all_time_values()
        total_fields = set()
        for time in times:
            base_names = self.get_base_names(time=time)
            for base_name in base_names:
                zone_names = self.get_zone_names(base=base_name, time=time)
                for zone_name in zone_names:
                    for location in CGNS_FIELD_LOCATIONS:
                        field_names = self.get_field_names(
                            location=location,
                            zone=zone_name,
                            base=base_name,
                            time=time,
                        )
                        total_fields.update(field_names)

        report += f"Total unique fields: {len(total_fields)}\n"
        if total_fields:
            report += f"Field names: {', '.join(sorted(total_fields))}\n"

    return report

def set_default_time(self, time: float) -> None:
    """Set the default active time. Calls the DefaultManager to set the default time.

    Args:
        time (float): The time to set as the default active time.
    """
    self.defaults.set_default_time(time)

def set_default_base(self, base: str, time: Optional[float] = None) -> None:
    """Set the default active base. Calls the DefaultManager to set the default base.

    Args:
        base (str): The base name to set as the default active base.
        time (float, optional): The time at which to set the default base. Defaults to None.
    """
    self.defaults.set_default_base(base, time=time)

def set_default_zone_base(
    self, zone: str, base: str, time: Optional[float] = None
) -> None:
    """Set the default active zone within a base. Calls the DefaultManager to set the default zone and base.

    Args:
        zone (str): The zone name to set as the default active zone.
        base (str): The base name in which the zone is located.
        time (float, optional): The time at which to set the default zone and base. Defaults to None.
    """
    self.defaults.set_default_zone_base(zone, base, time=time)

def resolve_time(self, time: Optional[float] = None) -> float:
    """Get the resolved time assignment. Calls the DefaultManager to resolve the time.

    Args:
        time (float, optional): The time to resolve. Defaults to None.

    Returns:
        float: The resolved time.
    """
    return self.defaults.resolve_time(time)

def resolve_base(
    self, base: Optional[str] = None, time: Optional[float] = None
) -> Optional[str]:
    """Get the resolved base assignment. Calls the DefaultManager to resolve the base.

    Args:
        base (str, optional): The base name to resolve. Defaults to None.
        time (float, optional): The time at which to resolve the base. Defaults to None.

    Returns:
        Optional[str]: The resolved base name.
    """
    return self.defaults.resolve_base(base=base, time=time)

def resolve_zone(
    self,
    zone: Optional[str] = None,
    base: Optional[str] = None,
    time: Optional[float] = None,
) -> Optional[str]:
    """Get the resolved zone assignment. Calls the DefaultManager to resolve the zone.

    Args:
        zone (str, optional): The zone name to resolve. Defaults to None.
        base (str, optional): The base name in which the zone is located. Defaults to None.
        time (float, optional): The time at which to resolve the zone. Defaults to None.

    Returns:
        Optional[str]: The resolved zone name.
    """
    return self.defaults.resolve_zone(zone=zone, base=base, time=time)

def get_all_time_values(self) -> list[float]:
    """Retrieve all time steps corresponding to the meshes, if available.

    Returns:
        list[float]: A list of all available time steps.
    """
    return list(self.data.keys())

def init_tree(self, time: Optional[float] = None) -> CGNSTree:
    """Initialize a CGNS tree structure at a specified time step or create a new one if it doesn't exist.

    Args:
        time (float, optional): The time step for which to initialize the CGNS tree structure. If a specific time is not provided, the method will display the tree structure for the default time step.

    Returns:
        CGNSTree (list): The initialized or existing CGNS tree structure for the specified time step.
    """
    time = self.resolve_time(time)

    if not self.data:
        self.data = {time: CGL.newCGNSTree()}
    elif time not in self.data:
        self.data[time] = CGL.newCGNSTree()

    return self.data[time]

def get_tree(
    self, time: Optional[float] = None, only_mesh: bool = False
) -> Optional[CGNSTree]:
    """Retrieve the CGNS tree structure for a specified time step, if available.

    Args:
        time (float, optional): The time step for which to retrieve the CGNS tree structure. If a specific time is not provided, the method will display the tree structure for the default time step.
        only_mesh (bool): If True, features of type global and fields are removed from the sample

    Returns:
        CGNSTree: The CGNS tree structure for the specified time step if available; otherwise, returns None.
    """
    if not self.data:
        return None

    time = self.resolve_time(time)
    tree = self.data[time]
    if only_mesh:
        flat_tree, cgns_types = CGH.flatten_cgns_tree(tree)
        updated_flat_tree = {
            path: value
            for path, value in flat_tree.items()
            if get_feature_details_from_path(path)["type"]
            not in ["global", "field"]
        }
        tree = CGH.unflatten_cgns_tree(updated_flat_tree, cgns_types)
    return tree

def set_trees(self, meshes: dict[float, CGNSTree]) -> None:
    """Set all meshes with their corresponding time step.

    Args:
        meshes (dict[float,CGNSTree]): Collection of time step with its corresponding CGNSTree.

    Raises:
        KeyError: If there is already a CGNS tree set.
    """
    if not self.data:
        self.data = meshes
    else:
        raise KeyError(
            "meshes is already set, you cannot overwrite it, delete it first or extend it with `Sample.add_tree`"
        )

def add_tree(
    self, tree: CGNSTree, time: Optional[float] = None, in_place: bool = True
) -> CGNSTree:
    """Merge a CGNS tree into the tree stored at a given time.

    If there is no tree at ``time``, ``tree`` is stored directly. Otherwise, Base
    nodes from ``tree`` are appended only when their name does not already exist in
    the destination tree. Bases with duplicate names are ignored and a warning is
    emitted.

    Args:
        tree (CGNSTree): CGNS tree to add.
        time (float, optional): Time step at which the tree is added. If omitted,
            the default time resolution is used.
        in_place (bool, optional): Controls ownership of the input tree. When
            ``True`` (default), the provided object may be stored/used directly.
            When ``False``, the input tree is deep-copied before insertion.

    Raises:
        ValueError: If ``tree`` is an empty list.

    Returns:
        CGNSTree: The resulting tree for the resolved ``time``.
    """
    if tree == []:
        raise ValueError("CGNS Tree should not be an empty list")

    if not in_place:
        tree = deepcopy(tree)

    def _iter_node_names(node: CGNSNode) -> list[str]:
        names = []
        if isinstance(node, list) and len(node) > 0:
            if isinstance(node[0], str):
                names.append(node[0])
            if len(node) > 2 and isinstance(node[2], list):
                for child in node[2]:
                    names.extend(_iter_node_names(child))
        return names

    all_names = _iter_node_names(tree)
    if all_names and all_names[0] == "CGNSTree":
        all_names = all_names[1:]
    _check_names(all_names)

    time = self.resolve_time(time)

    if not self.data:
        self.data = {time: tree}
    elif time not in self.data:
        self.data[time] = tree
    else:
        # TODO: gérer le cas où il y a des bases de mêmes noms... + merge
        # récursif des nœuds
        local_bases = self.get_base_names(time=time)
        base_nodes = CGU.getNodesFromTypeSet(tree, "CGNSBase_t")
        for _, node in base_nodes:
            if node[__NAME__] not in local_bases:  # pragma: no cover
                self.data[time][__CHILDREN__].append(node)
            else:
                logger.warning(
                    f"base <{node[__NAME__]}> already exists in self._tree --> ignored"
                )

    base_names = self.get_base_names(time=time)
    for base_name in base_names:
        base_node = self.get_base(base_name, time=time)
        if CGU.getValueByPath(base_node, "Time/TimeValues") is None:
            baseIterativeData_node = CGL.newBaseIterativeData(base_node, "Time", 1)
            TimeValues_node = CGU.newNode(
                "TimeValues", None, [], CGK.DataArray_ts, baseIterativeData_node
            )
            CGU.setValue(TimeValues_node, np.array([time]))

    return self.data[time]

def del_tree(self, time: float) -> CGNSTree:
    """Delete the CGNS tree for a specific time.

    Args:
        time (float): The time step for which to delete the CGNS tree structure.

    Raises:
        KeyError: There is no CGNS tree in this Sample / There is no CGNS tree for the provided time.

    Returns:
        CGNSTree: The deleted CGNS tree.
    """
    if not self.data:
        raise KeyError("There is no CGNS tree in this sample.")

    if time not in self.data:
        raise KeyError(f"There is no CGNS tree for time {time}.")

    return self.data.pop(time)

def get_topological_dim(
    self, base: Optional[str] = None, time: Optional[float] = None
) -> int:
    """Get the topological dimension of a base node at a specific time.

    Args:
        base (str, optional): The name of the base node for which to retrieve the topological dimension. Defaults to None.
        time (float, optional): The time at which to retrieve the topological dimension. Defaults to None.

    Raises:
        ValueError: If there is no base node with the specified `base` at the given `time` in this sample.

    Returns:
        int: The topological dimension of the specified base node at the given time.
    """
    # get_base will look for default time and base
    base_node = self.get_base(base, time)

    if base_node is None:  # pragma: no cover
        raise ValueError(
            f"There is no base called {base} at the time {time} in this sample."
        )

    return int(base_node[1][0])

def get_physical_dim(
    self, base: Optional[str] = None, time: Optional[float] = None
) -> int:
    """Get the physical dimension of a base node at a specific time.

    Args:
        base (str, optional): The name of the base node for which to retrieve the topological dimension. Defaults to None.
        time (float, optional): The time at which to retrieve the topological dimension. Defaults to None.

    Raises:
        ValueError: If there is no base node with the specified `base` at the given `time` in this sample.

    Returns:
        int: The topological dimension of the specified base node at the given time.
    """
    base_node = self.get_base(base, time)
    if base_node is None:  # pragma: no cover
        raise ValueError(
            f"There is no base called {base} at the time {time} in this sample."
        )

    return int(base_node[1][1])