units.h

Go to the documentation of this file.

/*
 * units.h
 *
 * It contains the definition of all units. A unit is
 * a compositions of individual components, that might
 * has more complex control rules or the additionl data
 * input.
 *
 */
 
#ifndef UNITS_H
#define UNITS_H
 
#include <atomic>
#include <condition_variable>
#include <string>
#include <list>
#include <map>
#include <mutex>
 
// The following classes are defined in this header file:
class Substation;
class ControlUnit;
class MeasurementUnit;
class OpenSpacePVOrWind;
 
#include "global.h"
#include "components.h"
#include "optimization_unit_general.hpp"
#include "output.h"
#include "worker_threads.hpp"
 
 
template<class Derived>
class BaseUnit {
    public:
        ~BaseUnit() = default;
 
        static void InitializeStaticVariables(unsigned long n) {
            Derived::InitializeStaticVariables(n);
        }
 
        static void VacuumInstancesAndStaticVariables() {
            Derived::VacuumInstancesAndStaticVariables();
        }
};
 
 
class Substation : BaseUnit<Substation> {
    public:
        static bool InstantiateNewSubstation(unsigned long public_id, std::string* name);
    private:
        Substation(unsigned long internal_id, unsigned long public_id, std::string* name);
    public:
        ~Substation();
        // getter methods
        unsigned long get_internal_id() const { return internal_id; } 
        unsigned long get_id()         const  { return public_id;   } 
        const std::string * get_name() const { return name; } 
        double get_station_load()       const { return station_load;    } 
        double get_residential_load()   const { return resident_load;   } 
        double get_residential_demand() const { return resident_demand; } 
        double get_other_demand()       const { return other_demand;    } 
        double get_current_demand_no_BESS()    const { return total_demand;    } 
        double get_current_BESS_demand()                 const { return total_BESS_demand;    } 
        double get_current_PV_generation_total_kW()      const { return pv_gen_total_kW;      } 
        double get_current_BS_generation_total_kW()      const { return bs_gen_total_kW;      } 
        double get_current_CHP_generation_total_kW()     const { return chp_gen_total_kW;     } 
        double get_current_wind_generation_total_kW()    const { return wind_gen_total_kW;    } 
        double get_current_unknown_generation_total_kW() const { return unknown_gen_total_kW; } 
        double get_current_PV_feedin_to_grid_kW()        const { return pv_gen_expo_kW;       } 
        double get_current_BS_feedin_to_grid_kW()        const { return bs_gen_expo_kW;       } 
        double get_current_CHP_feedin_to_grid_kW()       const { return chp_gen_expo_kW;      } 
        double get_current_wind_feedin_to_grid_kW()      const { return wind_gen_expo_kW;     } 
        double get_current_unknown_feedin_to_grid_kW()   const { return unknown_gen_expo_kW;  } 
        // modifiers bevore simulation start
        void add_unit(ControlUnit* unit);
        // methods for simulation run
        void  calc_load();
        const std::list<ControlUnit*>* get_connected_units() { return connected_units; } 
        //
        // static functions
        // 1. Initializers and destructors
        static void InitializeStaticVariables(unsigned long n_substations);
        static void VacuumInstancesAndStaticVariables();
        // 2. getter functions
        static Substation* GetInstancePublicID(unsigned long public_id); 
        static Substation* GetInstanceInternalID(unsigned long internal_id) { return st__substation_list[internal_id]; } 
        static const std::vector<Substation*>& GetArrayOfInstances() { return st__substation_list; } 
        static size_t GetNumberOfInstances() {return st__n_substations;}
    private:
        // constant member variables (other languages might call this 'final')
        const unsigned long internal_id; 
        const unsigned long public_id; 
        const std::string *const name;
        // member variables that can change over time
        std::list<ControlUnit*>* connected_units;
        double station_load;    
        double resident_load;   
        double resident_demand; 
        double other_demand;    
        double total_demand;   
        double total_BESS_demand; 
        double pv_gen_total_kW;      
        double bs_gen_total_kW;      
        double chp_gen_total_kW;     
        double wind_gen_total_kW;    
        double unknown_gen_total_kW; 
        double pv_gen_expo_kW;      
        double bs_gen_expo_kW;      
        double chp_gen_expo_kW;     
        double wind_gen_expo_kW;    
        double unknown_gen_expo_kW; 
        //
        // static list of substations
        //static bool st__substation_list_init;
        static unsigned long st__n_substations;
        //static unsigned long st__new_substation_position;
        static std::vector<Substation*> st__substation_list;
        static std::map<unsigned long, unsigned long> public_to_internal_id;
};
 
 
class ControlUnit : BaseUnit<ControlUnit> {
    public:
        static bool InstantiateNewControlUnit(unsigned long unitID, unsigned long substation_id, unsigned long locationID, bool residential, unsigned int n_flats);
    private:
        ControlUnit(unsigned long internalID, unsigned long publicID, unsigned long substation_id, unsigned long locationID, bool residential, unsigned int n_flats);
    public:
        ~ControlUnit();
        void add_unit(MeasurementUnit* unit);
        bool has_electricity_demand() const; 
        bool has_pv()   const; 
        bool has_bs()   const; 
        bool has_hp()   const; 
        bool has_cs()   const; 
        bool has_chp()  const; 
        bool has_wind() const; 
        bool has_bs_sim_added() const; 
        bool is_expandable_with_pv(); 
        bool is_expandable_with_hp(); 
        bool is_residential() const { return residential; } 
        bool heat_demand_given_in_data() const; 
        int  get_exp_combi_bit_repr()    const; 
        int  get_exp_combi_bit_repr_from_MUs()  const; 
        int  get_exp_combi_bit_repr_sim_added() const; 
        double get_current_load_vSMeter_kW() { return current_load_vSM_kW; }
        double get_current_demand_wo_BS_or_gen_kW()    const { return current_total_consumption_kW; } 
        double get_current_BS_demand_kW()              const; 
        double get_current_PV_generation_kW()          const; 
        double get_current_BS_generation_kW()          const; 
        double get_current_CHP_generation_kW()         const; 
        double get_current_wind_generation_kW()        const; 
        double get_current_unknown_generation_kW()     const; 
        double get_current_PV_feedin_to_grid_kW()      const { return current_PV_feedin_to_grid_kW;     } 
        double get_current_BS_feedin_to_grid_kW()      const { return current_BS_feedin_to_grid_kW;     } 
        double get_current_CHP_feedin_to_grid_kW()     const { return current_CHP_feedin_to_grid_kW;    } 
        double get_current_wind_feedin_to_grid_kW()    const { return current_wind_feedin_to_grid_kW;   } 
        double get_current_unknown_feedin_to_grid_kW() const { return current_unknown_feedin_to_grid_kW;} 
        size_t get_n_MUs()     { return connected_units->size(); } // returns the number of MUs, that are connected to the given control unit
        size_t get_internal_id() const { return internal_id; }   
        size_t get_unitID()      const { return unitID; }        
        size_t get_location_id() const { return locationID; }    
        double get_mean_annual_MU_el_demand_kWh() const; 
        double get_sim_comp_pv_kWp()   const; 
        double get_sim_comp_bs_P_kW()  const; 
        double get_sim_comp_bs_E_kWh() const; 
        float get_annual_heat_demand_th_kWh();  
        float get_annual_hp_el_cons_kWh();      
        double get_sim_comp_cs_max_P_kW() const; 
        size_t get_sim_comp_cs_n_EVs() const;   
        size_t get_sim_comp_cs_possible_n_EVs() const; 
        double  get_SSR(); 
        double  get_SCR(); 
        double  get_NPV(); 
        string* get_metrics_string_annual(); // call this function only if simulation run is finished! It will the compute sums of flows,SSC,SSR and output this as a string
        string* get_metrics_string_weekly_wr(unsigned long week_number); // This function outputs the weekly metrics AND resets the internal weekly counters!
        string* get_pv_section_string(); // This function returns a string containing information about the sections of the sim. added PV component. If no PV component is added, it returns an empty string.
        const ComponentBS* get_component_BS() const { if (has_sim_bs) return sim_comp_bs; else return nullptr; } 
        const ComponentHP* get_component_HP() const { if (has_sim_hp) return sim_comp_hp; else return nullptr; } 
        const ComponentCS* get_component_CS() const { if (has_sim_cs) return sim_comp_cs; else return nullptr; } 
        const ComponentPV* get_component_PV() const { if (has_sim_pv) return sim_comp_pv; else return nullptr; } 
        // public members
        bool is_sim_expanded; 
        // modifiers
        void add_exp_pv();
        void add_exp_bs(); 
        void add_exp_hp();
        void add_exp_cs(); 
        void add_ev(unsigned long carID); 
        void preprocess_ev_data(); 
        void set_output_object(CUOutput* output_obj);
        void set_exp_pv_params_A(float kWp_static); 
        void set_exp_pv_params_B(float kWp_per_m2, float min_kWp_sec, float max_kWp_sec, float max_kWp_unit); 
        void set_exp_bs_maxE_kWh(float value);
        void set_exp_bs_maxP_kW (float value);
        void set_exp_bs_E_P_ratio(float value); //< Set the E:P-ratio for simulatively added BS components to @param value
        void remove_sim_added_pv(); 
        void remove_sim_added_bs(); 
        void remove_sim_added_components(); 
        void reset_internal_state(); 
        // for simulation runs
        bool compute_next_value(unsigned long ts); 
#ifdef PYTHON_MODULE
        void send_control_commands_from_py_interface(double p_bs_kW, double p_hp_kW, const std::vector<double>& p_ev_kW); 
#endif
        //
        // static functions
        // 1. Initializers and destructors
        static void InitializeStaticVariables(unsigned long n_CUs);
        static void VacuumInstancesAndStaticVariables();
        // 2. getter functions
        static ControlUnit* GetInstancePublicID(unsigned long unitID);   
        static ControlUnit* GetInstancePublicIDWE(unsigned long unitID); 
        static ControlUnit* GetInstanceInternalID(unsigned long internalID) {return st__cu_list[internalID];} 
        //static ControlUnit* GetInstanceAtLocationID(unsigned long locationID);
        static const std::vector<ControlUnit*>& GetArrayOfInstances() {return st__cu_list;}
        static size_t GetNumberOfInstances() {return st__n_CUs;}
        static size_t GetNumberOfCUsWithSimCompPV();        
        static size_t GetNumberOfCUsWithSimCompHP();        
        static size_t GetNumberOfCUsWithSimCompEV();        
        static double GetAllSimCompBatteriesCharge_kWh();   
        static double GetAllSimCompBatteriesCapacity_kWh(); 
        static unsigned long GetTotalNumberOfOptimizationCalls()  { return optimization_call_counter; } 
        static unsigned long GetCurrentNumberOfOptiVars()         { return n_curr_optimization_vars;  } 
        // 3. modifiers for all created objects
        static void PreprocessEVData(); 
        static void ResetAllInternalStates();
        static void RemoveAllSimAddedComponents(); 
        static void ChangeControlHorizonInTS(unsigned int new_horizon); 
    protected:
        void change_control_horizon_in_ts(unsigned int new_horizon); 
    private:
        // constant member variables (other languages might call this 'final')
        const unsigned long internal_id; 
        const unsigned long unitID; 
        Substation *const higher_level_subst;
        const unsigned long locationID;
        const bool residential; 
        const bool generate_output_for_this_unit; 
        // member variables that can change over time
        std::list<MeasurementUnit*>* connected_units;
        bool has_sim_pv; 
        bool has_sim_bs; 
        bool has_sim_hp; 
        bool has_sim_cs; 
        ComponentPV* sim_comp_pv; 
        ComponentBS* sim_comp_bs; 
        ComponentHP* sim_comp_hp; 
        ComponentCS* sim_comp_cs; 
        CUOutput*    output_obj;
        BaseOptimizedController* optimized_controller; 
#ifdef PYTHON_MODULE
        bool py_control_commands_obtained;
        double py_cmd_p_bs_kW;
        double py_cmd_p_hp_kW;
        std::vector<double> py_cmd_p_ev_kW;
#endif
        // summation variables from the beginning of the simulation run until the current time step
        double sum_of_consumption_kWh;    
        double sum_of_self_cons_kWh;      
        double sum_of_mu_cons_kWh;        
        double sum_of_feed_into_grid_kWh; 
        double sum_of_grid_demand_kWh;    
        double sum_of_rem_pow_costs_EUR;  
        double sum_of_saved_pow_costs_EUR;
        double sum_of_feedin_revenue_EUR; 
        double sum_of_emissions_cbgd_kg_CO2eq;
        double sum_of_emissions_avoi_kg_CO2eq;
        unsigned long sum_of_errors_in_cntrl; 
        unsigned long sum_of_errors_in_cntrl_cmd_appl; 
        // other variables that are valid from the beginning of the simulation run until the current time step
        double peak_grid_demand_kW;             
        // summation variables from the beginning of the currently simulated week until the current time step
        double sum_of_cweek_consumption_kWh;    
        double sum_of_cweek_self_cons_kWh;      
        double sum_of_cweek_mu_cons_kWh;        
        double sum_of_cweek_feed_into_grid_kWh; 
        double sum_of_cweek_grid_demand_kWh;    
        double sum_of_cweek_rem_pow_costs_EUR;  
        double sum_of_cweek_saved_pow_costs_EUR;
        double sum_of_cweek_feedin_revenue_EUR; 
        double sum_of_cweek_emissions_cbgd_kg_CO2eq;
        double sum_of_cweek_emissions_avoi_kg_CO2eq;
        unsigned long sum_of_cweek_errors_in_cntrl; 
        unsigned long sum_of_cweek_errors_in_cntrl_cmd_appl; 
        // other variables that are valid from the beginning of the currently simulated week until the current time step
        double cweek_peak_grid_demand_kW;       
        // caches for optimization
        unsigned long ts_since_last_opti_run; 
        //bool   create_history_output; ///< True, if a history output should be created for this control unit.
        // Internal storage variables for the current state, especially the current power flows
        double current_load_vSM_kW; 
        double self_produced_load_kW; 
        double current_total_consumption_kW; 
        double current_PV_feedin_to_grid_kW; 
        double current_BS_feedin_to_grid_kW; 
        double current_CHP_feedin_to_grid_kW; 
        double current_wind_feedin_to_grid_kW; 
        double current_unknown_feedin_to_grid_kW; 
        //
        bool is_expandable_with_pv_cache; 
        bool is_expandable_with_pv_cache_computed; 
        bool is_expandable_with_hp_cache; 
        bool is_expandable_with_hp_cache_computed; 
        //
        // Variables required for multi-threading
        // CUControllerWorkerThread is getting full access to the member variables of this class
        // Required only for the member variable worker_thread
        friend class CUControllerWorkerThread;
        CUControllerWorkerThread* worker_thread; 
        //
        // static list of CUs
        static unsigned long st__n_CUs;
        static std::vector<ControlUnit*> st__cu_list;
        static std::map<unsigned long, unsigned long> public_to_internal_id;
        static std::vector<double>* st__empty_vector_for_time_horizon; 
        //static std::map<unsigned long, ControlUnit*> location_to_cu_map;
        // other static members
        static std::atomic<unsigned long> optimization_call_counter; 
        static std::atomic<unsigned long> n_curr_optimization_vars; 
        static std::mutex n_curr_optimization_vars_mutex;
        static std::condition_variable curr_opti_cv; 
    public:
        static const std::string MetricsStringHeaderAnnual; 
        static const std::string MetricsStringHeaderWeekly; 
};
 
 
class MeasurementUnit : BaseUnit<MeasurementUnit> {
    public:
        static bool InstantiateNewMeasurementUnit(size_t meUID, size_t public_unitID, std::string * meterPointName, size_t locID, 
                bool has_demand, bool has_feedin, bool has_pv_resid, bool has_pv_opens,
                bool has_bess,   bool has_hp,     bool has_wind,     bool has_evchst,
                bool has_chp, const std::string& data_source_path);
    private:
        // initialization and destruction
        MeasurementUnit(size_t internalID, size_t meUID, size_t public_unitID, std::string * meterPointName, size_t locID, 
                        bool has_demand, bool has_feedin, bool has_pv_resid, bool has_pv_opens,
                        bool has_bess,   bool has_hp,     bool has_wind,     bool has_evchst,
                        bool has_chp, const std::string& data_source_path);
    public:
        ~MeasurementUnit();
        const std::string * get_meterPointName() const { return meterPointName; } 
        unsigned long get_internal_id()          const { return internal_id; }    
        unsigned long get_meUID()                const { return meUID; }          
        unsigned long get_locationID()           const { return locationID; }     
        bool load_data(); 
        bool has_demand() const { return rsm_has_demand; }
        bool has_feedin() const { return rsm_has_feedin; }
        bool has_pv()     const { return rsm_with_pv_residential || rsm_with_pv_open_space; }
        bool has_pv_residential() const { return rsm_with_pv_residential; }
        bool has_pv_open_space()  const { return rsm_with_pv_open_space; }
        bool has_bs()     const { return rsm_with_bess;}
        bool has_hp()     const { return rsm_with_hp;  }
        bool has_evchst() const { return rsm_with_evchst;  }
        bool has_chp()    const { return rsm_with_chp; }
        bool has_wind()   const { return rsm_with_wind;}
        int  get_expansion_combination() const  { return expansion_combination; }
        // for simulation runs
        double get_total_demand_kWh() const; 
        bool compute_next_value(unsigned long ts);
        float get_current_ts_rsm_value() const { return current_load_rsm_kW; }
        float get_rsm_load_at_ts(unsigned long ts) const;
        float get_rsm_demand_at_ts(unsigned long ts) const;
        float get_rsm_feedin_at_ts(unsigned long ts) const;
        //
        // Class (i.e. static) functions
        // 1. Initializers and destructors
        static void InitializeStaticVariables(unsigned long n_MUs);
        static void VacuumInstancesAndStaticVariables();
        static size_t GetNumberOfInstances() {return st__n_MUs;}
        static bool LoadDataForAllInstances(); 
        //
        // 2. Class getter methods
        static MeasurementUnit* GetInstancePublicID(unsigned long meUID); 
    private:
        // constant member variables (other languages might call this 'final')
        const unsigned long internal_id; 
        const unsigned long meUID;  
        ControlUnit *const higher_level_cu;
        const std::string *const meterPointName;
        const unsigned long locationID;
        const std::string data_source_path;
        // member variables that can change over time
        float current_load_rsm_kW;
        bool rsm_has_demand; 
        bool rsm_has_feedin;
        bool rsm_with_pv_residential;
        bool rsm_with_pv_open_space;
        bool rsm_with_bess;
        bool rsm_with_hp;
        bool rsm_with_evchst; 
        bool rsm_with_wind;   
        bool rsm_with_chp;
        int expansion_combination;
        // member variables storing the data
        bool   data_loaded;
        int*   data_timestepID;
        float* data_value_demand;
        float* data_value_feedin;
        //char*  data_status_demand;
        //char*  data_status_feedin;
        //
        // static list of MUs
        static size_t st__n_MUs;
        static std::vector<MeasurementUnit*> st__mu_list;
        static std::map<unsigned long, unsigned long> public_to_internal_id;
};
 
 
 
enum OpenSpacePVOrWindType {
    PV,
    Wind
};
 
class OpenSpacePVOrWind {
    public:
        OpenSpacePVOrWind(float kWp, OpenSpacePVOrWindType type);
        float get_current_feedin_kW() { return current_feedin_kW; }
        // for simulation runs
        bool compute_next_value(unsigned long ts);
    private:
        // constant member variables
        const float kWp;
        const float* profile_data; 
        // members that might change during the time
        float current_feedin_kW;
};
 
#endif