components.h

Go to the documentation of this file.

/*
 * components.h
 *
 * It contains all individual components
 *
 */
 
#ifndef COMPONENTS_H
#define COMPONENTS_H
 
#include <map>
#include <random>
#include <string>
#include <vector>
 
// The following classes are defined in this header file:
class BaseComponent;
class BaseComponentSemiFlexible;
class RoofSectionPV;
class ComponentPV;
class ComponentBS;
class ComponentHP;
class ComponentCS;
class EVFSM;
 
#include "global.h"
#include "vehicles.h"
 
 
class BaseComponent {
    public:
        virtual ~BaseComponent() {}
        // modifieres (on structural level of the simulation)
        virtual void resetInternalState() = 0; 
        // modifiers (in the course of simulation time)
        virtual void resetWeeklyCounter() = 0; 
};
 
class BaseComponentSemiFlexible : public BaseComponent {
    public:
        BaseComponentSemiFlexible();
        ~BaseComponentSemiFlexible();
        virtual double get_currentDemand_kW() const = 0;
 
        const std::vector<double>* get_future_max_consumption_kWh() const { return &future_maxE_storage; }
 
        const std::vector<double>* get_future_min_consumption_kWh() const { return &future_minE_storage; }
 
        void set_horizon_in_ts(unsigned int new_horizon);
 
        virtual void setDemandToProfileData(unsigned long ts) = 0;
 
        virtual bool setDemandToGivenValue(double new_demand_kW) = 0;
 
    protected:
        // cached member variables
        std::vector<double> future_maxE_storage;
        std::vector<double> future_minE_storage;
        
};
 
 
class RoofSectionPV {
    public:
        RoofSectionPV(size_t locationID, float this_section_kWp, const std::string& orientation);
        float get_generation_at_ts_kW(unsigned long ts) const; 
        float get_section_kWp()    const { return this_section_kWp; }
        const std::string& get_orientation()   const { return orientation;      }
        size_t get_profile_index() const { return profile_index;    }
        // structural modifiers
        void update_section_kWp(float new_kWp); 
    private:
        // constant member variables
        const float* profile_data; 
        float this_section_kWp; // not const, because it can be changed (e.g., by the optimization when integrating PV optimization)
        const std::string orientation;
        size_t profile_index;
        //
        // static data for selecting the next time series for expansion
        static std::map<std::string, size_t> next_pv_idx; 
        // static data for selecting the next time series randomly
        static std::map<std::string, std::default_random_engine>            random_generators;
        static std::map<std::string, std::uniform_int_distribution<size_t>> distributions;
};
 
class ComponentPV : public BaseComponent {
    public:
        ComponentPV(float kWp_static, unsigned long locationID); 
        ComponentPV(float kWp_per_m2, float min_kWp_sec, float max_kWp_sec, float max_kWp_unit, unsigned long locationID); 
        // getter methods
        double get_kWp() const           { return total_kWp; } 
        float get_currentGeneration_kW() const { return currentGeneration_kW; }
        double get_cweek_generation_kWh(){ return generation_cumsum_cweek_kWh; } 
        double get_total_generation_kWh(){ return generation_cumsum_total_kWh; } 
        float get_generation_at_ts_kW(unsigned long ts) const; 
        std::string* get_section_string(const std::string& prefix_per_line); 
        const std::vector<double>* get_future_generation_kW() const { return &future_generation_kW; }
        std::list<std::vector<double>> get_total_generation_by_section_kW() const;
        std::list<double> get_kWp_per_section() const;
        //
        // update / action methods during simulation run
        void  calculateCurrentFeedin(unsigned long ts);
        // methods for simulation reset
        void resetWeeklyCounter();
        void resetInternalState();
        void set_horizon_in_ts(unsigned int new_horizon); 
        // modification methods for structural modifications
        void set_kWp_per_section(const std::list<double>& new_values);
    private:
        // constant members
        std::vector<RoofSectionPV> roof_sections;
        // semi-constant member variables, i.e. they might change for parameter variations
        float total_kWp;
        // member variables that can change over time
        float currentGeneration_kW;
        std::vector<double> future_generation_kW; 
        double generation_cumsum_total_kWh; 
        double generation_cumsum_cweek_kWh; 
};
 
class ComponentBS : public BaseComponent {
    friend class EVFSM;
    public:
        ComponentBS(double maxE_kWh, double maxP_kW, double E_over_P_ratio, double discharge_rate_per_step, double efficiency_in, double efficiency_out, double initial_SoC); 
        ComponentBS(double maxE_kWh, double discharge_rate_per_step, double efficiency_in, double initial_SoC); 
        // getter methods
        double get_SOC() const               { return SOC; }          
        double get_SOE() const               { return currentE_kWh; } 
        double get_currentCharge_kWh() const { return currentE_kWh; } 
        double get_currentLoad_kW()    const { return currentP_kW;  } 
        double get_gridOnly_discharge_kW() const { return currentP_from_grid_kW; } 
        double get_maxE_kWh()       const    { return maxE_kWh;     } 
        double get_maxP_kW()        const    { return maxP_kW;      } 
        double get_current_EFC()   const    { return (maxE_kWh > 0) ? total_E_withdrawn_kWh / maxE_kWh : 0.0; } 
        double get_cweek_EFC()     const    { return (maxE_kWh > 0) ? cweek_E_withdrawn_kWh / maxE_kWh : 0.0; } 
        unsigned long get_n_ts_empty() const { return n_ts_SOC_empty; } 
        unsigned long get_n_ts_full()  const { return n_ts_SOC_full;  } 
        double get_cweek_withdrawn_E_kWh() const { return cweek_E_withdrawn_kWh; } 
        double get_total_withdrawn_E_kWh() const { return total_E_withdrawn_kWh; } 
        double get_cweek_withdrawn_E_gridOnly_kWh() const { return cweek_E_withdrawn_from_grid_kWh; } 
        double get_total_withdrawn_E_gridOnly_kWh() const { return total_E_withdrawn_from_grid_kWh; } 
        // setter methods
        void  set_chargeRequest(double requested_charge_kW) { charge_request_kW = requested_charge_kW; }
        void  set_grid_charged_amount(double grid_charged_kW); 
    protected:
        void  set_SOE_without_computations(double new_SOE_kWh); 
    public:
        void  set_maxE_kWh(double value);
        void  set_maxP_kW (double value);
        void  set_maxP_by_EPRatio(double EP_ratio);
        // update / action methods
        void calculateActions();
        void resetWeeklyCounter();
        void resetInternalState();
    private:
        // semi-constant member variables, i.e. they might change for parameter variations
        double maxE_kWh;
        double maxP_kW;
        double E_over_P_ratio;
        // constant member variables (other languages might call this 'final')
        const double discharge_rate_per_step;
        const double efficiency_in;
        const double efficiency_out;
        const double initial_SoC;
        // member variables that can change over time
        double SOC;
        double currentE_kWh; 
        double currentP_kW;  
        double currentE_from_grid_kWh;  
        double currentP_from_grid_kW;   
        double charge_request_kW;
        double cweek_E_withdrawn_kWh; 
        double total_E_withdrawn_kWh; 
        double cweek_E_withdrawn_from_grid_kWh; 
        double total_E_withdrawn_from_grid_kWh; 
        unsigned long n_ts_SOC_empty; 
        unsigned long n_ts_SOC_full;  
};
 
class ComponentHP : public BaseComponentSemiFlexible {
    public:
        ComponentHP(const ControlUnit* connected_unit, float annual_econs_kWh);
        // getter methods
        using BaseComponentSemiFlexible::get_currentDemand_kW;
        double get_currentDemand_kW() const { return currentDemand_kW; }
        double get_total_consumption_kWh()   const { return total_consumption_kWh; }
        double get_cweek_consumption_kWh()   const { return cweek_consumption_kWh; }
        float get_rated_power_without_AUX()  const { return rated_power_kW; }
        //float  get_demand_at_ts_kW(unsigned long ts) const; ///< Returns the demand of the heat pump at a given time step in kW. If there is no data available for this time step, 0.0 is returned.
        using BaseComponentSemiFlexible::get_future_max_consumption_kWh;
        using BaseComponentSemiFlexible::get_future_min_consumption_kWh;
        const std::vector<double>* get_future_max_power_kW() const { return &future_maxP_storage; }
        const std::vector<double>* get_future_min_power_kW() const { return &future_minP_storage; }
 
        //
        // update / action methods
        using BaseComponentSemiFlexible::set_horizon_in_ts;
        void set_horizon_in_ts(unsigned int new_horizon);
        void computeNextInternalState(unsigned long ts);
        using BaseComponentSemiFlexible::setDemandToProfileData;
        void setDemandToProfileData(unsigned long ts);
        using BaseComponentSemiFlexible::setDemandToGivenValue;
        bool setDemandToGivenValue(double new_demand_kW);
        void resetWeeklyCounter();
        void resetInternalState();
        //
        // static methods for initializing the random generators
        static void InitializeRandomGenerator();
        static void VacuumStaticVariables();
    private:
        // constant member variables
        const ControlUnit* connected_unit;
        const float yearly_electricity_consumption_kWh;
        const float scaling_factor; 
        const float* profile_data; 
        const double* profile_cumsum; 
        float rated_power_kW; 
        // member variables that can change over time
        double currentDemand_kW;
        double total_consumption_kWh; 
        double cweek_consumption_kWh; 
        std::vector<double> future_maxP_storage; 
        std::vector<double> future_minP_storage; 
#ifdef ADD_METHOD_ACCESS_PROTECTION_VARS
        // Variables for access protection of non-const methods during the simulation run
        bool state_s1;
#endif
        //
        // static data for selecting the next time series for expansion
        static size_t next_hp_idx;
        static bool random_generator_init;
        static std::default_random_engine* random_generator;
        static std::uniform_int_distribution<size_t>* distribution;
};
 
class ComponentCS : public BaseComponent {
    public:
        ComponentCS(ControlUnit* calling_control_unit, unsigned int number_of_flats); 
        ~ComponentCS();
        // getters
        bool is_enabled() const { return enabled; }
        double get_max_P_kW() const; 
        double get_currentDemand_kW() const { return current_demand_kW; } 
        double get_total_consumption_kWh() const { return total_consumption_kWh;  } 
        double get_cweek_consumption_kWh() const { return cweek_consumption_kWh;  } 
        unsigned long get_n_EVs_pc()  const; 
        unsigned long get_n_EVs_pnc() const; 
        unsigned long get_n_EVs()     const; 
        unsigned long get_possible_n_EVs() const; 
        unsigned long get_control_unit_id() const; 
        std::vector<const EVFSM*> get_listOfEVs() const {
            std::vector<const EVFSM*> const_list;
            const_list.reserve(listOfEVs.size());
            for (EVFSM* ev : listOfEVs) const_list.push_back(ev);
            return const_list;
        } 
        unsigned long get_n_chargers() const { return n_chargers; } 
        const std::vector<const std::vector<double>*>* get_future_max_consumption_kWh() const { return &future_maxE_storage; }
        const std::vector<const std::vector<double>*>* get_future_min_consumption_kWh() const { return &future_minE_storage; }
        const std::vector<const std::vector<double>*>* get_future_max_power_kW() const { return &future_maxP_storage; }
        // modifieres (on structural level of the simulation)
        void enable_station();
        void disable_station();
        void resetWeeklyCounter();
        void resetInternalState();
        void add_ev(unsigned long carID);
        void set_horizon_in_ts(unsigned int new_horizon); 
        void preprocess_ev_data(); 
        // modifiers (in the course of simulation time)
        void setCarStatesForTimeStep(unsigned long ts); 
        void setDemandToProfileData(unsigned long ts); 
        bool setDemandToGivenValues(std::vector<double>& charging_power_per_EV_kW); 
    private:
        // constant members
        const ControlUnit* installation_place;
        const unsigned long n_chargers; 
        double max_charging_power; // Not const, as the value might not be known on pre-initialization
        // variable members, constant during one simulation run
        bool enabled;
        std::vector<EVFSM*> listOfEVs;
        // variable members, variable during simulation run
        double current_demand_kW;
        double total_consumption_kWh;
        double cweek_consumption_kWh; 
        std::vector<const std::vector<double>*> future_maxE_storage; 
        std::vector<const std::vector<double>*> future_minE_storage;
        std::vector<const std::vector<double>*> future_maxP_storage;
#ifdef ADD_METHOD_ACCESS_PROTECTION_VARS
        // Variables for access protection of non-const methods during the simulation run
        bool is_callable_setCarStatesForTimeStep;
        bool is_callable_set_charging_value;
#endif
};
 
 
class EVFSM : public BaseComponentSemiFlexible {
 
    public:
        EVFSM(unsigned long carID, ComponentCS* homeStation);
        ~EVFSM();
        // getters
        EVState get_current_state() const { return current_state; }
        // EVStateIfConnAtHome get_current_state_icah() const { return current_state_icah; } ///< Returns the current state of the EV iff it is connected at home
        using BaseComponentSemiFlexible::get_future_max_consumption_kWh;
        using BaseComponentSemiFlexible::get_future_min_consumption_kWh;
        using BaseComponentSemiFlexible::get_currentDemand_kW;
        const std::vector<double>* get_future_max_power_kW() const { return &future_maxP_storage; } 
        double get_currentDemand_kW() const { return current_P_kW; } 
        std::string* get_metrics_string_annual(); 
        const ComponentBS* get_battery() const { return battery; } 
        // modifiers (on structural level of the simulation)
        using BaseComponentSemiFlexible::set_horizon_in_ts;
        void set_horizon_in_ts(unsigned int new_horizon);
        void add_weekly_tour(short weekday, unsigned long departure_ts_of_day, unsigned long ts_duration, double tour_length_km, bool with_work); 
        void preprocessTourInformation(); 
        void resetInternalState(); 
        // modifiers (in the course of simulation time)
        void setCarStateForTimeStep(unsigned long ts); 
        using BaseComponentSemiFlexible::setDemandToProfileData;
        void setDemandToProfileData(unsigned long ts);
        using BaseComponentSemiFlexible::setDemandToGivenValue;
        bool setDemandToGivenValue(double new_demand_kW);
        using BaseComponentSemiFlexible::resetWeeklyCounter;
        void resetWeeklyCounter() {} 
        // static methods
        static const std::map<unsigned long, EVFSM*>& GetArrayOfInstances() { return list_of_cars; } 
        static unsigned long GetNumberOfEVs() { return list_of_cars.size(); }
        static void AddWeeklyTour(unsigned long carID, short weekday, unsigned long departure_ts_of_day, unsigned long ts_duration, double tour_length_km, bool with_work); 
        static void VacuumStaticVariables();
        static void SetSeed(unsigned int seed); 
 
    private:
        // constant members
        const unsigned long carID;       
        const float econs_kWh_per_km;    
        ComponentCS const* homeStation;  
        // variable members (constant during a simulation run)
        std::vector<std::vector<WeeklyVehicleTour>*> list_of_tours_pd; 
        std::vector<WeeklyVehicleTour*> list_of_all_tours; 
        std::vector<EVState> prec_vec_of_states; 
        std::vector<double> prec_vec_of_minE; 
        std::vector<double> prec_vec_of_maxE; 
        std::vector<double> prec_vec_of_driving_distance_km; 
        std::vector<float>  prec_vec_of_maxP_kW; 
        std::vector<double> prec_vec_of_curr_BS_E_cons_kWh; 
        // cached member variables
        std::vector<double> future_maxP_storage;  
        // attached members
        ComponentBS* battery;
        // variable members, variable during a simulation run
        EVState current_state;           
        unsigned long current_ts;        
        //EVStateIfConnAtHome current_state_icah; ///< Internal current state of the EV iff it is connected at home
        double energy_demand_per_tour_ts; 
        double current_P_kW;  
        // variables for the final metrics calculation
        double sum_of_driving_distance_km;    
        double sum_of_E_used_for_driving_kWh; 
        double sum_of_E_charged_home_kWh;     
        double sum_of_E_discharged_home_kWh;  
        ulong  sum_of_ts_EV_is_connected;     
#ifdef ADD_METHOD_ACCESS_PROTECTION_VARS
        // Variables for access protection of non-const methods during the simulation run
        bool state_s1; // directly after initialization, tours can be added
        bool state_s2; // ready for new/first time step, i.e., all tour information has been processed, no tours can be added anymore
        bool state_s3; // EV internal state set to new time step, current demand can be set
#endif
        //
        // class members
        static std::map<unsigned long, EVFSM*> list_of_cars;
        static std::default_random_engine*            random_generator; 
        static std::uniform_real_distribution<float>* distribution    ; 
    public:
        static const std::string MetricsStringHeaderAnnual; 
};
 
#endif