VeraGridEngine.Compilers package

Submodules

VeraGridEngine.Compilers.circuit_to_bentayga module

class VeraGridEngine.Compilers.circuit_to_bentayga.FakeAdmittances[source]

Bases: object

VeraGridEngine.Compilers.circuit_to_bentayga.add_btg_buses(circuit: MultiCircuit, btg_circuit: btg.Circuit, time_series: bool = False, ntime: int = 1)[source]

Convert the buses to bentayga buses :param circuit: VeraGrid circuit :param btg_circuit: bentayga circuit :param time_series: compile the time series from VeraGrid? otherwise, just the snapshot :param ntime: number of time steps :return: bus dictionary buses[uuid] -> Bus

VeraGridEngine.Compilers.circuit_to_bentayga.add_btg_generators(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool = False, ntime: int = 1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.add_btg_line(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool = False, ntime: int = 1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.add_btg_loads(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool = False, ntime: int = 1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.add_btg_shunts(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool = False, ntime=1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.add_btg_static_generators(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool, ntime=1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.bentayga_linear_matrices(circuit: MultiCircuit, distributed_slack=False)[source]

Bentayga linear analysis :param circuit: MultiCircuit instance :param distributed_slack: distribute the PTDF slack :return: Bentayga LinearAnalysisMatrices object

VeraGridEngine.Compilers.circuit_to_bentayga.bentayga_pf(circuit: MultiCircuit, opt: PowerFlowOptions, time_series=False)[source]

Bentayga power flow :param circuit: MultiCircuit instance :param opt: Power Flow Options :param time_series: Compile with VeraGrid time series? :return: Bentayga Power flow results object

VeraGridEngine.Compilers.circuit_to_bentayga.debug_bentayga_circuit_at(btg_circuit: btg.Circuit, t: int = None)[source]
VeraGridEngine.Compilers.circuit_to_bentayga.get_battery_data(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool = False, ntime: int = 1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.get_bentayga_pf_options(opt: PowerFlowOptions)[source]

Translate VeraGrid power flow options to Bentayga power flow options :param opt: :return:

VeraGridEngine.Compilers.circuit_to_bentayga.get_dc_line_data(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool = False, ntime: int = 1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.get_hvdc_data(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool, ntime=1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.get_snapshots_from_bentayga(circuit: MultiCircuit)[source]
VeraGridEngine.Compilers.circuit_to_bentayga.get_transformer_data(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool = False, ntime: int = 1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.get_vsc_data(circuit: MultiCircuit, btg_circuit: btg.Circuit, bus_dict, time_series: bool = False, ntime: int = 1)[source]
Parameters:

  • circuit – VeraGrid circuit

  • btg_circuit – bentayga circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to bentayga bus object

  • ntime – number of time steps

VeraGridEngine.Compilers.circuit_to_bentayga.to_bentayga(circuit: MultiCircuit, time_series: bool)[source]

Convert VeraGrid circuit to Bentayga :param circuit: MultiCircuit :param time_series: compile the time series from VeraGrid? otherwise just the snapshot :return: btg.Circuit instance

VeraGridEngine.Compilers.circuit_to_bentayga.translate_bentayga_pf_results(grid: MultiCircuit, res) → PowerFlowResults[source]
Parameters:

  • grid

  • res

Returns:

VeraGridEngine.Compilers.circuit_to_data module

VeraGridEngine.Compilers.circuit_to_data.compile_numerical_circuit_at()[source]

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)[source]

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)[source]
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, control_remote_voltage: bool = True, fill_three_phase: bool = False) → None[source]

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 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)[source]
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[source]
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_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][source]

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) → None[source]
Parameters:

  • bus_data – BusData

  • circuit

  • areas_dict

  • t_idx

  • use_stored_guess

  • consider_grounded_buses

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_node_data(data: FluidNodeData, circuit: MultiCircuit, t_idx: int | None = None) → Dict[str, int][source]
Parameters:

  • data

  • circuit

  • t_idx

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_p2x_data(data: FluidP2XData, circuit: MultiCircuit, plant_dict: Dict[str, int], gen_dict: Dict[str, int]) → FluidP2XData[source]
Parameters:

  • data

  • circuit

  • plant_dict

  • gen_dict

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_path_data(data: FluidPathData, circuit: MultiCircuit, plant_dict: Dict[str, int]) → FluidPathData[source]
Parameters:

  • data – FluidPathData

  • circuit

  • plant_dict

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_pump_data(data: FluidPumpData, circuit: MultiCircuit, plant_dict: Dict[str, int], gen_dict: Dict[str, int]) → FluidPumpData[source]
Parameters:

  • data

  • circuit

  • plant_dict

  • gen_dict

Returns:

VeraGridEngine.Compilers.circuit_to_data.get_fluid_turbine_data(data: FluidTurbineData, circuit: MultiCircuit, plant_dict: Dict[str, int], gen_dict: Dict[str, int]) → FluidTurbineData[source]
Parameters:

  • data

  • circuit

  • plant_dict

  • gen_dict

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, control_remote_voltage: bool = True, fill_three_phase: bool = False) → Dict[str, int][source]
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>)[source]
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, opf_results: OptimalPowerFlowResults | None = None, fill_three_phase: bool = False) → LoadData[source]
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, control_remote_voltage: bool = True, fill_three_phase: bool = False) → None[source]
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_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[source]

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.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[source]

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, logger: Logger) → None[source]

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 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[source]

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[source]

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)[source]
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_gslv module

VeraGridEngine.Compilers.circuit_to_gslv.CheckArr(arr: ndarray[tuple[Any, ...], dtype[float64]], arr_expected: ndarray[tuple[Any, ...], dtype[float64]], tol: float, name: str, test: str, verbose=False)[source]
Parameters:

  • arr

  • arr_expected

  • tol

  • name

  • test

  • verbose

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.CheckArrEq(arr: ndarray, arr_expected: ndarray, name: str, test: str, verbose=False)[source]
Parameters:

  • arr

  • arr_expected

  • name

  • test

  • verbose

Returns:

class VeraGridEngine.Compilers.circuit_to_gslv.FakeAdmittances[source]

Bases: object

Fake admittances class needed to make the translation

class VeraGridEngine.Compilers.circuit_to_gslv.GslvDicts[source]

Bases: object

VeraGridEngine.Compilers.circuit_to_gslv.add_areas(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.Area, 'pg.Area'][source]

Add GSLV Areas :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :return: Dictionary [VeraGrid area] -> GSLV Area

VeraGridEngine.Compilers.circuit_to_gslv.add_battery_data(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None, opf_results: None | OptimalPowerFlowResults = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

  • opf_results – OptimelPowerFlowResults (optional)

VeraGridEngine.Compilers.circuit_to_gslv.add_branch_groups(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.BranchGroup, 'pg.BranchGroup'][source]

Add GSLV countries :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :return: Dictionary [VeraGrid country] -> GSLV country

VeraGridEngine.Compilers.circuit_to_gslv.add_buses(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, area_dict: Dict[dev.Area, 'pg.Area'], zone_dict: Dict[dev.Zone, 'pg.Zone'], substation_dict: Dict[dev.Substation, 'pg.Substation'], voltage_level_dict: Dict[dev.VoltageLevel, 'pg.VoltageLevel'], country_dict: Dict[dev.Country, 'pg.Country'], use_time_series: bool, n_time: int = 1, time_indices: IntVec | None = None) → Dict[str, 'pg.Bus'][source]

Convert the buses to GSLV buses :param circuit: VeraGrid circuit :param gslv_grid: GSLV circuit :param use_time_series: compile the time series from VeraGrid? otherwise, just the snapshot :param n_time: number of time steps :param time_indices: Array of time indices :param area_dict: Area object translation dictionary :param zone_dict: Zone object translation dictionary :param substation_dict: Substation object translation dictionary :param voltage_level_dict: Voltage level object translation dictionary :param country_dict: Country object translation dictionary :return: bus dictionary buses[uuid] -> Bus

VeraGridEngine.Compilers.circuit_to_gslv.add_contingencies(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, n_time: int, groups_dict: Dict[dev.ContingencyGroup, 'pg.ContingencyGroup'])[source]

Add GSLV ContingenciesGroup :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :param n_time: number of time steps :param groups_dict: Contingency groups dictionary :return: Dictionary [VeraGrid ContingenciesGroup] -> GSLV ContingenciesGroup

VeraGridEngine.Compilers.circuit_to_gslv.add_contingency_groups(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.ContingencyGroup, 'pg.ContingencyGroup'][source]

Add GSLV ContingenciesGroup :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :return: Dictionary [VeraGrid ContingenciesGroup] -> GSLV ContingenciesGroup

VeraGridEngine.Compilers.circuit_to_gslv.add_controllable_shunts(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], time_series: bool, n_time=1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_gslv.add_countries(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.Country, 'pg.Country'][source]

Add GSLV countries :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :return: Dictionary [VeraGrid country] -> GSLV country

VeraGridEngine.Compilers.circuit_to_gslv.add_dc_lines(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_gslv.add_facilities(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.Facility, 'pg.Facility'][source]
Parameters:

  • circuit

  • gslv_grid

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.add_generators(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], time_series: bool, n_time=1, time_indices: IntVec | None = None, opf_results: None | OptimalPowerFlowResults = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

  • opf_results – OptimalPowerFlowResults (optional)

VeraGridEngine.Compilers.circuit_to_gslv.add_hvdcs(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], time_series: bool, n_time=1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_gslv.add_investment_groups(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.InvestmentsGroup, 'pg.InvestmentGroup'][source]
Parameters:

  • circuit

  • gslv_grid

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.add_investments(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, groups_dict: Dict[dev.InvestmentsGroup, 'pg.InvestmentGroup'])[source]
Parameters:

  • circuit

  • gslv_grid

  • groups_dict

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.add_lines(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], branch_groups_dict: Dict[dev.BranchGroup, 'pg.BranchGroup'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • branch_groups_dict – dictionary of converted branch groups

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_gslv.add_loads(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], use_time_series: bool, n_time=1, time_indices: IntVec | None = None, opf_results: OptimalPowerFlowResults | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • bus_dict – dictionary of bus id to GSLV bus object

  • use_time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • n_time – number of time steps

  • time_indices

  • opf_results

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.add_modelling_authorities(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.ModellingAuthority, 'pg.ModellingAuthority'][source]
Parameters:

  • circuit

  • gslv_grid

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.add_municipalities(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.Country, 'pg.Country'][source]

Add GSLV countries :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :return: Dictionary [VeraGrid country] -> GSLV country

VeraGridEngine.Compilers.circuit_to_gslv.add_regions(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.Country, 'pg.Country'][source]

Add GSLV countries :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :return: Dictionary [VeraGrid country] -> GSLV country

VeraGridEngine.Compilers.circuit_to_gslv.add_shunts(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], time_series: bool, n_time=1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_gslv.add_static_generators(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], time_series: bool, n_time=1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_gslv.add_substations(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, n_time: int) → Dict[dev.Substation, 'pg.Substation'][source]

Add GSLV substations :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :param n_time: number of time steps :return: Dictionary [VeraGrid Zone] -> GSLV Zone

VeraGridEngine.Compilers.circuit_to_gslv.add_transformers(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], branch_groups_dict: Dict[dev.BranchGroup, 'pg.BranchGroup'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None, override_controls=False)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • branch_groups_dict – dictionary of branch grous converetd

  • n_time – number of time steps

  • time_indices – Array of time indices

  • override_controls – If true the controls are set to Fix

VeraGridEngine.Compilers.circuit_to_gslv.add_transformers3w(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], time_series: bool, n_time=1, time_indices: IntVec | None = None, override_controls=False)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

  • override_controls – If true the controls are set to Fix

VeraGridEngine.Compilers.circuit_to_gslv.add_voltage_levels(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, substations_dict: Dict[dev.Substation, 'pg.Substation']) → Dict[dev.VoltageLevel, 'pg.VoltageLevel'][source]

Add GSLV substations :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :param substations_dict: substations mapping dictionary :return: Dictionary [VeraGrid Zone] -> GSLV Zone

VeraGridEngine.Compilers.circuit_to_gslv.add_vscs(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit, bus_dict: Dict[str, 'pg.Bus'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • gslv_grid – GSLV circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to GSLV bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_gslv.add_zones(circuit: MultiCircuit, gslv_grid: pg.MultiCircuit) → Dict[dev.Zone, 'pg.Zone'][source]

Add GSLV Zones :param circuit: VeraGrid circuit :param gslv_grid: GSLV Circuit :return: Dictionary [VeraGrid Zone] -> GSLV Zone

VeraGridEngine.Compilers.circuit_to_gslv.compare_branch_parent_data(gslv_branch_data: pg.BranchParentData, gc_branch_data: BranchParentData, tol: float, parent_name: str)[source]
Parameters:

  • gslv_branch_data

  • gc_branch_data

  • tol

  • parent_name

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.compare_nc(nc_gslv: pg.NumericalCircuit, nc_gc: NumericalCircuit, tol: float)[source]
Parameters:

  • nc_gslv

  • nc_gc

  • tol

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_area(area: dev.Area) → pg.Area[source]
Parameters:

area

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_arr(arr, d: Dict)[source]
VeraGridEngine.Compilers.circuit_to_gslv.convert_battery(k: int, elm: dev.Battery, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, time_indices: IntVec | None = None, opf_results: OptimalPowerFlowResults | None = None) → pg.Battery[source]
Parameters:

  • k

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • time_indices

  • opf_results

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_branch_group(country: dev.BranchGroup) → pg.BranchGroup[source]
Parameters:

country

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_bus(elm: dev.Bus, n_time: int, area_dict: Dict[dev.Area, 'pg.Area'], zone_dict: Dict[dev.Zone, 'pg.Zone'], substation_dict: Dict[dev.Substation, 'pg.Substation'], voltage_level_dict: Dict[dev.VoltageLevel, 'pg.VoltageLevel'], country_dict: Dict[dev.Country, 'pg.Country'], time_indices: IntVec, use_time_series: bool) → pg.Bus[source]
Parameters:

  • elm

  • n_time

  • area_dict

  • zone_dict

  • substation_dict

  • voltage_level_dict

  • country_dict

  • time_indices

  • use_time_series

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_contingencies(elm: dev.Contingency, n_time: int, groups_dict: Dict[dev.ContingencyGroup, 'pg.ContingencyGroup']) → pg.Contingency[source]
Parameters:

  • elm

  • n_time

  • groups_dict

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_contingency_groups(elm: dev.ContingencyGroup) → pg.ContingencyGroup[source]
Parameters:

elm

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_controllable_shunt(elm: dev.ControllableShunt, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, shunt_control_mode_dict: Dict[ShuntControlMode, 'pg.ShuntControlMode'], time_indices: IntVec | None = None) → pg.ControllableShunt[source]
Parameters:

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • shunt_control_mode_dict

  • time_indices

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_country(country: dev.Country) → pg.Country[source]
Parameters:

country

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_dc_line(elm: dev.DcLine, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, time_indices: IntVec | None) → pg.DcLine[source]
Parameters:

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • time_indices

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_facility(elm: dev.Facility) → pg.Facility[source]
Parameters:

elm

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_generator(k: int, elm: dev.Generator, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, time_indices: IntVec | None = None, opf_results: OptimalPowerFlowResults | None = None) → pg.Generator[source]
Parameters:

  • k

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • time_indices

  • opf_results

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_gslv_arr_to_idx(arr, d: Dict)[source]
VeraGridEngine.Compilers.circuit_to_gslv.convert_hvdc_line(elm: dev.HvdcLine, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, time_indices: IntVec | None) → pg.HvdcLine[source]
Parameters:

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • time_indices

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_investment(elm: dev.Investment, groups_dict: Dict[dev.InvestmentsGroup, 'pg.InvestmentGroup']) → pg.Investment[source]
Parameters:

  • elm

  • groups_dict

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_investment_group(elm: dev.InvestmentsGroup) → pg.InvestmentGroup[source]
Parameters:

elm

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_line(elm: dev.Line, n_time: int, bus_dict: Dict[str, 'pg.Bus'], branch_groups_dict: Dict[dev.BranchGroup, 'pg.BranchGroup'], use_time_series: bool, time_indices: IntVec | None = None) → pg.Line[source]
Parameters:

  • elm

  • n_time

  • bus_dict

  • branch_groups_dict

  • use_time_series

  • time_indices

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_load(k: int, elm: dev.Load, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, time_indices: IntVec | None = None, opf_results: OptimalPowerFlowResults | None = None) → pg.Load[source]
Parameters:

  • k

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • time_indices

  • opf_results

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_modelling_authority(elm: dev.ModellingAuthority) → pg.ModellingAuthority[source]
Parameters:

elm

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_municipality(country: dev.Municipality) → pg.Municipality[source]
Parameters:

country

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_region(country: dev.Region) → pg.Region[source]
Parameters:

country

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_shunt(elm: dev.Shunt, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, time_indices: IntVec | None = None) → pg.Shunt[source]
Parameters:

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • time_indices

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_static_generator(elm: dev.StaticGenerator, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, time_indices: IntVec | None = None) → pg.StaticGenerator[source]
Parameters:

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • time_indices

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_substation(se: dev.Substation, n_time: int) → pg.Substation[source]
Parameters:

  • se

  • n_time

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_tap_module_control_mode_dict(data: Dict[int, TapModuleControl]) → Dict[int, 'pg.TapModuleControl'][source]

Function to convert a dictionary of TapModuleControl modes to pg.TapModuleControl modes :param data: :return:

VeraGridEngine.Compilers.circuit_to_gslv.convert_tap_module_control_mode_lst(data: List[TapModuleControl]) → List['pg.TapModuleControl'][source]

Function to convert a list of TapModuleControl modes to pg.TapModuleControl modes :param data: :return:

VeraGridEngine.Compilers.circuit_to_gslv.convert_tap_phase_control_mode_dict(data: Dict[int, TapPhaseControl]) → Dict[int, 'pg.TapPhaseControl'][source]

Function to convert a dictionary of TapPhaseControl modes to pg.TapPhaseControl modes :param data: :return:

VeraGridEngine.Compilers.circuit_to_gslv.convert_tap_phase_control_mode_lst(data: List[TapPhaseControl]) → List['pg.TapPhaseControl'][source]

Function to convert a list of TapPhaseControl modes to pg.TapPhaseControl modes :param data: :return:

VeraGridEngine.Compilers.circuit_to_gslv.convert_transformer(elm: dev.Transformer2W, bus_dict: Dict[str, 'pg.Bus'], branch_groups_dict: Dict[dev.BranchGroup, 'pg.BranchGroup'], n_time: int, use_time_series: bool, time_indices: IntVec | None, override_controls: bool) → pg.Transformer2W[source]
Parameters:

  • elm

  • bus_dict

  • branch_groups_dict

  • n_time

  • use_time_series

  • time_indices

  • override_controls

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_transformer3w(elm: dev.Transformer3W, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, time_indices: IntVec | None, override_controls: bool) → pg.Transformer3W[source]
Parameters:

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • time_indices

  • override_controls

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_voltage_level(elm: dev.VoltageLevel, substations_dict: Dict[dev.Substation, 'pg.Substation']) → pg.VoltageLevel[source]
Parameters:

  • elm

  • substations_dict

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_vsc(elm: dev.VSC, bus_dict: Dict[str, 'pg.Bus'], n_time: int, use_time_series: bool, time_indices: IntVec | None) → pg.Vsc[source]
Parameters:

  • elm

  • bus_dict

  • n_time

  • use_time_series

  • time_indices

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.convert_zone(zone: dev.Zone) → pg.Zone[source]
Parameters:

zone

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.fill_profile(gslv_profile: pg.Profiledouble | pg.Profilebool | pg.Profileint | pg.Profileuint, gc_profile: AnyProfile, use_time_series: bool, time_indices: IntVec | None, n_time: int = 1, default_val: int | float | bool | TapPhaseControl | TapModuleControl = 0) → None[source]

Generates a default time series :param gslv_profile: Profile from gslv to fill in :param gc_profile: Profile from veragrid to convert :param use_time_series: use time series? :param time_indices: time series indices if any (optional) :param n_time: number of time steps :param default_val: Default value

VeraGridEngine.Compilers.circuit_to_gslv.fill_profile_with_array(gslv_profile: pg.Profiledouble, arr: Vec, use_time_series: bool, time_indices: IntVec | None, n_time=1, default_val=0) → None[source]

Generates a default time series :param gslv_profile: Profile from gslv to fill in :param arr: array to fill in :param use_time_series: use time series? :param time_indices: time series indices if any (optional) :param n_time: number of time steps :param default_val: Default value

VeraGridEngine.Compilers.circuit_to_gslv.get_gslv_investments_evaluation_options(opt: InvestmentsEvaluationOptions, circuit: MultiCircuit, gslv_circuit: pg.MultiCircuit) → pg.InvestmentsEvaluationOptions[source]

Translate VeraGrid investment-evaluation options to GSLV options.

Parameters:

  • opt – VeraGrid investments-evaluation options.

  • circuit – VeraGrid circuit.

  • gslv_circuit – Converted GSLV circuit.

Returns:

GSLV investments-evaluation options.

VeraGridEngine.Compilers.circuit_to_gslv.get_gslv_mip_solvers_list() → List[str][source]

Get list of available MIP solvers :return:

VeraGridEngine.Compilers.circuit_to_gslv.get_gslv_opf_options(opt: OptimalPowerFlowOptions, circuit: MultiCircuit, gslv_circuit: pg.MultiCircuit) → pg.OptimalPowerFlowOptions[source]

Translate VeraGrid power flow options to GSLV power flow options :param opt: :return:

VeraGridEngine.Compilers.circuit_to_gslv.get_gslv_pf_options(opt: PowerFlowOptions) → pg.PowerFlowOptions[source]

Translate VeraGrid power flow options to GSLV power flow options :param opt: :return:

VeraGridEngine.Compilers.circuit_to_gslv.get_snapshots_from_gslv(circuit: MultiCircuit, override_branch_controls=False) → List[NumericalCircuit][source]
Parameters:

  • circuit

  • override_branch_controls

Returns:

VeraGridEngine.Compilers.circuit_to_gslv.gslv_contingencies_snapshot(circuit: MultiCircuit, con_opt: ContingencyAnalysisOptions, opf_results: None | OptimalPowerFlowResults = None) → pg.ContingencyResultsSnapshot[source]

GSLV power flow :param circuit: MultiCircuit instance :param con_opt: ContingencyAnalysisOptions :param opf_results: OptimalPowerFlowResults (optional) :return: GSLV Power flow results object

VeraGridEngine.Compilers.circuit_to_gslv.gslv_contingencies_ts(circuit: MultiCircuit, con_opt: ContingencyAnalysisOptions, time_series: bool = False, time_indices: IntVec | None = None) → pg.ContingencyAnalysisResults[source]

GSLV power flow :param circuit: MultiCircuit instance :param con_opt: ContingencyAnalysisOptions :param time_series: Compile with VeraGrid time series? :param time_indices: Array of time indices :return: GSLV Power flow results object

VeraGridEngine.Compilers.circuit_to_gslv.gslv_investments_evaluation(circuit: MultiCircuit, options: InvestmentsEvaluationOptions, logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → InvestmentsEvaluationResults[source]

Run GSLV investments evaluation and translate its results back to VeraGrid.

Parameters:

  • circuit – VeraGrid circuit.

  • options – VeraGrid investments-evaluation options.

  • logger – VeraGrid logger instance.

Returns:

VeraGrid investments-evaluation results.

VeraGridEngine.Compilers.circuit_to_gslv.gslv_linear_matrices(circuit: MultiCircuit, distributed_slack=False, correctValues=False, override_branch_controls=False) → pg.LinearAnalysis[source]

Newton linear analysis :param circuit: MultiCircuit instance :param distributed_slack: distribute the PTDF slack :param correctValues: Correct nonsense values (outsie -1, 1) interval :param override_branch_controls: Override branch controls :return: Newton LinearAnalysisMatrices object

VeraGridEngine.Compilers.circuit_to_gslv.gslv_opf(circuit: MultiCircuit, opf_options: OptimalPowerFlowOptions, time_series: bool = False, time_indices: Union[IntVec, None]=None, logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → pg.OptimalPowerFlowResults[source]

GSLV power flow :param logger: :param circuit: MultiCircuit instance :param opf_options: Power Flow Options :param time_series: Compile with VeraGrid time series? :param time_indices: Array of time indices :return: GSLV Power flow results object

VeraGridEngine.Compilers.circuit_to_gslv.gslv_pf(circuit: MultiCircuit, pf_opt: PowerFlowOptions, time_series: bool = False, time_indices: Union[IntVec, None]=None, opf_results: Union[None, OptimalPowerFlowResults]=None, logger: Logger = <VeraGridEngine.basic_structures.Logger object>) → pg.PowerFlowResults[source]

GSLV power flow :param logger: :param circuit: MultiCircuit instance :param pf_opt: Power Flow Options :param time_series: Compile with VeraGrid time series? :param time_indices: Array of time indices :param opf_results: Instance of :return: GSLV Power flow results object

VeraGridEngine.Compilers.circuit_to_gslv.to_gslv(circuit: MultiCircuit, use_time_series: bool, time_indices: IntVec | None = None, override_branch_controls=False, opf_results: None | OptimalPowerFlowResults = None) → Tuple['pg.MultiCircuit', GslvDicts][source]

Convert VeraGrid circuit to GSLV :param circuit: MultiCircuit :param use_time_series: compile the time series from VeraGrid? otherwise just the snapshot :param time_indices: Array of time indices :param override_branch_controls: If true the branch controls are set to Fix :param opf_results: :return: pg.MultiCircuit instance

VeraGridEngine.Compilers.circuit_to_gslv.translate_gslv_investments_evaluation_results(res: pg.InvestmentsEvaluationResults) → InvestmentsEvaluationResults[source]

Translate GSLV investment-evaluation results to VeraGrid results.

Parameters:

res – GSLV investments-evaluation results.

Returns:

VeraGrid investments-evaluation results.

VeraGridEngine.Compilers.circuit_to_gslv.translate_gslv_pf_results(grid: MultiCircuit, res: pg.PowerFlowResults) → PowerFlowResults[source]

Translate the GSLV Power Analytics results back to VeraGrid :param grid: MultiCircuit instance :param res: GSLV’s PowerFlowResults instance :return: PowerFlowResults instance

VeraGridEngine.Compilers.circuit_to_gslv.translate_gslv_pf_time_series_results(grid: MultiCircuit, res: pg.PowerFlowResults, options: PowerFlowOptions, time_indices: IntVec | None, clustering_results) → PowerFlowTimeSeriesResults[source]

Translate GSLV time-series power-flow results to VeraGrid results.

Parameters:

  • grid – MultiCircuit instance.

  • res – GSLV power-flow results.

  • options – Power-flow options used for the run.

  • time_indices – Requested global time indices, or None for all.

  • clustering_results – Optional clustering metadata.

Returns:

PowerFlowTimeSeriesResults instance.

VeraGridEngine.Compilers.circuit_to_newton_pa module

class VeraGridEngine.Compilers.circuit_to_newton_pa.FakeAdmittances[source]

Bases: object

Fake admittances class needed to make the translation

VeraGridEngine.Compilers.circuit_to_newton_pa.add_battery_data(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None, opf_results: None | OptimalPowerFlowResults = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

  • opf_results – OptimelPowerFlowResults (optional)

VeraGridEngine.Compilers.circuit_to_newton_pa.add_dc_line_data(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_newton_pa.add_hvdc_data(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time=1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_areas(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, n_time: int = 1) → Dict[dev.Area, 'npa.Area'][source]

Add Newton Areas :param circuit: VeraGrid circuit :param npa_circuit: Newton Circuit :param n_time: number of time steps :return: Dictionary [VeraGrid area] -> Newton Area

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_buses(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, time_series: bool, n_time: int = 1, time_indices: IntVec | None = None, area_dict: Dict[dev.Area, 'npa.Area'] | None = None) → Dict[str, 'npa.CalculationNode'][source]

Convert the buses to Newton buses :param circuit: VeraGrid circuit :param npa_circuit: Newton circuit :param time_series: compile the time series from VeraGrid? otherwise, just the snapshot :param n_time: number of time steps :param time_indices: Array of time indices :param area_dict: Area object translation dictionary :return: bus dictionary buses[uuid] -> Bus

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_contingencies(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, n_time: int, groups_dict: Dict[dev.ContingencyGroup, 'npa.ContingenciesGroup'])[source]

Add Newton ContingenciesGroup :param circuit: VeraGrid circuit :param npa_circuit: Newton Circuit :param n_time: number of time steps :param groups_dict: Contingency groups dictionary :return: Dictionary [VeraGrid ContingenciesGroup] -> Newton ContingenciesGroup

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_contingency_groups(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, n_time: int = 1) → Dict[dev.ContingencyGroup, 'npa.ContingenciesGroup'][source]

Add Newton ContingenciesGroup :param circuit: VeraGrid circuit :param npa_circuit: Newton Circuit :param n_time: number of time steps :return: Dictionary [VeraGrid ContingenciesGroup] -> Newton ContingenciesGroup

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_generators(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time=1, time_indices: IntVec | None = None, opf_results: None | OptimalPowerFlowResults = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

  • opf_results – OptimelPowerFlowResults (optional)

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_investment_groups(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, n_time: int)[source]
Parameters:

  • circuit

  • npa_circuit

  • n_time

Returns:

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_investments(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, n_time: int, groups_dict: Dict[dev.InvestmentsGroup, 'npa.InvestmentsGroup'])[source]
Parameters:

  • circuit

  • npa_circuit

  • n_time

  • groups_dict

Returns:

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_line(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_loads(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time=1, time_indices: IntVec | None = None, opf_results: None | OptimalPowerFlowResults = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • bus_dict – dictionary of bus id to Newton bus object

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • n_time – number of time steps

  • time_indices

  • opf_results

Returns:

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_shunts(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time=1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_static_generators(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time=1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_newton_pa.add_npa_zones(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, n_time: int = 1) → Dict[dev.Zone, 'npa.Zone'][source]

Add Newton Zones :param circuit: VeraGrid circuit :param npa_circuit: Newton Circuit :param n_time: number of time steps :return: Dictionary [VeraGrid Zone] -> Newton Zone

VeraGridEngine.Compilers.circuit_to_newton_pa.add_transformer3w_data(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time=1, time_indices: IntVec | None = None, override_controls=False)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

  • override_controls – If true the controls are set to Fix

VeraGridEngine.Compilers.circuit_to_newton_pa.add_transformer_data(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None, override_controls=False)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

  • override_controls – If true the controls are set to Fix

VeraGridEngine.Compilers.circuit_to_newton_pa.add_vsc_data(circuit: MultiCircuit, npa_circuit: npa.HybridCircuit, bus_dict: Dict[str, 'npa.CalculationNode'], time_series: bool, n_time: int = 1, time_indices: IntVec | None = None)[source]
Parameters:

  • circuit – VeraGrid circuit

  • npa_circuit – Newton circuit

  • time_series – compile the time series from VeraGrid? otherwise just the snapshot

  • bus_dict – dictionary of bus id to Newton bus object

  • n_time – number of time steps

  • time_indices – Array of time indices

VeraGridEngine.Compilers.circuit_to_newton_pa.convert_bus_types(arr: List['npa.BusType']) → IntVec[source]

Convert list of Newton bus types to an array of VeraGrid compatible bus type integers :param arr: Array of Newton bus types :return: Array of integers representing VeraGrid bus types

VeraGridEngine.Compilers.circuit_to_newton_pa.debug_newton_pa_circuit_at(npa_circuit: npa.HybridCircuit, t: int = None)[source]

Debugging function :param npa_circuit: Newton’s HybridCircuit :param t: time index

VeraGridEngine.Compilers.circuit_to_newton_pa.get_final_profile(time_series: bool, time_indices: ~numpy.ndarray[tuple[~typing.Any, ...], ~numpy.dtype[~numpy.int64]] | None, profile: ~numpy.ndarray[tuple[~typing.Any, ...], ~numpy.dtype[~numpy.int64]] | ~numpy.ndarray[tuple[~typing.Any, ...], ~numpy.dtype[~numpy.float64]] | None, ntime=1, default_val=0, dtype=<class 'float'>) → ndarray[tuple[Any, ...], dtype[float64]] | ndarray[tuple[Any, ...], dtype[int64]][source]

Generates a default time series :param time_series: use time series? :param time_indices: time series indices if any (optional) :param profile: Profile array (must be provided if time_series = True :param ntime: (if time_series = False) number of time steps :param default_val: Default value :param dtype: data type (float, int, etc…) :return: Profile array

VeraGridEngine.Compilers.circuit_to_newton_pa.get_newton_mip_solvers_list() → List[str][source]

Get list of available MIP solvers :return:

VeraGridEngine.Compilers.circuit_to_newton_pa.get_newton_pa_linear_opf_options(opf_opt: OptimalPowerFlowOptions, pf_opt: PowerFlowOptions, area_dict)[source]

Translate VeraGrid power flow options to Newton power flow options :param opf_opt: :param pf_opt: :param area_dict: :return:

VeraGridEngine.Compilers.circuit_to_newton_pa.get_newton_pa_linear_options(opt: LinearAnalysisOptions) → npa.LinearAnalysisOptions[source]

Translate VeraGrid power flow options to Newton power flow options :param opt: :return:

VeraGridEngine.Compilers.circuit_to_newton_pa.get_newton_pa_nonlinear_opf_options(pf_opt: PowerFlowOptions, opf_opt: OptimalPowerFlowOptions) → npa.NonlinearOpfOptions[source]

Translate VeraGrid power flow options to Newton power flow options :param pf_opt: PowerFlowOptions instance :param opf_opt: OptimalPowerFlowOptions instance :return: NonlinearOpfOptions

VeraGridEngine.Compilers.circuit_to_newton_pa.get_newton_pa_pf_options(opt: PowerFlowOptions) → npa.PowerFlowOptions[source]

Translate VeraGrid power flow options to Newton power flow options :param opt: :return:

VeraGridEngine.Compilers.circuit_to_newton_pa.get_snapshots_from_newtonpa(circuit: MultiCircuit, override_branch_controls=False) → List[NumericalCircuit][source]
Parameters:

  • circuit

  • override_branch_controls

Returns:

VeraGridEngine.Compilers.circuit_to_newton_pa.newton_pa_contingencies(circuit: MultiCircuit, con_opt: ContingencyAnalysisOptions, time_series: bool = False, time_indices: IntVec | None = None) → npa.ContingencyAnalysisResults[source]

Newton power flow :param circuit: MultiCircuit instance :param con_opt: ContingencyAnalysisOptions :param time_series: Compile with VeraGrid time series? :param time_indices: Array of time indices :return: Newton Power flow results object

VeraGridEngine.Compilers.circuit_to_newton_pa.newton_pa_linear_matrices(circuit: MultiCircuit, distributed_slack=False, override_branch_controls=False)[source]

Newton linear analysis :param circuit: MultiCircuit instance :param distributed_slack: distribute the PTDF slack :param override_branch_controls: Override branch controls :return: Newton LinearAnalysisMatrices object

VeraGridEngine.Compilers.circuit_to_newton_pa.newton_pa_linear_opf(circuit: MultiCircuit, opf_options: OptimalPowerFlowOptions, pf_opt: PowerFlowOptions, time_series=False, time_indices: IntVec | None = None) → npa.LinearOpfResults[source]

Newton power flow :param circuit: MultiCircuit instance :param opf_options: :param pf_opt: Power Flow Options :param time_series: Compile with VeraGrid time series? :param time_indices: Array of time indices :return: Newton Power flow results object

VeraGridEngine.Compilers.circuit_to_newton_pa.newton_pa_nonlinear_opf(circuit: MultiCircuit, pf_opt: PowerFlowOptions, opf_opt: OptimalPowerFlowOptions, time_series=False, time_indices: IntVec | None = None) → npa.NonlinearOpfResults[source]

Newton power flow :param circuit: MultiCircuit instance :param pf_opt: Power Flow Options :param opf_opt: OptimalPowerFlowOptions :param time_series: Compile with VeraGrid time series? :param time_indices: Array of time indices :return: Newton Power flow results object (NonlinearOpfResults)

VeraGridEngine.Compilers.circuit_to_newton_pa.newton_pa_pf(circuit: MultiCircuit, pf_opt: PowerFlowOptions, time_series: bool = False, time_indices: IntVec | None = None, opf_results: None | OptimalPowerFlowResults = None) → npa.PowerFlowResults[source]

Newton power flow :param circuit: MultiCircuit instance :param pf_opt: Power Flow Options :param time_series: Compile with VeraGrid time series? :param time_indices: Array of time indices :param opf_results: Instance of :return: Newton Power flow results object

VeraGridEngine.Compilers.circuit_to_newton_pa.to_newton_pa(circuit: MultiCircuit, use_time_series: bool, time_indices: IntVec | None = None, override_branch_controls=False, opf_results: None | OptimalPowerFlowResults = None)[source]

Convert VeraGrid circuit to Newton :param circuit: MultiCircuit :param use_time_series: compile the time series from VeraGrid? otherwise just the snapshot :param time_indices: Array of time indices :param override_branch_controls: If true the branch controls are set to Fix :param opf_results: :return: npa.HybridCircuit instance

VeraGridEngine.Compilers.circuit_to_newton_pa.translate_contingency_report(newton_report, veragrid_report)[source]

Translate contingency report :param newton_report: :param veragrid_report: :return:

VeraGridEngine.Compilers.circuit_to_newton_pa.translate_newton_pa_contingencies(grid: MultiCircuit, con_res: npa.ContingencyAnalysisResults) → ContingencyAnalysisResults[source]
Parameters:

  • grid

  • con_res

Returns:

VeraGridEngine.Compilers.circuit_to_newton_pa.translate_newton_pa_opf_results(grid: MultiCircuit, res: npa.NonlinearOpfResults) → OptimalPowerFlowResults[source]

Translate Newton OPF results to VeraGrid :param grid: MultiCircuit instance :param res: NonlinearOpfResults instance :return: OptimalPowerFlowResults instance

VeraGridEngine.Compilers.circuit_to_newton_pa.translate_newton_pa_pf_results(grid: MultiCircuit, res: npa.PowerFlowResults) → PowerFlowResults[source]

Translate the Newton Power Analytics results back to VeraGrid :param grid: MultiCircuit instance :param res: Newton’s PowerFlowResults instance :return: PowerFlowResults instance

VeraGridEngine.Compilers.circuit_to_optimods module

VeraGridEngine.Compilers.circuit_to_optimods.solve_acopf(case: Dict) → Dict[source]

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)[source]

Bases: JSONEncoder

default(obj)[source]

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    # Let the base class default method raise the TypeError
    return super().default(o)
VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_buses(circuit: MultiCircuit, idx0)[source]

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)[source]
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)[source]
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)[source]
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)[source]
VeraGridEngine.Compilers.circuit_to_pgm.get_pgm_line(circuit: MultiCircuit, bus_dict, idx0, logger: Logger)[source]
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)[source]

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)[source]
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)[source]
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)[source]
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)[source]
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)[source]

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)[source]

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][source]

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[source]

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[source]

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

Module contents