com.powsybl.openrao.searchtreerao.commons.objectivefunctionevaluator.ObjectiveFunctionResultImpl Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2021, 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/.
 */

package com.powsybl.openrao.searchtreerao.commons.objectivefunctionevaluator;

import com.powsybl.openrao.data.cracapi.cnec.FlowCnec;
import com.powsybl.openrao.data.raoresultapi.ComputationStatus;
import com.powsybl.openrao.searchtreerao.result.api.FlowResult;
import com.powsybl.openrao.searchtreerao.result.api.ObjectiveFunctionResult;
import com.powsybl.openrao.searchtreerao.result.api.RangeActionActivationResult;
import com.powsybl.openrao.searchtreerao.result.api.SensitivityResult;
import org.apache.commons.lang3.tuple.Pair;

import java.util.*;

/**
 * @author Joris Mancini {@literal }
 */
public class ObjectiveFunctionResultImpl implements ObjectiveFunctionResult {
    private final ObjectiveFunction objectiveFunction;
    private final FlowResult flowResult;
    private final RangeActionActivationResult rangeActionActivationResult;
    private final SensitivityResult sensitivityResult;
    private final ComputationStatus sensitivityStatus;
    private boolean areCostsComputed;
    private Double functionalCost;
    private Map virtualCosts;
    private List orderedLimitingElements;
    private Map> orderedCostlyElements;

    private Set excludedContingencies;

    public ObjectiveFunctionResultImpl(ObjectiveFunction objectiveFunction,
                                       FlowResult flowResult,
                                       RangeActionActivationResult rangeActionActivationResult,
                                       SensitivityResult sensitivityResult,
                                       ComputationStatus sensitivityStatus) {
        this.objectiveFunction = objectiveFunction;
        this.flowResult = flowResult;
        this.rangeActionActivationResult = rangeActionActivationResult;
        this.sensitivityResult = sensitivityResult;
        this.sensitivityStatus = sensitivityStatus;
        this.areCostsComputed = false;
    }

    @Override
    public ObjectiveFunction getObjectiveFunction() {
        return objectiveFunction;
    }

    @Override
    public double getFunctionalCost() {
        if (!areCostsComputed) {
            computeCosts(new HashSet<>());
        }
        return functionalCost;
    }

    @Override
    public List getMostLimitingElements(int number) {
        if (!areCostsComputed) {
            computeCosts(new HashSet<>());
        }
        return orderedLimitingElements.subList(0, Math.min(orderedLimitingElements.size(), number));
    }

    @Override
    public double getVirtualCost() {
        if (!areCostsComputed) {
            computeCosts(new HashSet<>());
        }
        if (virtualCosts.size() > 0) {
            return virtualCosts.values().stream().mapToDouble(v -> v).sum();
        }
        return 0;
    }

    @Override
    public Set getVirtualCostNames() {
        return objectiveFunction.getVirtualCostNames();
    }

    @Override
    public double getVirtualCost(String virtualCostName) {
        if (!areCostsComputed) {
            computeCosts(new HashSet<>());
        }
        return virtualCosts.getOrDefault(virtualCostName, Double.NaN);
    }

    @Override
    public List getCostlyElements(String virtualCostName, int number) {
        if (!areCostsComputed) {
            computeCosts(new HashSet<>());
        }
        return orderedCostlyElements.get(virtualCostName).subList(0, Math.min(orderedCostlyElements.get(virtualCostName).size(), number));
    }

    @Override
    public void excludeContingencies(Set contingenciesToExclude) {
        if (!contingenciesToExclude.equals(excludedContingencies)) {
            computeCosts(contingenciesToExclude);
        }
    }

    private void computeCosts(Set contingenciesToExclude) {
        Pair> functionalCostAndLimitingElements = objectiveFunction.getFunctionalCostAndLimitingElements(flowResult, rangeActionActivationResult, sensitivityResult, sensitivityStatus, contingenciesToExclude);
        functionalCost = functionalCostAndLimitingElements.getLeft();
        orderedLimitingElements = functionalCostAndLimitingElements.getRight();
        virtualCosts = new HashMap<>();
        orderedCostlyElements = new HashMap<>();
        getVirtualCostNames().forEach(vcn -> {
            Pair> virtualCostAndCostlyElements = objectiveFunction.getVirtualCostAndCostlyElements(flowResult, rangeActionActivationResult, sensitivityResult, sensitivityStatus, vcn, contingenciesToExclude);
            virtualCosts.put(vcn, virtualCostAndCostlyElements.getLeft());
            orderedCostlyElements.put(vcn, virtualCostAndCostlyElements.getRight());
        });
        areCostsComputed = true;
        excludedContingencies = contingenciesToExclude;
    }
}