output.h

Go to the documentation of this file.

/*
 * output.h
 *
 * This contains all functions and classes for buffering outputs
 * and writing them to the disk finally.
 *
 */
 
#ifndef __OUTPUT_H
#define __OUTPUT_H
 
#include <filesystem>
#include <fstream>
#include <list>
#include <mutex>
#include <sstream>
#include <string>
#include <vector>
 
// The following classes are defined in this header file:
class CUOutput;
class CUOutputSingleFile;
class CUOutputOneFilePerCU;
class CUOutputOneFilePerSubstation;
 
#include "vehicles.h"
 
using namespace std;
 
namespace output {
 
    inline std::ofstream* substation_output         = NULL; 
    inline std::ofstream* substation_output_details = NULL; 
    inline std::ofstream* cu_details_ccmd_output    = NULL; 
    inline std::ofstream* cu_details_ev_output      = NULL; 
    inline CUOutputSingleFile* cu_single_output = NULL; 
    inline CUOutputOneFilePerSubstation** cu_multi_outputs = NULL; 
    inline size_t n_cu_multi_outputs = 0; 
 
    inline std::mutex mtx_cu_details_ccmd; 
    inline std::mutex mtx_cu_details_ev;   
 
    void initializeDirectoriesBase(unsigned long scenario_id);
    void initializeDirectoriesPerPVar();
    void initializeSubstationOutput(unsigned long scenario_id);
    void initializeCUOutput(unsigned long scenario_id);
    void closeOutputs();
    void flushBuffers();
 
    struct CurrentParamValues {
        float exp_pv_kWp_static       = 0.0; bool exp_pv_kWp_static_set       = false;
        float exp_pv_kWp_per_m2       = 0.0; bool exp_pv_kWp_per_m2_set       = false;
        float exp_pv_min_kWp_roof_sec = 0.0; bool exp_pv_min_kWp_roof_sec_set = false;
        float exp_pv_max_kWp_roof_sec = 0.0; bool exp_pv_max_kWp_roof_sec_set = false;
        float exp_pv_max_kWp_per_unit = 0.0; bool exp_pv_max_kWp_per_unit_set = false;
        float exp_bs_maxP_kW  = 0.0;  bool exp_bs_maxP_kW_set  = false;
        float exp_bs_maxE_kWh = 0.0;  bool exp_bs_maxE_kWh_set = false;
        float exp_bs_init_SOC = 0.0;  bool exp_bs_init_SOC_set = false;
        float exp_bs_EP_ratio = 0.0;  bool exp_bs_EP_ratio_set = false;
        uint  control_horizon_in_ts     = 24; bool control_horizon_in_ts_set     = false;
        uint  control_update_freq_in_ts =  1; bool control_update_freq_in_ts_set = false;
    };
    void outputCurrentParamVariCombi(CurrentParamValues&);
 
    void outputCurrentCUSettings(); 
 
    void outputMetrics(bool alt_fname = false, string * fname_postfix = NULL); 
 
    void outputMetricsStrListSACPlanning(list<string*> &output_list);
 
    void outputWeeklyMetricsStrList(list<string*> *output_list, unsigned long week_number);
 
    void outputEVMetrics(bool alt_fname = false, string * fname_postfix = NULL);
 
    void outputRuntimeInformation(long seconds_setup, long seconds_main_run);
 
     void outputControlCommandDetails(
        unsigned long ts, unsigned long cuID, bool optimization_state_ok,
        double inp_max_p_bs_kW,
        double inp_max_e_bs_kWh,
        double inp_max_p_cs_kW,
        double inp_current_bs_charge_kWh,
        const std::vector<float>&  inp_future_resid_demand_kW,
        const std::vector<double>& inp_future_pv_generation_kW,
        const std::vector<double>& inp_future_hp_shiftable_maxP,
        const std::vector<double>& inp_future_hp_shiftable_minP,
        const std::vector<double>& inp_future_hp_shiftable_maxE,
        const std::vector<double>& inp_future_hp_shiftable_minE,
        const std::vector<const std::vector<double>*>* inp_future_ev_shiftable_maxE,
        const std::vector<const std::vector<double>*>* inp_future_ev_shiftable_minE,
        const std::vector<const std::vector<double>*>* inp_future_ev_maxP,
        const std::vector<double>& out_future_bs_power_kW,
        const std::vector<double>& out_future_hp_power_kW,
        const std::vector<std::vector<double>>& out_future_ev_power_kW
    );
 
    void outputEVStateDetails(unsigned long ts, unsigned long carID, EVState ev_state, float p_charging_kW, float cumsum_E_ch_home, float cumsum_E_min, float cumsum_E_max, float ev_bs_SOE_kWh);
 
}
 
class CUOutput {
    public:
        virtual ~CUOutput();
        virtual void output_for_one_cu(
                size_t cuID,          size_t ts,
                double load_vsm,      double load_rsm,
                double load_selfprod, double load_pv,
                double bs_SOC,        double load_bs,
                double load_hp,       double load_cs,
                size_t n_cars_pc,     size_t n_cars_pnc) = 0;
        virtual void flush_buffer() = 0;
        void close_buffer();
    protected:
        bool            buffer_open;   
        std::ofstream*  output_stream; 
};
 
class CUOutputSingleFile : public CUOutput {
    public:
        CUOutputSingleFile(unsigned long scenario_id);
        ~CUOutputSingleFile();
        static const size_t bufferSize = 128*1024;
        //
        // definition of virtual methods from base class
        void output_for_one_cu(
                size_t cuID,          size_t ts,
                double load_vsm,      double load_rsm,
                double load_selfprod, double load_pv,
                double bs_SOC,        double load_bs,
                double load_hp,       double load_cs,
                size_t n_cars_pc,     size_t n_cars_pnc);
        void flush_buffer();
    private:
        mutex  single_file_mutex; 
        char*  buffer; // buffer for speedup
};
 
class CUOutputOneFilePerCU : public CUOutput {
    public:
        CUOutputOneFilePerCU(int cuID, filesystem::path& dirpath);
        //
        // definition of virtual methods from base class
        void output_for_one_cu(
                size_t cuID,          size_t ts,
                double load_vsm,      double load_rsm,
                double load_selfprod, double load_pv,
                double bs_SOC,        double load_bs,
                double load_hp,       double load_cs,
                size_t n_cars_pc,     size_t n_cars_pnc);
        void flush_buffer();
};
 
class CUOutputOneFilePerSubstation : public CUOutput {
    public:
        CUOutputOneFilePerSubstation(const string* substName, filesystem::path& dirpath);
        //
        // definition of virtual methods from base class
        void output_for_one_cu(
                size_t cuID,         size_t ts,
                double load_vsm,      double load_rsm,
                double load_selfprod, double load_pv,
                double bs_SOC,        double load_bs,
                double load_hp,       double load_cs,
                size_t n_cars_pc,    size_t n_cars_pnc);
        void flush_buffer();
    private:
        std::mutex single_file_mutex; 
};
 
#endif