static_env

StaticEnv

StaticEnv()

Bases: ABC, Generic[CableT, CircuitFromCableInputSchemaT, CircuitFromCableConstructionalInputSchemaT, CircuitFromCableIdInputSchemaT]

Class that builds a static environment.

Source code in cable_thermal_model/environment/static_env.py

def __init__(self) -> None:
    """Initialize the static environment with empty circuit and cable containers."""
    self.circuits: dict[str, CableCircuit] = {}
    self.circuit_cable_indices: dict[str, list[int]] = {}
    self.cables: dict[CableKey, PosCable] = {}
    self.number_of_cables: int = 0

    self.crossing_cables: bool = False

    self.n_phases: int = 3

get_cables

get_cables() -> dict[CableKey, PosCable]

Returns a dict of all cables in the static environment.

Source code in cable_thermal_model/environment/static_env.py

def get_cables(self) -> dict[CableKey, PosCable]:
    """Returns a dict of all cables in the static environment."""
    return self.cables

get_number_of_cables

get_number_of_cables() -> int

Returns the total number of cables in the static environment.

Source code in cable_thermal_model/environment/static_env.py

def get_number_of_cables(self) -> int:
    """Returns the total number of cables in the static environment."""
    return self.number_of_cables

add_circuit_from_cable_id

add_circuit_from_cable_id(
    circuit_input: CircuitFromCableIdInputSchemaT,
)

Adds the circuit to the environment based on a Cable Id.

Parameters:

Name	Type	Description	Default
circuit_input	CircuitFromCableIdInputSchemaT	CircuitFromCableIdInputSchemaT containing the input parameters for the circuit.	required

Source code in cable_thermal_model/environment/static_env.py

def add_circuit_from_cable_id(
    self,
    circuit_input: CircuitFromCableIdInputSchemaT,
):
    """Adds the circuit to the environment based on a Cable Id.

    Args:
        circuit_input: CircuitFromCableIdInputSchemaT containing the input parameters for the circuit.

    """
    # Build cable from cable id
    cable = self._build_cable_from_circuit_input_from_cable_id(circuit_input)
    multiple_configurations = self.multiple_configurations_from_cable_id(
        multiple_configurations_from_cable_id=circuit_input.multiple_configurations,
        cable_source_file_path=circuit_input.cable_source_file_path,
    )

    # Add circuit to environment from the constructed cable
    self.add_circuit_from_cable(
        self._circuit_from_cable_input_schema_cls(
            cable=cable,
            multiple_configurations=multiple_configurations,
            **circuit_input.model_dump(exclude={"multiple_configurations"}),
        )
    )
    return self

add_circuit_from_cable_constructional_information

add_circuit_from_cable_constructional_information(
    circuit_input: CircuitFromCableConstructionalInputSchemaT,
)

Adds the circuit to the environment based on a Cable Constructional Input Schema.

Parameters:

Name	Type	Description	Default
circuit_input	CircuitFromCableConstructionalInputSchemaT	CircuitFromCableConstructionalInputSchemaT containing the input parameters for the circuit.	required

Source code in cable_thermal_model/environment/static_env.py

def add_circuit_from_cable_constructional_information(
    self,
    circuit_input: CircuitFromCableConstructionalInputSchemaT,
):
    """Adds the circuit to the environment based on a Cable Constructional Input Schema.

    Args:
        circuit_input: CircuitFromCableConstructionalInputSchemaT containing the input parameters for the circuit.

    """
    # Build cable from cable constructional information
    cable = self._build_cable_from_circuit_input_from_cable_constructional_information(circuit_input)
    multiple_configurations = self.multiple_configurations_from_cable_constructional_input(
        multiple_configurations_from_cable_constructional_input=circuit_input.multiple_configurations,
    )

    # Add circuit to environment from the constructed cable
    self.add_circuit_from_cable(
        self._circuit_from_cable_input_schema_cls(
            cable=cable,
            multiple_configurations=multiple_configurations,
            **circuit_input.model_dump(exclude={"multiple_configurations"}),
        )
    )
    return self

add_circuit_from_cable

add_circuit_from_cable(
    circuit_input: CircuitFromCableInputSchemaT,
)

Add a cable circuit consisting of one or three cables to the environment based on a given cable instance.

Parameters:

Name	Type	Description	Default
circuit_input	CircuitFromCableInputSchemaT	CircuitInputSchemaT containing the input parameters for the circuit, including a cable instance.	required

Source code in cable_thermal_model/environment/static_env.py

def add_circuit_from_cable(
    self,
    circuit_input: CircuitFromCableInputSchemaT,
):
    """Add a cable circuit consisting of one or three cables to the environment based on a given cable instance.

    Args:
       circuit_input: CircuitInputSchemaT containing the input
           parameters for the circuit, including a cable instance.

    """
    # If circuit_type is not provided, determine it
    if circuit_input.circuit_type is None:
        circuit_input.circuit_type = self.get_circuit_type(cable=circuit_input.cable)
    else:
        # Warning if unrealistic combination is chosen by user
        self._warn_for_unrealistic_circuits(circuit_input.cable, circuit_input.circuit_type)

    if (
        circuit_input.cable.layer_metrics.pipe
        and circuit_input.cable.layer_metrics.pipe.trefoil_circuit_in_single_pipe
        and circuit_input.circuit_type
        not in [
            CircuitType.Trefoil,
        ]
    ):
        raise NotImplementedError(
            f"Three cables in one pipe not implemented for circuit type: {circuit_input.circuit_type}"
        )

    if circuit_input.circuit_name in self.circuits:
        raise ValueError(
            f"{circuit_input.circuit_name} already exists in environment. Circuit names should be unique."
        )

    # Add circuit to domain based on cable object
    self.circuits[circuit_input.circuit_name] = CircuitBuilder().from_cable(circuit_input=circuit_input)

    if circuit_input.multiple_configurations:
        if self.circuits[circuit_input.circuit_name].bonding is not BondingType.TwoSided:
            raise NotImplementedError(
                "Circuit is not bonded on two sides, no circulating currents are assumed. "
                f"Multiple configurations are not implemented for bonding type {circuit_input.bonding_type}."
            )
        self._validate_local_configuration(
            self.circuits[circuit_input.circuit_name],
            [self._generate_circuit_configuration(config) for config in circuit_input.multiple_configurations],
        )
        weighted_screen_impedance = self._generate_weighted_screen_impedance(
            local_screen_resistance=self.circuits[circuit_input.circuit_name]
            .cables[0]
            .cable._get_resistance_screen(Ts=ELECTRIC_RESISTANCE_REFERENCE_TEMPERATURE),
            multiple_configurations=circuit_input.multiple_configurations,
        )
        self.circuits[circuit_input.circuit_name].set_weighted_screen_impedance(weighted_screen_impedance)

    circuit_cables = self.circuits[circuit_input.circuit_name].cables
    self.circuit_cable_indices[circuit_input.circuit_name] = [
        self.number_of_cables + n for n, _ in enumerate(circuit_cables)
    ]
    self._add_cables_to_cable_dict(circuit_cables)

    return self

get_circuit_type staticmethod

get_circuit_type(cable: AbstractCable) -> CircuitType

Determines probable circuit type by number of conductors in the cable.

Source code in cable_thermal_model/environment/static_env.py

@staticmethod
def get_circuit_type(cable: AbstractCable) -> CircuitType:
    """Determines probable circuit type by number of conductors in the cable."""
    if isinstance(cable, FDCableTrefoilCircuitInSinglePipe | FDCableTrefoilCircuitInSinglePipeInAir):
        return CircuitType.Trefoil
    if cable.conductor.number_of_conductors == CableConductorCount.Three:
        return CircuitType.Single
    if cable.conductor.number_of_conductors == CableConductorCount.One:
        warnings.warn(
            '"trefoil" is assumed to be the circuit_type, since the cable has a single conductor. '
            'If "linear" was meant as circuit_type, please specify.',
            stacklevel=2,
        )
        return CircuitType.Trefoil

    raise NotImplementedError(f"Number of conductors '{cable.conductor.number_of_conductors}' not supported.")

get_cable

get_cable(cable_key: CableKey) -> PosCable

Gets the Cable-object corresponding to the cable_name from the environment.

Source code in cable_thermal_model/environment/static_env.py

def get_cable(self, cable_key: CableKey) -> PosCable:
    """Gets the Cable-object corresponding to the cable_name from the environment."""
    return self.cables[cable_key]

multiple_configurations_from_cable_id staticmethod

multiple_configurations_from_cable_id(
    multiple_configurations_from_cable_id: list[
        CircuitConfigurationFromCableId
    ],
    cable_source_file_path: Path,
) -> list[CircuitConfiguration]

Generates multiple circuit configurations based on a list of CircuitConfigurationFromCableId.

Parameters:

Name	Type	Description	Default
multiple_configurations_from_cable_id	list[CircuitConfigurationFromCableId]	A list of CircuitConfigurationFromCableId, specifying the cable ids and lengths of the different configurations.	required
cable_source_file_path	Path	Name of the file containing the cable specifications. This file has to be located in the data directory and must either be an excel or csv file.	required

Returns:

Type	Description
list[CircuitConfiguration]	list[CircuitConfiguration]: A list of CircuitConfiguration objects that can be used in the multiple_configurations argument of add_circuit_from_cable or add_circuit_from_cable_id.

Source code in cable_thermal_model/environment/static_env.py

@staticmethod
def multiple_configurations_from_cable_id(
    multiple_configurations_from_cable_id: list[CircuitConfigurationFromCableId], cable_source_file_path: Path
) -> list[CircuitConfiguration]:
    """Generates multiple circuit configurations based on a list of CircuitConfigurationFromCableId.

    Args:
        multiple_configurations_from_cable_id: A list of
            CircuitConfigurationFromCableId, specifying the cable ids and
            lengths of the different configurations.
        cable_source_file_path: Name of the file containing the cable
            specifications. This file has to be located in the data
            directory and must either be an excel or csv file.

    Returns:
        list[CircuitConfiguration]: A list of CircuitConfiguration objects that can be used in
            the multiple_configurations argument of add_circuit_from_cable or
            add_circuit_from_cable_id.

    """
    multiple_configurations: list[CircuitConfiguration] = []
    for config in multiple_configurations_from_cable_id:
        cable = CableBuilder.build_cable_from_cable_id(
            cable_id=config.cable_id,
            fd_cable_class=config.fd_cable_class,
            pipe=config.pipe,
            cable_source_file_path=cable_source_file_path,
        )
        multiple_configurations.append(
            CircuitConfiguration(
                cable=cable,
                length=config.length,
                circuit_type=config.circuit_type,
                dist=config.dist,
            )
        )
    return multiple_configurations

multiple_configurations_from_cable_constructional_input staticmethod

multiple_configurations_from_cable_constructional_input(
    multiple_configurations_from_cable_constructional_input: list[
        CircuitConfigurationFromCableConstructionalInputSchema
    ],
) -> list[CircuitConfiguration]

Generate multiple configurations from constructional input schemas.

Parameters:

Name	Type	Description	Default
multiple_configurations_from_cable_constructional_input	list[CircuitConfigurationFromCableConstructionalInputSchema]	A list of CircuitConfigurationFromCableConstructionalInputSchema, specifying the cable constructional input schemas and lengths of the different configurations.	required

Returns:

Type	Description
list[CircuitConfiguration]	list[CircuitConfiguration]: A list of CircuitConfiguration objects that can be used in the multiple_configurations argument of add_circuit_from_cable or add_circuit_from_cable_id.

Source code in cable_thermal_model/environment/static_env.py

@staticmethod
def multiple_configurations_from_cable_constructional_input(
    multiple_configurations_from_cable_constructional_input: list[
        CircuitConfigurationFromCableConstructionalInputSchema
    ],
) -> list[CircuitConfiguration]:
    """Generate multiple configurations from constructional input schemas.

    Args:
        multiple_configurations_from_cable_constructional_input: A list
            of CircuitConfigurationFromCableConstructionalInputSchema,
            specifying the cable constructional input schemas and lengths
            of the different configurations.

    Returns:
        list[CircuitConfiguration]: A list of CircuitConfiguration objects that can be used in
            the multiple_configurations argument of add_circuit_from_cable or
            add_circuit_from_cable_id.

    """
    multiple_configurations: list[CircuitConfiguration] = []
    for config in multiple_configurations_from_cable_constructional_input:
        cable = CableBuilder.build_cable(
            cable_constructional_input=config.cable_constructional_information,
            fd_cable_class=config.fd_cable_class,
            pipe=config.pipe,
        )
        multiple_configurations.append(
            CircuitConfiguration(
                cable=cable,
                length=config.length,
                circuit_type=config.circuit_type,
                dist=config.dist,
            )
        )
    return multiple_configurations