# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at https://mozilla.org/MPL/2.0/.
# SPDX-License-Identifier: MPL-2.0
from warnings import warn
import numpy as np
from VeraGridEngine.Devices.multi_circuit import MultiCircuit
from VeraGridEngine.Simulations.ContingencyAnalysis.contingency_analysis_options import ContingencyAnalysisOptions
from VeraGridEngine.Simulations.ATC.available_transfer_capacity_options import AvailableTransferCapacityOptions
from VeraGridEngine.Simulations.ContinuationPowerFlow.continuation_power_flow_options import ContinuationPowerFlowOptions
from VeraGridEngine.Simulations.ContinuationPowerFlow.continuation_power_flow_input import ContinuationPowerFlowInput
from VeraGridEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOptions
from VeraGridEngine.Simulations.Clustering.clustering_options import ClusteringAnalysisOptions
from VeraGridEngine.Simulations.InvestmentsEvaluation.investments_evaluation_options import InvestmentsEvaluationOptions
from VeraGridEngine.Simulations.ATC.available_transfer_capacity_driver import (AvailableTransferCapacityDriver)
from VeraGridEngine.Simulations.ATC.available_transfer_capacity_ts_driver import (
AvailableTransferCapacityTimeSeriesDriver
)
from VeraGridEngine.Simulations.Clustering.clustering_driver import ClusteringDriver
from VeraGridEngine.Simulations.ContingencyAnalysis.contingency_analysis_driver import (ContingencyAnalysisDriver)
from VeraGridEngine.Simulations.ContingencyAnalysis.contingency_analysis_ts_driver import (
ContingencyAnalysisTimeSeriesDriver
)
from VeraGridEngine.Simulations.ContinuationPowerFlow.continuation_power_flow_driver import (
ContinuationPowerFlowDriver
)
from VeraGridEngine.Simulations.CatalogueOptimization.catalogue_optimization_driver import (
CatalogueOptimizationDriver,
CatalogueOptimizationOptions,
)
from VeraGridEngine.Simulations.InputsAnalysis.inputs_analysis_driver import InputsAnalysisDriver
from VeraGridEngine.Simulations.InvestmentsEvaluation.investments_evaluation_driver import (InvestmentsEvaluationDriver)
from VeraGridEngine.Simulations.LinearFactors.linear_analysis_driver import LinearAnalysisDriver
from VeraGridEngine.Simulations.LinearFactors.linear_analysis_results import LinearAnalysisResults
from VeraGridEngine.Simulations.LinearFactors.linear_analysis_ts_driver import (LinearAnalysisTimeSeriesDriver)
from VeraGridEngine.Simulations.NTC.ntc_driver import OptimalNetTransferCapacityDriver
from VeraGridEngine.Simulations.NTC.ntc_options import OptimalNetTransferCapacityOptions
from VeraGridEngine.Simulations.NTC.ntc_ts_driver import OptimalNetTransferCapacityTimeSeriesDriver
from VeraGridEngine.Simulations.NodalCapacity.nodal_capacity_ts_driver import (NodalCapacityTimeSeriesDriver)
from VeraGridEngine.Simulations.OPF.opf_driver import OptimalPowerFlowDriver
from VeraGridEngine.Simulations.OPF.opf_ts_driver import (OptimalPowerFlowTimeSeriesDriver)
from VeraGridEngine.Simulations.PowerFlow.power_flow_driver import PowerFlowDriver
from VeraGridEngine.Simulations.PowerFlow.power_flow_driver_3ph import PowerFlowDriver3Ph
from VeraGridEngine.Simulations.PowerFlow.power_flow_ts_driver import (PowerFlowTimeSeriesDriver)
from VeraGridEngine.Simulations.Reliability.blackout_driver import CascadingDriver
from VeraGridEngine.Simulations.Reliability.reliability_driver import ReliabilityStudyDriver
from VeraGridEngine.Simulations.Rms.rms_driver import RmsSimulationDriver
from VeraGridEngine.Simulations.Rms.rms_options import RmsOptions
from VeraGridEngine.Simulations.EMT.emt_driver import EmtSimulationDriver
from VeraGridEngine.Simulations.EMT.emt_options import EmtOptions
from VeraGridEngine.Simulations.SigmaAnalysis.sigma_analysis_driver import SigmaAnalysisDriver
from VeraGridEngine.Simulations.StateEstimation.state_stimation_driver import (
StateEstimationDriver,
StateEstimationOptions,
)
from VeraGridEngine.Simulations.ShortCircuitStudies.short_circuit_driver import ShortCircuitDriver
from VeraGridEngine.Simulations.Stochastic.stochastic_power_flow_driver import (StochasticPowerFlowDriver)
from VeraGridEngine.Simulations.Topology.node_groups_driver import NodeGroupsDriver
from VeraGridEngine.Simulations.types import DRIVER_OBJECTS
from VeraGridEngine.enumerations import SimulationTypes
from VeraGridEngine.basic_structures import IntVec
[docs]
def create_driver(grid: MultiCircuit,
driver_tpe: SimulationTypes,
time_indices: IntVec | None) -> DRIVER_OBJECTS | None:
"""
Create driver with the results
:param grid: MultiCircuit instance
:param driver_tpe: SimulationTypes
:param time_indices: list of time indices
:return: Driver or None
"""
if time_indices is None:
time_indices = grid.get_all_time_indices()
# get the results' object dictionary
if driver_tpe == SimulationTypes.NetTransferCapacity_run:
drv = AvailableTransferCapacityDriver(grid=grid,
options=AvailableTransferCapacityOptions())
elif driver_tpe == SimulationTypes.NetTransferCapacityTS_run:
drv = AvailableTransferCapacityTimeSeriesDriver(grid=grid,
options=AvailableTransferCapacityOptions(),
time_indices=time_indices,
clustering_results=None)
elif driver_tpe == SimulationTypes.ContingencyAnalysis_run:
drv = ContingencyAnalysisDriver(grid=grid,
options=ContingencyAnalysisOptions())
elif driver_tpe == SimulationTypes.ContingencyAnalysisTS_run:
drv = ContingencyAnalysisTimeSeriesDriver(grid=grid,
options=ContingencyAnalysisOptions(),
time_indices=time_indices,
clustering_results=None)
elif driver_tpe == SimulationTypes.ContinuationPowerFlow_run:
n = grid.get_bus_number()
drv = ContinuationPowerFlowDriver(grid=grid,
options=ContinuationPowerFlowOptions(),
inputs=ContinuationPowerFlowInput(
Sbase=np.zeros(n, dtype=complex),
Vbase=np.zeros(n, dtype=complex),
Starget=np.zeros(n, dtype=complex)
),
pf_options=PowerFlowOptions(),
opf_results=None)
elif driver_tpe == SimulationTypes.LinearAnalysis_run:
drv = LinearAnalysisDriver(grid=grid, options=None)
elif driver_tpe == SimulationTypes.LinearAnalysis_TS_run:
drv = LinearAnalysisTimeSeriesDriver(grid=grid,
options=None,
time_indices=time_indices,
clustering_results=None)
elif driver_tpe == SimulationTypes.OPF_run:
drv = OptimalPowerFlowDriver(grid=grid, options=None)
elif driver_tpe == SimulationTypes.OPFTimeSeries_run:
drv = OptimalPowerFlowTimeSeriesDriver(grid=grid,
options=None,
time_indices=time_indices,
clustering_results=None)
elif driver_tpe == SimulationTypes.NodalCapacityTimeSeries_run:
drv = NodalCapacityTimeSeriesDriver(grid=grid,
options=None,
time_indices=time_indices,
clustering_results=None)
elif driver_tpe == SimulationTypes.PowerFlow_run:
drv = PowerFlowDriver(grid=grid, options=PowerFlowOptions())
elif driver_tpe == SimulationTypes.PowerFlow3ph_run:
drv = PowerFlowDriver3Ph(grid=grid, options=PowerFlowOptions())
elif driver_tpe == SimulationTypes.PowerFlowTimeSeries_run:
drv = PowerFlowTimeSeriesDriver(grid=grid,
options=PowerFlowOptions(),
time_indices=time_indices,
clustering_results=None)
elif driver_tpe == SimulationTypes.StateEstimation_run:
drv = StateEstimationDriver(circuit=grid, options=StateEstimationOptions())
elif driver_tpe == SimulationTypes.SigmaAnalysis_run:
drv = SigmaAnalysisDriver(grid=grid, options=PowerFlowOptions())
elif driver_tpe == SimulationTypes.RmsDynamic_run:
# Disk retrieval only needs a driver shell that owns the correct results
# class. Saved RMS results already contain the solved traces.
drv = RmsSimulationDriver(
grid=grid,
options=RmsOptions(),
pf_results=None
)
elif driver_tpe == SimulationTypes.EmtDynamic_run:
# Disk retrieval only needs a driver shell that owns the correct results
# class. Saved EMT results already contain the solved traces.
drv = EmtSimulationDriver(
grid=grid,
options=EmtOptions(),
pf_results_3ph=None,
pf_results=None
)
elif driver_tpe == SimulationTypes.ShortCircuit_run:
drv = ShortCircuitDriver(grid=grid,
options=None,
pf_options=None,
pf_results=None,
pf_results3ph=None,
opf_results=None)
elif driver_tpe == SimulationTypes.StochasticPowerFlow:
drv = StochasticPowerFlowDriver(grid=grid, options=PowerFlowOptions())
elif driver_tpe == SimulationTypes.ClusteringAnalysis_run:
drv = ClusteringDriver(grid=grid, options=ClusteringAnalysisOptions(0))
elif driver_tpe == SimulationTypes.InputsAnalysis_run:
drv = InputsAnalysisDriver(grid=grid)
elif driver_tpe == SimulationTypes.InvestmentsEvaluation_run:
drv = InvestmentsEvaluationDriver(
grid=grid,
options=InvestmentsEvaluationOptions(
max_eval=0,
pf_options=PowerFlowOptions()
),
problem=None
)
elif driver_tpe == SimulationTypes.CatalogueOptimization_run:
drv = CatalogueOptimizationDriver(
grid=grid,
options=CatalogueOptimizationOptions(max_eval=0, pf_options=PowerFlowOptions()),
problem=None,
)
elif driver_tpe == SimulationTypes.OPF_NTC_run:
drv = OptimalNetTransferCapacityDriver(
grid=grid,
options=OptimalNetTransferCapacityOptions(
sending_bus_idx=np.zeros(0, dtype=int),
receiving_bus_idx=np.zeros(0, dtype=int),
),
)
elif (
driver_tpe == SimulationTypes.OptimalNetTransferCapacityTimeSeries_run
or driver_tpe == SimulationTypes.OPF_NTC_TS_run
):
drv = OptimalNetTransferCapacityTimeSeriesDriver(
grid=grid,
options=OptimalNetTransferCapacityOptions(
sending_bus_idx=np.zeros(0, dtype=int),
receiving_bus_idx=np.zeros(0, dtype=int),
),
time_indices=time_indices,
clustering_results=None,
)
elif driver_tpe == SimulationTypes.Reliability_run:
drv = ReliabilityStudyDriver(
grid=grid,
pf_options=PowerFlowOptions(),
time_indices=time_indices,
n_sim=0,
)
elif driver_tpe == SimulationTypes.Cascade_run:
drv = CascadingDriver(grid=grid, options=PowerFlowOptions())
elif driver_tpe == SimulationTypes.NodeGrouping_run:
drv = NodeGroupsDriver(
grid=grid,
sigmas=1.0,
min_group_size=1,
ptdf_results=LinearAnalysisResults(
br_names=grid.get_branch_names(add_hvdc=False, add_vsc=False, add_switch=True),
bus_names=grid.get_bus_names(),
hvdc_names=grid.get_hvdc_names(),
vsc_names=grid.get_vsc_names(),
bus_types=np.ones(grid.get_bus_number(), dtype=int),
),
)
else:
warn(f"Session {driver_tpe} not implemented for disk retrieval :/")
return None
return drv