def __init__(self, grid: MultiCircuit, options: OptimalPowerFlowOptions, start_=0, end_=None):
"""
PowerFlow class constructor
@param grid: MultiCircuit Object
@param options: OPF options
"""
QThread.__init__(self)
# Grid to run a power flow in
self.grid = grid
self.numerical_circuit = self.grid.compile()
# Options to use
self.options = options
# OPF results
self.results = OptimalPowerFlowTimeSeriesResults(n=len(self.grid.buses),
m=len(self.grid.branches),
nt=len(self.grid.time_profile),
ngen=len(self.grid.get_generators()),
nbat=len(self.grid.get_batteries()),
nload=len(self.grid.get_loads()),
time=self.grid.time_profile)
self.start_ = start_
self.end_ = end_
self.logger = list()
# set cancel state
self.__cancel__ = False
self.all_solved = True
def __init__(self, grid: MultiCircuit, options: LinearAnalysisOptions, start_=0, end_=None):
"""
TimeSeries constructor
@param grid: MultiCircuit instance
@param options: LinearAnalysisOptions instance
"""
QThread.__init__(self)
# reference the grid directly
self.grid = grid
self.options = options
self.results = PtdfTimeSeriesResults(n=0,
m=0,
time_array=[],
bus_names=[],
bus_types=[],
branch_names=[])
self.ptdf_driver = LinearAnalysis(grid=self.grid, distributed_slack=self.options.distribute_slack)
self.start_ = start_
self.end_ = end_
self.indices = pd.to_datetime(self.grid.time_profile)
self.elapsed = 0
self.logger = Logger()
self.__cancel__ = False
def __init__(self,
grid: MultiCircuit,
options: PowerFlowOptions,
opf_results: OptimalPowerFlowResults = None):
"""
PowerFlowDriver class constructor
:param grid: MultiCircuit instance
:param options: PowerFlowOptions instance
:param opf_results: OptimalPowerFlowResults instance
"""
QThread.__init__(self)
# Grid to run a power flow in
self.grid = grid
# Options to use
self.options = options
self.opf_results = opf_results
self.results = PowerFlowResults()
self.logger = Logger()
self.convergence_reports = list()
self.__cancel__ = False
def __init__(self, experiment: Experiment):
"""
Initialization of background worker.
:param experiment: Work on that experiment.
:type experiment: Experiment
"""
QThread.__init__(self)
self._experiment = copy.copy(experiment)
# remove thinks that are no longer useful
self._experiment.clearObservers()
saveObservers = None
saveObserversOrig = None
if self._experiment.dataStats is not None:
saveObservers = self._experiment.dataStats.observers
self._experiment.dataStats.clearObservers()
if self._experiment.origDataStats is not None:
saveObserversOrig = self._experiment.origDataStats.observers
self._experiment.origDataStats.clearObservers()
# no we can make deep copy
self._experiment = copy.deepcopy(self._experiment)
# return original observers
if saveObservers is not None:
experiment.dataStats.observers = saveObservers
if saveObserversOrig is not None:
experiment.origDataStats.observers = saveObserversOrig
def __init__(self):
QWidget.__init__(self)
QThread.__init__(self)
self._running = True
self._instance = None
self.lconnected = QLabel('')
self.lFlyState = QLabel('')
self.bTakeoff = QPushButton('')
self.bTakeoff.setDisabled(True)
self.bCircle = QPushButton('')
self.bCircle.setDisabled(True)
self.bRTH = QPushButton('')
self.bRTH.setDisabled(True)
self.layout = QVBoxLayout()
self.layout.addWidget(self.lconnected)
self.layout.addWidget(self.lFlyState)
self.layout.addWidget(self.bTakeoff)
self.layout.addWidget(self.bCircle)
self.layout.addWidget(self.bRTH)
self.setLayout(self.layout)
self.bTakeoff.clicked.connect(self.takeoff)
self.bCircle.clicked.connect(self.circle)
self.bRTH.clicked.connect(self.rth)
self.start()
def __init__(self, grid: MultiCircuit, options: PowerFlowOptions, triggering_idx=None, max_additional_islands=1,
cascade_type_: CascadeType = CascadeType.LatinHypercube, n_lhs_samples_=1000):
"""
Constructor
Args:
grid: MultiCircuit instance to cascade
options: Power flow Options
triggering_idx: branch indices to trigger first
max_additional_islands: number of islands that shall be formed to consider a blackout
cascade_type_: Cascade simulation kind
n_lhs_samples_: number of latin hypercube samples if using LHS cascade
"""
QThread.__init__(self)
self.grid = grid
self.options = options
self.triggering_idx = triggering_idx
self.__cancel__ = False
self.current_step = 0
self.max_additional_islands = max_additional_islands
self.cascade_type = cascade_type_
self.n_lhs_samples = n_lhs_samples_
self.results = CascadingResults(self.cascade_type)
def __init__(self, grid: MultiCircuit, sigmas=0.5, min_group_size=2, ptdf_results: LinearAnalysisResults = None):
"""
Electric distance clustering
:param grid: MultiCircuit instance
:param sigmas: number of standard deviations to consider
"""
QThread.__init__(self)
self.grid = grid
self.sigmas = sigmas
self.min_group_size = min_group_size
n = len(grid.buses)
self.use_ptdf = True
self.ptdf_results = ptdf_results
# results
self.X_train = np.zeros((n, n))
self.sigma = 1.0
self.groups_by_name = list()
self.groups_by_index = list()
self.__cancel__ = False
def __init__(self, grid: MultiCircuit, options: NMinusKOptions, pf_options: PowerFlowOptions):
"""
N - k class constructor
@param grid: MultiCircuit Object
@param options: N-k options
@:param pf_options: power flow options
"""
QThread.__init__(self)
# Grid to run
self.grid = grid
# Options to use
self.options = options
# power flow options
self.pf_options = pf_options
# OPF results
self.results = NMinusKResults(0, 0, 0)
# set cancel state
self.__cancel__ = False
self.all_solved = True
self.logger = Logger()
self.elapsed = 0.0
self.branch_names = list()
def __init__(self,
circuit: MultiCircuit,
file_name,
simulation_drivers=list(),
sessions=list()):
"""
Constructor
:param circuit: MultiCircuit instance
:param file_name: name of the file where to save
:param simulation_drivers: List of Simulation Drivers
"""
QThread.__init__(self)
self.circuit = circuit
self.file_name = file_name
self.valid = False
self.simulation_drivers = simulation_drivers
self.sessions = sessions
self.logger = Logger()
self.error_msg = ''
self.__cancel__ = False
def __init__(self, circuit: MultiCircuit, file_name, sleep_time):
"""
:param circuit: current circuit
:param file_name: name of the file to sync
:param sleep_time: seconds between executions
"""
QThread.__init__(self)
self.circuit = circuit
self.file_name = file_name
self.sleep_time = sleep_time
self.issues = list()
self.version_conflict = False
self.highest_version = 0
self.logger = Logger()
self.error_msg = ''
self.__cancel__ = False
self.__pause__ = False
def __init__(self, parent): # Initialise with serial port details
QThread.__init__(self)
self.parent = parent
self.ser = self.parent.ser_port
self.txq = Queue.Queue()
self.running = True
def __init__(self, processID: int, backend: str = "uia"):
"""
Constructs an Observer. The target application must already be started before constructing the Observer.
:raises: NoSuchProcess
:raises: AccessDenied
:param processID: The ID of the process to watch.
:type processID: int
:return: None
:rtype: NoneType
"""
QThread.__init__(self)
self._pid = processID
self._process = psutil.Process(processID)
self._backend = backend
self._childMapping = {
None: []
} # maps each super token to its list of children.
# maps each super token to the last iteration it was matched on.
self._lastSuperTokenIterations = {}
self._iteration = 0
self._playing = False
self._playingLock = Lock()
def __init__(self, circuit: MultiCircuit,
options: ContinuationPowerFlowOptions,
inputs: ContinuationPowerFlowInput,
pf_options: PowerFlowOptions,
opf_results=None, t=0):
"""
ContinuationPowerFlowDriver constructor
:param circuit: NumericalCircuit instance
:param options: ContinuationPowerFlowOptions instance
:param inputs: ContinuationPowerFlowInput instance
:param pf_options: PowerFlowOptions instance
:param opf_results:
"""
QThread.__init__(self)
# MultiCircuit instance
self.circuit = circuit
# voltage stability options
self.options = options
self.inputs = inputs
self.pf_options = pf_options
self.opf_results = opf_results
self.t = t
self.results = None
self.__cancel__ = False
def __init__(self, grid: MultiCircuit, options: PowerFlowOptions, opf_results: OptimalPowerFlowResults = None):
"""
PowerFlowDriver class constructor
:param grid: MultiCircuit instance
:param options: PowerFlowOptions instance
:param opf_results: OptimalPowerFlowResults instance
"""
QThread.__init__(self)
# Grid to run a power flow in
self.grid = grid
# Options to use
self.options = options
self.opf_results = opf_results
self.results = PowerFlowResults(n=0, m=0, n_tr=0, n_hvdc=0,
bus_names=(), branch_names=(), transformer_names=(),
hvdc_names=(), bus_types=())
self.logger = Logger()
self.convergence_reports = list()
self.__cancel__ = False
def __init__(self, wit_manager: WitManager, clean_iso_path: Path, output_folder: Path):
QThread.__init__(self)
self.wit_manager = wit_manager
self.clean_iso_path = clean_iso_path
self.output_folder = output_folder
self.steps = 0
def __init__(self,
circuit: MultiCircuit,
options: PowerFlowOptions,
max_iter=1000):
"""
Constructor
Args:
circuit: Grid to cascade
options: Power flow Options
max_iter: max iterations
"""
QThread.__init__(self)
self.circuit = circuit
self.options = options
self.max_iter = max_iter
self.__cancel__ = False
self.problem = None
self.solution = None
self.optimization_values = None
def __init__(self,
grid: MultiCircuit,
pf_options: PowerFlowOptions,
start_=0,
end_=None,
power_delta=10):
"""
TimeSeries constructor
@param grid: MultiCircuit instance
@param pf_options: PowerFlowOptions instance
"""
QThread.__init__(self)
# reference the grid directly
self.grid = grid
self.pf_options = pf_options
self.results = None
self.ptdf_driver = None
self.start_ = start_
self.end_ = end_
self.power_delta = power_delta
self.elapsed = 0
self.logger = Logger()
self.__cancel__ = False
def __init__(self, randomizer: Randomizer, wit_manager: WitManager, output_folder):
QThread.__init__(self)
self.randomizer = randomizer
self.wit_manager = wit_manager
self.output_folder = output_folder
self.steps = 0
def __init__(self, config, acs_control_widget, recorder_widget, parent=None):
QThread.__init__(self, parent)
self.config = config
self.acs_control_widget = acs_control_widget
self.recorder_widget = recorder_widget
self.recordingStopped = Event()
self.recordingStartedEvent = Event()
def __init__(self,
grid: MultiCircuit,
options: PowerFlowOptions,
sampling_points=1000,
opf_time_series_results=None):
"""
Latin Hypercube constructor
Args:
grid: MultiCircuit instance
options: Power flow options
sampling_points: number of sampling points
"""
QThread.__init__(self)
self.circuit = grid
self.options = options
self.sampling_points = sampling_points
self.opf_time_series_results = opf_time_series_results
self.results = None
self.logger = Logger()
self.pool = None
self.returned_results = list()
self.__cancel__ = False
def __init__(self,
grid: MultiCircuit,
options: PTDFOptions,
pf_options: PowerFlowOptions,
opf_results=None):
"""
Power Transfer Distribution Factors class constructor
@param grid: MultiCircuit Object
@param options: OPF options
"""
QThread.__init__(self)
# Grid to run
self.grid = grid
# Options to use
self.options = options
# power flow options
self.pf_options = pf_options
self.opf_results = opf_results
# OPF results
self.results = None
# set cancel state
self.__cancel__ = False
self.all_solved = True
self.elapsed = 0.0
self.logger = Logger()
def __init__(self, grid: MultiCircuit, options: PowerFlowOptions, opf_time_series_results=None,
start_=0, end_=None):
"""
TimeSeries constructor
@param grid: MultiCircuit instance
@param options: PowerFlowOptions instance
"""
QThread.__init__(self)
# reference the grid directly
self.grid = grid
self.options = options
self.opf_time_series_results = opf_time_series_results
self.results = None
self.start_ = start_
self.end_ = end_
self.elapsed = 0
self.logger = Logger()
self.returned_results = list()
self.pool = multiprocessing.Pool()
self.__cancel__ = False
def __init__(self,
grid: MultiCircuit,
options: PowerFlowOptions,
use_opf_vals=False,
opf_time_series_results=None,
start_=0,
end_=None):
"""
TimeSeries constructor
@param grid: MultiCircuit instance
@param options: PowerFlowOptions instance
"""
QThread.__init__(self)
# reference the grid directly
self.grid = grid
self.options = options
self.use_opf_vals = use_opf_vals
self.opf_time_series_results = opf_time_series_results
self.results = None
self.start_ = start_
self.end_ = end_
self.__cancel__ = False
def __init__(self,
circuit: MultiCircuit,
options: VoltageCollapseOptions,
inputs: VoltageCollapseInput,
pf_options: PowerFlowOptions,
opf_results=None):
"""
VoltageCollapse constructor
@param circuit: NumericalCircuit instance
@param options:
"""
QThread.__init__(self)
# MultiCircuit instance
self.circuit = circuit
# voltage stability options
self.options = options
self.inputs = inputs
self.pf_options = pf_options
self.opf_results = opf_results
self.results = list()
self.__cancel__ = False
def __init__(self, grid: MultiCircuit, options: PowerFlowOptions, mc_tol=1e-3, batch_size=100, max_mc_iter=10000):
"""
Monte Carlo simulation constructor
:param grid: MultiGrid instance
:param options: Power flow options
:param mc_tol: monte carlo std.dev tolerance
:param batch_size: size of the batch
:param max_mc_iter: maximum monte carlo iterations in case of not reach the precission
"""
QThread.__init__(self)
self.circuit = grid
self.options = options
self.mc_tol = mc_tol
self.batch_size = batch_size
self.max_mc_iter = max_mc_iter
n = len(self.circuit.buses)
m = self.circuit.get_branch_number()
self.results = MonteCarloResults(n, m, name='Monte Carlo')
self.logger = Logger()
self.pool = None
self.returned_results = list()
self.__cancel__ = False
def __init__(self, grid: MultiCircuit, options: NMinusKOptions):
"""
N - k class constructor
@param grid: MultiCircuit Object
@param options: N-k options
@:param pf_options: power flow options
"""
QThread.__init__(self)
# Grid to run
self.grid = grid
# Options to use
self.options = options
# N-K results
self.results = NMinusKResults(n=0,
m=0,
bus_names=(),
branch_names=(),
bus_types=())
self.numerical_circuit = None
# set cancel state
self.__cancel__ = False
self.logger = Logger()
self.elapsed = 0.0
self.branch_names = list()
def __init__(self,
grid: MultiCircuit,
options: PowerFlowOptions,
opf_time_series_results=None,
number_of_steps=10):
"""
TimeSeries constructor
@param grid: MultiCircuit instance
@param options: PowerFlowOptions instance
"""
QThread.__init__(self)
# reference the grid directly
self.grid = grid
self.options = options
self.opf_time_series_results = opf_time_series_results
self.results = None
self.number_of_steps = number_of_steps
self.elapsed = 0
self.logger = Logger()
self.returned_results = list()
self.pool = None
self.steps = self.sample_steps()
self.__cancel__ = False
def __init__(self, grid: MultiCircuit, options: OptimalPowerFlowOptions):
"""
PowerFlowDriver class constructor
@param grid: MultiCircuit Object
@param options: OPF options
"""
QThread.__init__(self)
# Grid to run a power flow in
self.grid = grid
# Options to use
self.options = options
# OPF results
self.results = None
# set cancel state
self.__cancel__ = False
self.all_solved = True
self.elapsed = 0.0
self.logger = Logger()
def __init__(self, grid: MultiCircuit, options: LinearAnalysisOptions):
"""
Power Transfer Distribution Factors class constructor
@param grid: MultiCircuit Object
@param options: OPF options
"""
QThread.__init__(self)
# Grid to run
self.grid = grid
# Options to use
self.options = options
# OPF results
self.results = LinearAnalysisResults(n_br=0,
n_bus=0,
br_names=[],
bus_names=[],
bus_types=[])
# set cancel state
self.__cancel__ = False
self.all_solved = True
self.elapsed = 0.0
self.logger = Logger()
def __init__(self, port, controller_service):
QThread.__init__(self)
logging.info("Starting trigger thread")
self.run_thread = True
self.ardunio = Ardunio(port)
self.controller_service = controller_service
self.current_led_state = [False, False, False, False]
def __init__(self, source, *args):
QThread.__init__(self, *args)
self.source = source
self.target = Target()
def __init__(self):
QThread.__init__(self)
def __init__(self,device='ME', tag='TAG', environment=ENV):
QThread.__init__(self)
SkelDataRec.__init__(self, device=device, tag=tag, environment=environment)
