optimization_unit_general.hpp

Go to the documentation of this file.

 
#ifndef OPTIMIZATION_UNIT_GENERAL_HPP
#define OPTIMIZATION_UNIT_GENERAL_HPP
 
#include <vector>
 
class BaseOptimizedController {
    protected:
        const unsigned long controlUnitID; 
        const unsigned long n_cars; 
        unsigned long time_horizon;
        std::vector<double> bs_power; 
        std::vector<double> hp_power; 
        std::vector<std::vector<double>> ev_power; 
        std::list<double> optimal_pv_size_per_section_kW; 
        double optimal_bs_size_kWh; 
 
    public:
        BaseOptimizedController(unsigned long cuID, unsigned int time_horizon, unsigned long n_cars) :
            controlUnitID(cuID), n_cars(n_cars), bs_power(time_horizon, 0.0), hp_power(time_horizon, 0.0)
        {
            this->time_horizon = time_horizon;
            ev_power.assign(n_cars, std::vector<double>(time_horizon, 0.0));
            optimal_bs_size_kWh = 0.0;
        }
 
        virtual ~BaseOptimizedController() = default;
 
        const std::vector<double>& get_future_hp_power_kW() { return hp_power; }
 
        const std::vector<double>& get_future_bs_power_kW() { return bs_power; }
 
        const std::vector<std::vector<double>>& get_future_ev_power_kW() { return ev_power; }
 
        const std::list<double>& get_optimal_PV_size_per_section_kW() { return optimal_pv_size_per_section_kW; }
 
        double get_optimal_BS_size_kWh() { return optimal_bs_size_kWh; }
 
            void reset(unsigned int new_horizon) {
                this->time_horizon = new_horizon;
                bs_power.assign(new_horizon, 0.0);
                hp_power.assign(new_horizon, 0.0);
                ev_power.assign(this->n_cars, std::vector<double>(new_horizon, 0.0));
            }
 
            void shiftVectorsByOnePlace() {
                std::move(bs_power.begin() + 1, bs_power.end(), bs_power.begin());
                bs_power.back() = 0.0;
                std::move(hp_power.begin() + 1, hp_power.end(), hp_power.begin());
                hp_power.back() = 0.0;
                for (unsigned int evIdx = 0; evIdx < n_cars; evIdx++) {
                    std::move(ev_power[evIdx].begin() + 1, ev_power[evIdx].end(), ev_power[evIdx].begin());
                    ev_power[evIdx].back() = 0.0;
                }
            }
 
        virtual bool updateController(
            const unsigned long ts,
            double max_p_bs_kW,
            double max_e_bs_kWh,
            double max_p_cs_kW,
            double current_bs_charge_kWh,
            const std::vector<float>& future_resid_demand_kW,
            const std::vector<double>& future_pv_generation_kW,
            const std::vector<double>& future_hp_shiftable_maxP,
            const std::vector<double>& future_hp_shiftable_minP,
            const std::vector<double>& future_hp_shiftable_maxE,
            const std::vector<double>& future_hp_shiftable_minE,
            const std::vector<const std::vector<double>*>* future_ev_shiftable_maxE,
            const std::vector<const std::vector<double>*>* future_ev_shiftable_minE,
            const std::vector<const std::vector<double>*>* future_ev_maxP,
            const bool optimize_PV_size,
            const bool optimize_BS_size,
            const std::list<std::vector<double>>* total_PV_generation_per_section_kW,
            const std::list<double>* max_PV_power_per_section_kWp
        ) = 0;
};
 
#endif