VeraGridEngine.Compilers package

Subpackages

• VeraGridEngine.Compilers.Gslv package
  • Subpackages
    • VeraGridEngine.Compilers.Gslv.Devices package
      • Submodules
      • VeraGridEngine.Compilers.Gslv.Devices.areas module
      • VeraGridEngine.Compilers.Gslv.Devices.associations module
      • VeraGridEngine.Compilers.Gslv.Devices.batteries module
      • VeraGridEngine.Compilers.Gslv.Devices.branch_groups module
      • VeraGridEngine.Compilers.Gslv.Devices.buses module
      • VeraGridEngine.Compilers.Gslv.Devices.contingencies module
      • VeraGridEngine.Compilers.Gslv.Devices.controllable_shunts module
      • VeraGridEngine.Compilers.Gslv.Devices.countries module
      • VeraGridEngine.Compilers.Gslv.Devices.dc_lines module
      • VeraGridEngine.Compilers.Gslv.Devices.facilities module
      • VeraGridEngine.Compilers.Gslv.Devices.generators module
      • VeraGridEngine.Compilers.Gslv.Devices.hvdc_line module
      • VeraGridEngine.Compilers.Gslv.Devices.investments module
      • VeraGridEngine.Compilers.Gslv.Devices.lines module
      • VeraGridEngine.Compilers.Gslv.Devices.loads module
      • VeraGridEngine.Compilers.Gslv.Devices.market_units module
      • VeraGridEngine.Compilers.Gslv.Devices.modelling_authorities module
      • VeraGridEngine.Compilers.Gslv.Devices.municipalities module
      • VeraGridEngine.Compilers.Gslv.Devices.regions module
      • VeraGridEngine.Compilers.Gslv.Devices.shunts module
      • VeraGridEngine.Compilers.Gslv.Devices.static_generators module
      • VeraGridEngine.Compilers.Gslv.Devices.substations module
      • VeraGridEngine.Compilers.Gslv.Devices.transformers module
      • VeraGridEngine.Compilers.Gslv.Devices.transformers3w module
      • VeraGridEngine.Compilers.Gslv.Devices.voltage_levels module
      • VeraGridEngine.Compilers.Gslv.Devices.vsc module
      • VeraGridEngine.Compilers.Gslv.Devices.zones module
      • Module contents
    • VeraGridEngine.Compilers.Gslv.Simulations package
      • Submodules
      • VeraGridEngine.Compilers.Gslv.Simulations.contingencies module
      • VeraGridEngine.Compilers.Gslv.Simulations.investments module
      • VeraGridEngine.Compilers.Gslv.Simulations.linear module
      • VeraGridEngine.Compilers.Gslv.Simulations.opf module
      • VeraGridEngine.Compilers.Gslv.Simulations.power_flow module
      • VeraGridEngine.Compilers.Gslv.Simulations.power_flow_3ph module
      • Module contents
  • Submodules
  • VeraGridEngine.Compilers.Gslv.activation module
    • install_gslv_license()
  • VeraGridEngine.Compilers.Gslv.common module
    • apply_three_phase_load_data()
    • apply_three_phase_shunt_data()
    • convert_tap_module_control_mode_dict()
    • convert_tap_module_control_mode_lst()
    • convert_tap_phase_control_mode_dict()
    • convert_tap_phase_control_mode_lst()
    • fill_profile()
    • fill_profile_with_array()
    • get_gslv_mip_solvers_list()
    • get_single_three_phase_snapshot_index()
    • set_generator_associations()
    • set_injection_associations()
  • VeraGridEngine.Compilers.Gslv.compare module
    • CheckArr()
    • CheckArrEq()
    • compare_branch_parent_data()
    • compare_nc()
    • convert_arr()
    • convert_gslv_arr_to_idx()
  • VeraGridEngine.Compilers.Gslv.conversion module
    • FakeAdmittances
      • FakeAdmittances.Ybus
      • FakeAdmittances.Yf
      • FakeAdmittances.Yt
    • GslvDicts
      • GslvDicts.area_dict
      • GslvDicts.branch_groups_dict
      • GslvDicts.con_groups_dict
      • GslvDicts.country_dict
      • GslvDicts.emission_gas_dict
      • GslvDicts.facility_dict
      • GslvDicts.fuel_dict
      • GslvDicts.inv_groups_dict
      • GslvDicts.market_unit_dict
      • GslvDicts.modelling_authorities_dict
      • GslvDicts.municipalities_dict
      • GslvDicts.regions_dict
      • GslvDicts.substation_dict
      • GslvDicts.technology_dict
      • GslvDicts.voltage_level_dict
      • GslvDicts.zone_dict
    • get_snapshots_from_gslv()
    • to_gslv()
  • Module contents

Submodules

VeraGridEngine.Compilers.circuit_to_data module

VeraGridEngine.Compilers.circuit_to_data.compile_numerical_circuit_at()

Compile a NumericalCircuit from a MultiCircuit :param circuit: MultiCircuit instance :param t_idx: time step from the time series to gather data from, if None the snapshot is used :param apply_temperature: apply the branch temperature correction :param branch_tolerance_mode: Branch tolerance mode :param opf_results:(optional) OptimalPowerFlowResults instance :param use_stored_guess: use the storage voltage guess? :param bus_dict (optional) Dict[Bus, int] dictionary :param areas_dict (optional) Dict[Area, int] dictionary :param control_taps_modules: control taps modules? :param control_taps_phase: control taps phase? :param control_remote_voltage: control remote voltage? :param fill_gep: fill generation expansion planning parameters? :param fill_three_phase: :param consider_grounded_buses: Consider the is_grounded bus state :param logger: Logger instance :return: NumericalCircuit instance

VeraGridEngine.Compilers.circuit_to_data.delta2StarAdmittance(Yab: complex, Ybc: complex, Yca: complex)

Converts Delta to Star in admittances :param Yab: :param Ybc: :param Yca: :return: Ya, Yb, Yc

VeraGridEngine.Compilers.circuit_to_data.fill_controllable_branch(ii: int, elm: dev.Transformer2W | dev.Winding | dev.UPFC, data: PassiveBranchData, ctrl_data: ActiveBranchData, bus_data: BusData, bus_dict: Dict[Bus, int], t_idx: int | None, opf_results: VALID_OPF_RESULTS | None, use_stored_guess: bool, bus_voltage_used: BoolVec, Sbase: float, control_taps_modules: bool, control_taps_phase: bool, logger: Logger)

Parameters:

• ii

• elm

• data

• ctrl_data

• bus_data

• bus_dict

• t_idx

• opf_results

• use_stored_guess

• bus_voltage_used

• Sbase

• control_taps_modules

• control_taps_phase

• logger

Returns:

VeraGridEngine.Compilers.circuit_to_data.fill_generator_parent(k: int, data: GeneratorData | BatteryData, elm: Generator | Battery, bus_dict: Dict[Bus, int], bus_voltage_used: ndarray[tuple[Any, ...], dtype[bool]], logger: Logger, bus_data: BusData, t_idx: int | None = None, use_stored_guess: bool = False, control_remote_voltage: bool = True, fill_three_phase: bool = False) → None

Fill the common ancestor of generation and batteries :param k: :param data: :param elm: :param bus_dict: :param bus_voltage_used: :param logger: :param bus_data: :param t_idx: :param use_stored_guess: :param control_remote_voltage: :param fill_three_phase: :return:

VeraGridEngine.Compilers.circuit_to_data.fill_parent_branch(i: int, elm: Line | DcLine | Transformer2W | HvdcLine | VSC | UPFC | Winding | Switch | SeriesReactance, data: PassiveBranchData, bus_data: BusData, bus_dict: Dict[Bus, int], bus_voltage_used: ndarray[tuple[Any, ...], dtype[bool]], use_stored_guess=False, t_idx: int | None = None)

Parameters:

• i

• elm

• data

• bus_data

• bus_dict

• bus_voltage_used

• use_stored_guess

• t_idx

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_battery_data(data: BatteryData, circuit: MultiCircuit, bus_dict: Dict[Bus, int], bus_voltage_used: BoolVec, logger: Logger, bus_data: BusData, t_idx: int | None, opf_results: VALID_OPF_RESULTS | None = None, time_series=False, control_remote_voltage: bool = True, fill_three_phase: bool = False) → None

Parameters:

• data

• circuit

• bus_dict

• bus_voltage_used

• logger

• bus_data

• opf_results

• t_idx

• time_series

• control_remote_voltage

• fill_three_phase

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_branch_data(data: PassiveBranchData, ctrl_data: ActiveBranchData, circuit: MultiCircuit, bus_dict: Dict[Bus, int], bus_data: BusData, bus_voltage_used: BoolVec, apply_temperature: bool, branch_tolerance_mode: BranchImpedanceMode, t_idx: int | None, opf_results: VALID_OPF_RESULTS | None = None, use_stored_guess: bool = False, control_taps_modules: bool = True, control_taps_phase: bool = True, logger: Logger = <VeraGridEngine.basic_structures.Logger object>, fill_three_phase: bool = False) → Dict[BRANCH_TYPES, int]

Compile BranchData for a time step or the snapshot :param data: BranchData :param ctrl_data: ControllableBranchData :param circuit: MultiCircuit :param bus_dict: Dictionary of buses to compute the indices :param bus_data: BusData :param bus_voltage_used: :param apply_temperature: apply the temperature correction? :param branch_tolerance_mode: BranchImpedanceMode :param t_idx: time index (-1 is useless) :param opf_results: OptimalPowerFlowResults :param use_stored_guess: use the stored voltage ? :param control_taps_modules: Control TapsModules :param control_taps_phase: Control TapsPhase :param logger: Logger :param fill_three_phase: Fill the tree phase info? :return: BranchData

VeraGridEngine.Compilers.circuit_to_data.get_bus_data(bus_data: BusData, circuit: MultiCircuit, areas_dict: Dict[Area, int], t_idx: int | None, use_stored_guess=False, consider_grounded_buses: bool = False, logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → None

Parameters:

• bus_data – BusData

• circuit

• areas_dict

• t_idx

• use_stored_guess

• consider_grounded_buses

• logger

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_node_data(data: FluidNodeData, circuit: MultiCircuit, t_idx: int | None = None, logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → Dict[str, int]

Parameters:

• data

• circuit

• t_idx

• logger

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_p2x_data(data: FluidP2XData, circuit: MultiCircuit, plant_dict: Dict[str, int], gen_dict: Dict[str, int], logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → FluidP2XData

Parameters:

• data

• circuit

• plant_dict

• gen_dict

• logger

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_path_data(data: FluidPathData, circuit: MultiCircuit, plant_dict: Dict[str, int], logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → FluidPathData

Parameters:

• data – FluidPathData

• circuit

• plant_dict

• logger

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_pump_data(data: FluidPumpData, circuit: MultiCircuit, plant_dict: Dict[str, int], gen_dict: Dict[str, int], logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → FluidPumpData

Parameters:

• data

• circuit

• plant_dict

• gen_dict

• logger

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_turbine_data(data: FluidTurbineData, circuit: MultiCircuit, plant_dict: Dict[str, int], gen_dict: Dict[str, int], logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → FluidTurbineData

Parameters:

• data

• circuit

• plant_dict

• gen_dict

• logger

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_generator_data(data: GeneratorData, circuit: MultiCircuit, bus_dict, bus_voltage_used: BoolVec, logger: Logger, bus_data: BusData, t_idx: int | None, opf_results: VALID_OPF_RESULTS | None = None, time_series: bool = False, use_stored_guess: bool = False, control_remote_voltage: bool = True, fill_three_phase: bool = False) → Dict[str, int]

Parameters:

• data

• circuit

• bus_dict

• bus_voltage_used

• logger

• bus_data

• opf_results

• t_idx

• time_series

• use_stored_guess

• control_remote_voltage

• fill_three_phase

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_hvdc_data(data: HvdcData, circuit: MultiCircuit, bus_dict, bus_data: BusData, bus_voltage_used: BoolVec, t_idx: int | None, opf_results: Union[OptimalPowerFlowResults, OptimalNetTransferCapacityResults, None]=None, use_stored_guess: bool = False, logger: Logger = <VeraGridEngine.basic_structures.Logger object>)

Parameters:

• data

• circuit

• bus_dict

• bus_data

• bus_voltage_used

• t_idx

• opf_results

• use_stored_guess

• logger

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_load_data(data: LoadData, circuit: MultiCircuit, bus_dict: Dict[Bus, int], bus_voltage_used: BoolVec, bus_data: BusData, t_idx: int | None, logger: Logger, use_stored_guess: bool = False, opf_results: OptimalPowerFlowResults | None = None, fill_three_phase: bool = False) → LoadData

Parameters:

• data

• circuit

• bus_dict

• bus_voltage_used

• bus_data

• logger

• t_idx

• opf_results

• use_stored_guess

• fill_three_phase – Fill the tree phase info?

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_shunt_data(data: ShuntData, circuit: MultiCircuit, bus_dict, bus_voltage_used: BoolVec, bus_data: BusData, t_idx: int | None, logger: Logger, use_stored_guess: bool = False, control_remote_voltage: bool = True, fill_three_phase: bool = False) → None

Parameters:

• data

• circuit

• bus_dict

• bus_voltage_used

• bus_data

• logger

• t_idx

• use_stored_guess

• control_remote_voltage

• fill_three_phase

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_valid_fluid_injection_indices(elm: FluidInjectionTemplate, plant_dict: Dict[str, int], gen_dict: Dict[str, int], logger: Logger) → tuple[int | None, int | None]

Resolve the plant and generator indices for one fluid injection.

Parameters:

• elm – Fluid injection device.

• plant_dict – Fluid node index by idtag.

• gen_dict – Generator index by idtag.

• logger – Logger receiving invalid-link errors.

Returns:

Plant and generator indices, or None for invalid links.

VeraGridEngine.Compilers.circuit_to_data.get_vsc_data(data: VscData, circuit: MultiCircuit, bus_dict: Dict[Bus, int], branch_dict: Dict[BRANCH_TYPES, int], bus_data: BusData, bus_voltage_used: BoolVec, t_idx: int | None, opf_results: VALID_OPF_RESULTS | None = None, use_stored_guess: bool = False, control_remote_voltage: bool = True, logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → None

Compile VscData for a time step or the snapshot :param data: VscData :param circuit: MultiCircuit :param bus_dict: Dictionary of buses to compute the indices :param branch_dict: Dictionary of branches to compute the indices :param bus_data: BusData :param bus_voltage_used: :param t_idx: time index (-1 is useless) :param opf_results: OptimalPowerFlowResults :param use_stored_guess: use the stored voltage ? :param control_remote_voltage: Control RemoteVoltage :param logger: Logger :return: VscData

VeraGridEngine.Compilers.circuit_to_data.normalize_upper_bound(lower: float, upper: float, logger: Logger, device_name: str, device_class: str, lower_name: str, upper_name: str) → tuple[float, float]

Normalize a scalar box constraint so the upper bound is never below the lower bound.

Parameters:

• lower – Lower bound candidate.

• upper – Upper bound candidate.

• logger – Logger used to report the correction.

• device_name – Device name for the log entry.

• device_class – Device class for the log entry.

• lower_name – Human-readable lower-bound field name.

• upper_name – Human-readable upper-bound field name.

Returns:

Tuple (lower, upper) with upper >= lower enforced.

VeraGridEngine.Compilers.circuit_to_data.resize_fluid_injection_data(data: FluidTurbineData, nelm: int) → None

Resize fluid injection data arrays to the valid compiled entries.

Parameters:

• data – Fluid injection data structure.

• nelm – Number of valid compiled entries.

Returns:

None.

VeraGridEngine.Compilers.circuit_to_data.set_bus_control_angle_vsc(i: int, j: int, remote_control: bool, bus_name: str, bus_angle_used: ndarray[tuple[Any, ...], dtype[bool]], bus_data: BusData, candidate_Va: float, use_stored_guess: bool, logger: Logger) → None

Set the bus control angle :param i: Bus index :param j: Remote Bus index :param remote_control: Using remote control? :param bus_name: Bus name :param bus_angle_used: Array of flags indicating if a bus angle has been modified before :param bus_data: BusData :param candidate_Va: Angle set point that you want to set in degrees :param use_stored_guess: Use the stored seed values? :param logger: Logger

VeraGridEngine.Compilers.circuit_to_data.set_bus_control_voltage(i: int, j: int, remote_control: bool, bus_name: str, bus_voltage_used: ndarray[tuple[Any, ...], dtype[bool]], bus_data: BusData, candidate_Vm: float, use_stored_guess: bool, logger: Logger) → None

Set the bus control voltage :param i: Bus index :param j: Remote Bus index :param remote_control: Using remote control? :param bus_name: Bus name :param bus_voltage_used: Array of flags indicating if a bus voltage has been modified before :param bus_data: BusData :param candidate_Vm: Voltage set point that you want to set :param use_stored_guess: Use the stored seed values? :param logger: Logger

VeraGridEngine.Compilers.circuit_to_data.set_bus_control_voltage_hvdc(i: int, j: int, remote_control: bool, bus_name: str, bus_voltage_used: ndarray[tuple[Any, ...], dtype[bool]], bus_data: BusData, candidate_Vm: float, use_stored_guess: bool, logger: Logger) → None

Set the bus control voltage :param i: Bus index :param j: Remote Bus index :param remote_control: Using remote control? :param bus_name: Bus name :param bus_voltage_used: Array of flags indicating if a bus voltage has been modified before :param bus_data: BusData :param candidate_Vm: Voltage set point that you want to set :param use_stored_guess: Use the stored seed values? :param logger: Logger

VeraGridEngine.Compilers.circuit_to_data.set_bus_control_voltage_vsc(i: int, j: int, remote_control: bool, bus_name: str, bus_voltage_used: ndarray[tuple[Any, ...], dtype[bool]], bus_data: BusData, candidate_Vm: float, use_stored_guess: bool, logger: Logger) → None

Set the bus control voltage :param i: Bus index :param j: Remote Bus index :param remote_control: Using remote control? :param bus_name: Bus name :param bus_voltage_used: Array of flags indicating if a bus voltage has been modified before :param bus_data: BusData :param candidate_Vm: Voltage set point that you want to set :param use_stored_guess: Use the stored seed values? :param logger: Logger

VeraGridEngine.Compilers.circuit_to_data.set_control_dev(k: int, f: int, t: int, control_int: int, control_dev: Bus | Line | DcLine | Transformer2W | HvdcLine | VSC | UPFC | Winding | Switch | SeriesReactance | None, control_val: float, control_bus_idx: ndarray[tuple[Any, ...], dtype[int64]], control_branch_idx: ndarray[tuple[Any, ...], dtype[int64]], bus_dict: Dict[Bus, int], bus_data: BusData, bus_voltage_used: ndarray[tuple[Any, ...], dtype[bool]], bus_angle_used: ndarray[tuple[Any, ...], dtype[bool]], use_stored_guess: bool, logger: Logger)

Parameters:

• k – device index

• f

• t

• control_int – ConverterControlType

• control_dev – control device

• control_val – control value

• control_bus_idx – array to be filled in

• control_branch_idx – array to be filled in

• bus_dict – dictionary to be filled in

• bus_data – bus data

• bus_voltage_used – used bus voltage

• bus_angle_used – used bus angle

• use_stored_guess

• logger

VeraGridEngine.Compilers.circuit_to_optimods module

VeraGridEngine.Compilers.circuit_to_optimods.solve_acopf(case: Dict) → Dict

Solve ACOPF :param case: :return:

VeraGridEngine.Compilers.circuit_to_pgm module

class VeraGridEngine.Compilers.circuit_to_pgm.NumpyEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: JSONEncoder

JSON encoder that serializes NumPy arrays to lists.

default(obj: Any) → Any

Convert numpy arrays to python lists for JSON serialization.

Parameters:

obj – Object to serialize.

Returns:

JSON serializable representation of obj.

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_buses(circuit: MultiCircuit, idx0)

Convert the buses to LFE’sPGM buses :param circuit: VeraGrid circuit :param idx0: First object index :return: bus dictionary buses[uuid] -> int

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_dc_line_data(circuit: MultiCircuit, bus_dict, idx0)

Parameters:

• circuit – VeraGrid circuit

• bus_dict – dictionary of bus id to LFE’sPGM index

• idx0 – First object index

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_generators(circuit: MultiCircuit, bus_dict, idx0, n_time=None)

Parameters:

• circuit – VeraGrid circuit

• bus_dict – dictionary of bus id to LFE’sPGM index

• idx0 – First object index

• n_time – Number of time steps, last_index, generation profile

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_hvdc_data(circuit: MultiCircuit, bus_dict, idx0)

Parameters:

• circuit – VeraGrid circuit

• bus_dict – dictionary of bus id to LFE’sPGM index

• idx0 – First object index

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_input_data(circuit: MultiCircuit, logger: Logger = <VeraGridEngine.basic_structures.Logger object>, time_series=False)

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_line(circuit: MultiCircuit, bus_dict, idx0, logger: Logger)

Parameters:

• circuit – VeraGrid circuit

• bus_dict – dictionary of bus id to LFE’sPGM index

• idx0 – First object index

• logger – Logger object

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_loads(circuit: MultiCircuit, bus_dict, idx0, n_time=None)

Generate load data :param circuit: VeraGrid circuit :param bus_dict: dictionary of bus id to LFE’sPGM index :param idx0: First object index :param n_time: Number of time steps :return struct of load values, load_profile

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_shunts(circuit: MultiCircuit, bus_dict, idx0)

Parameters:

• circuit – VeraGrid circuit

• bus_dict – dictionary of bus id to LFE’sPGM index

• idx0 – First object index

:returns shunts, last object index

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_source(circuit: MultiCircuit, bus_dict, idx0)

Parameters:

• circuit – VeraGrid circuit

• bus_dict – dictionary of bus id to LFE’sPGM index

• idx0 – First object index

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_transformer_data(circuit: MultiCircuit, bus_dict, idx0)

Parameters:

• circuit – VeraGrid circuit

• bus_dict – dictionary of bus id to LFE’sPGM index

• idx0 – First object index

VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_vsc_data(circuit: MultiCircuit, bus_dict, idx0)

Parameters:

• circuit – VeraGrid circuit

• bus_dict – dictionary of bus id to LFE’sPGM index

• idx0 – First object index

VeraGridEngine.Compilers.circuit_to_pgm.pgm_pf(circuit: MultiCircuit, opt: PowerFlowOptions, logger: Logger, symmetric=True, time_series=False)

LFE’sPGM power flow :param circuit: MultiCircuit instance :param opt: Power Flow Options :param logger: Logger object :param symmetric: Symmetric (3-phase balanced calculation? / asymmetric) :param time_series: Time_series? :return: LFE’s PGM Power flow results object

VeraGridEngine.Compilers.circuit_to_pgm.save_pgm(filename: str, circuit: MultiCircuit, logger: Logger = <VeraGridEngine.basic_structures.Logger object>, time_series=False)

Save to Power Grid Model format :param filename: :param circuit: :param logger: :param time_series: :return:

VeraGridEngine.Compilers.circuit_to_pgm.to_pgm(circuit: MultiCircuit, logger: Logger = <VeraGridEngine.basic_structures.Logger object>, time_series=False) → Tuple[pgm.PowerGridModel, Dict]

Convert VeraGrid circuit to LFE’sPGM model See https://github.com/alliander-opensource/power-grid-model/blob/main/docs/graph-data-model.md :param circuit: MultiCircuit :param logger: Logger instance :param time_series: use time series? :return: pgm.PowerGridModel instance

VeraGridEngine.Compilers.circuit_to_pgm.translate_pgm_pf_results2d(grid: MultiCircuit, pf_res) → PowerFlowTimeSeriesResults

Translate the time series power flow results :param grid: :param pf_res: :return: TimeSeriesResults

VeraGridEngine.Compilers.circuit_to_pgm.translate_pgm_results(grid: MultiCircuit, pf_res) → PowerFlowResults

Translate the PGM results to SnapShot power flow results :param grid: :param pf_res: :return: PowerFlowResults

Module contents