AbstractSecurityAnalysisRunParameters.java
/**
* Copyright (c) 2024, RTE (http://www.rte-france.com/)
* 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 http://mozilla.org/MPL/2.0/.
* SPDX-License-Identifier: MPL-2.0
*/
package com.powsybl.security;
import com.powsybl.action.Action;
import com.powsybl.commons.report.ReportNode;
import com.powsybl.computation.ComputationManager;
import com.powsybl.computation.local.LocalComputationManager;
import com.powsybl.security.interceptors.SecurityAnalysisInterceptor;
import com.powsybl.security.monitor.StateMonitor;
import com.powsybl.security.strategy.OperatorStrategy;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Supplier;
/**
* @author Laurent Issertial {@literal <laurent.issertial at rte-france.com>}
*/
public abstract class AbstractSecurityAnalysisRunParameters<T extends AbstractSecurityAnalysisRunParameters<T>> {
protected static final Supplier<LimitViolationFilter> DEFAULT_FILTER_SUPPLIER = LimitViolationFilter::load;
protected static final Supplier<ComputationManager> DEFAULT_COMPUTATION_MANAGER_SUPPLIER = LocalComputationManager::getDefault;
private LimitViolationFilter filter;
private ComputationManager computationManager;
private List<SecurityAnalysisInterceptor> interceptors = new ArrayList<>();
private List<OperatorStrategy> operatorStrategies = new ArrayList<>();
private List<Action> actions = new ArrayList<>();
private List<StateMonitor> monitors = new ArrayList<>();
private ReportNode reportNode = ReportNode.NO_OP;
/**
* {@link LimitViolationFilter} getter<br>
* If null, sets the field to its default value with {@link #DEFAULT_FILTER_SUPPLIER} before returning it.
*/
public LimitViolationFilter getFilter() {
if (filter == null) {
setFilter(DEFAULT_FILTER_SUPPLIER.get());
}
return filter;
}
/**
* {@link ComputationManager} getter<br>
* If null, sets the field to its default value with {@link #DEFAULT_COMPUTATION_MANAGER_SUPPLIER} before returning it.
*/
public ComputationManager getComputationManager() {
if (computationManager == null) {
setComputationManager(DEFAULT_COMPUTATION_MANAGER_SUPPLIER.get());
}
return computationManager;
}
public List<SecurityAnalysisInterceptor> getInterceptors() {
return interceptors;
}
public List<OperatorStrategy> getOperatorStrategies() {
return operatorStrategies;
}
public List<Action> getActions() {
return actions;
}
public List<StateMonitor> getMonitors() {
return monitors;
}
public ReportNode getReportNode() {
return reportNode;
}
public T setFilter(LimitViolationFilter filter) {
Objects.requireNonNull(filter, "LimitViolationFilter should not be null");
this.filter = filter;
return self();
}
/**
* Sets the computationManager handling command execution.
*/
public T setComputationManager(ComputationManager computationManager) {
Objects.requireNonNull(computationManager, "ComputationManager should not be null");
this.computationManager = computationManager;
return self();
}
/**
* Sets the list of operator strategies to apply to solve limit violations occurring after a contingency,
* see {@link OperatorStrategy}.
*/
public T setOperatorStrategies(List<OperatorStrategy> operatorStrategies) {
Objects.requireNonNull(operatorStrategies, "OperatorStrategy list should not be null");
this.operatorStrategies = operatorStrategies;
return self();
}
/**
* Sets the list of interceptors to notify at specific steps of the security analysis,
* see {@link SecurityAnalysisInterceptor}.
*/
public T setInterceptors(List<SecurityAnalysisInterceptor> interceptors) {
Objects.requireNonNull(interceptors, "Interceptor list should not be null");
this.interceptors = interceptors;
return self();
}
/**
* Sets the list of state monitors, see {@link StateMonitor}
*/
public T setMonitors(List<StateMonitor> monitors) {
Objects.requireNonNull(monitors, "StateMonitor list should not be null");
this.monitors = monitors;
return self();
}
/**
* Sets the list of actions referenced in {@link OperatorStrategy}
*/
public T setActions(List<Action> actions) {
Objects.requireNonNull(actions, "Action list should not be null");
this.actions = actions;
return self();
}
/**
* Sets the reportNode used for functional logs, see {@link ReportNode}
*/
public T setReportNode(ReportNode reportNode) {
Objects.requireNonNull(reportNode, "ReportNode should not be null");
this.reportNode = reportNode;
return self();
}
public T addOperatorStrategy(OperatorStrategy operatorStrategy) {
Objects.requireNonNull(operatorStrategy, "OperatorStrategy should not be null");
operatorStrategies.add(operatorStrategy);
return self();
}
public T addInterceptor(SecurityAnalysisInterceptor interceptor) {
Objects.requireNonNull(interceptor, "Interceptor should not be null");
interceptors.add(interceptor);
return self();
}
public T addMonitor(StateMonitor monitor) {
Objects.requireNonNull(monitor, "StateMonitor should not be null");
monitors.add(monitor);
return self();
}
public T addAction(Action action) {
Objects.requireNonNull(action, "Action should not be null");
actions.add(action);
return self();
}
protected abstract T self();
}