OpenDSS_VoltageEstimation/output_utils.py at main · HodgeLab/OpenDSS_VoltageEstimation · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
"""
Output utilities for saving analysis results
"""

import os
import json
import pandas as pd
from config import OUTPUT_FILES


def save_violation_results(output_folder, undervoltages_dict, overvoltages_dict,
                          xfmr_overloads_dict, line_overloads_dict, blown_fuses):
    """Save violation analysis results to CSV files"""

    # Process violation dictionaries
    count = 0
    new_undervoltages_dict = {}
    new_overvoltages_dict = {}
    new_xfmr_overloads_dict = {}
    new_line_overloads_dict = {}

    for key, value in undervoltages_dict.items():
        new_undervoltages_dict[count] = {'Bus': key, 'OpenDSS Value (p.u.)': value}
        count += 1
    undervoltages_dict = new_undervoltages_dict

    count = 0
    for key, value in overvoltages_dict.items():
        new_overvoltages_dict[count] = {'Bus': key, 'OpenDSS Value (p.u.)': value}
        count += 1
    overvoltages_dict = new_overvoltages_dict

    count = 0
    for key, value in xfmr_overloads_dict.items():
        new_xfmr_overloads_dict[count] = value
        new_xfmr_overloads_dict[count]['Name'] = key
        new_xfmr_overloads_dict[count]['Bus and Phases'] = value['Bus']
        new_xfmr_overloads_dict[count]['Number of Phases'] = value['number_of_phases']
        count += 1
    xfmr_overloads_dict = new_xfmr_overloads_dict

    count = 0
    for key, value in line_overloads_dict.items():
        new_line_overloads_dict[count] = value
        new_line_overloads_dict[count]['Name'] = key
        count += 1
    line_overloads_dict = new_line_overloads_dict

    # Create DataFrames and save
    undervoltages_df = pd.DataFrame.from_dict(undervoltages_dict, "index",
                                             columns=['OpenDSS Value (p.u.)', 'Bus'])
    undervoltages_df = undervoltages_df.sort_values(by=['OpenDSS Value (p.u.)'])

    overvoltages_df = pd.DataFrame.from_dict(overvoltages_dict, "index",
                                            columns=['OpenDSS Value (p.u.)', 'Bus'])
    overvoltages_df = overvoltages_df.sort_values(by=['OpenDSS Value (p.u.)'])

    xfmr_overloads_df = pd.DataFrame.from_dict(xfmr_overloads_dict, "index",
                                              columns=['Loading (p.u.)', 'Name', 'Bus and Phases', 'kVA', 'Number of Phases'])
    xfmr_overloads_df = xfmr_overloads_df.sort_values(by=['Loading (p.u.)'])

    line_overloads_df = pd.DataFrame.from_dict(line_overloads_dict, "index",
                                              columns=['Loading (p.u.)', 'Name', 'Bus1', 'Bus2'])
    line_overloads_df = line_overloads_df.sort_values(by=['Loading (p.u.)'])

    # Save CSV files
    undervoltages_df.to_csv(os.path.join(output_folder, OUTPUT_FILES['under_voltages']), header=True, index=False)
    overvoltages_df.to_csv(os.path.join(output_folder, OUTPUT_FILES['over_voltages']), header=True, index=False)
    xfmr_overloads_df.to_csv(os.path.join(output_folder, OUTPUT_FILES['transformer_overloads']), header=True, index=False)
    line_overloads_df.to_csv(os.path.join(output_folder, OUTPUT_FILES['line_overloads']), header=True, index=False)

    # Save blown fuses
    with open(os.path.join(output_folder, OUTPUT_FILES['blown_fuses']), 'w') as blown_fp:
        blown_fp.write('Blown Fuse\n')
        for fuse in blown_fuses:
            blown_fp.write(fuse + '\n')


def save_summary_data(output_folder, all_losses, total_power, percent_losses,
                     max_total, max_com, max_res, peak_total_day, peak_total_hour, peak_total_min):
    """Save summary data to CSV"""
    with open(os.path.join(output_folder, OUTPUT_FILES['summary_data']), 'w') as loss_fp:
        loss_fp.write("Total peak time real losses (kW),Total peak time circuit power (kW),Percentage peak time real losses,Total peak time real customer power (kW),Total peak time real commercial power (kW),Total peak time real residential power (kW),Peak load day of year,Peak load hour of day,Peak load minute of hour\n")
        loss_fp.write(f'{all_losses},{total_power},{percent_losses},{max_total},{max_com},{max_res},{peak_total_day},{peak_total_hour},{peak_total_min}\n')


def save_voltage_data(output_folder, sorted_dss_vals_avg, deenergized_switch_nodes, master_folder):
    """Save voltage analysis data"""
    try:
        sorted_dss_vals_avg_df = pd.DataFrame(sorted(sorted_dss_vals_avg))
        sorted_dss_vals_avg_df.columns = ('OpenDSS Value (p.u.)', 'Bus')
        sorted_dss_vals_avg_df.to_csv(os.path.join(output_folder, OUTPUT_FILES['peak_voltages']), index=False, header=True)
    except:
        print("System didn't solve")

    # Save de-energized nodes
    with open(os.path.join(output_folder, OUTPUT_FILES['de_energized_nodes']), 'w') as open_fp:
        open_fp.write('De-Energized Bus due to Open Switch (or Blown Fuse)\n')
        for node in deenergized_switch_nodes:
            open_fp.write(node + '\n')

    # Save version file
    with open(os.path.join(master_folder, OUTPUT_FILES['version_file']), 'w') as version_fp:
        version_fp.write('1.0\n')


def save_voltage_estimation_data(output_folder, voltage_df, load_kw_df, load_kvar_df,
                                pv_df, summary_df, metadata):
    """Save voltage estimation dataset"""
    voltage_estimation_folder = os.path.join(output_folder, 'voltage_estimation_data')
    if not os.path.isdir(voltage_estimation_folder):
        os.makedirs(voltage_estimation_folder)

    # Save voltage data (target variables for estimation)
    print("Saving voltage data...")
    voltage_df.to_csv(os.path.join(voltage_estimation_folder, 'voltage_pu_all_buses.csv'))

    # Save load data (input features for estimation)
    print("Saving load data...")
    load_kw_df.to_csv(os.path.join(voltage_estimation_folder, 'load_kw_all_buses.csv'))
    load_kvar_df.to_csv(os.path.join(voltage_estimation_folder, 'load_kvar_all_buses.csv'))

    # Save PV data (additional features if applicable)
    if pv_df is not None:
        print("Saving PV data...")
        pv_df.to_csv(os.path.join(voltage_estimation_folder, 'pv_irradiance_all_systems.csv'))

    # Save system summary data
    summary_df.to_csv(os.path.join(voltage_estimation_folder, 'system_summary.csv'), index=False)

    # Save metadata
    with open(os.path.join(voltage_estimation_folder, 'dataset_metadata.json'), 'w') as f:
        json.dump(metadata, f, indent=2)

    return voltage_estimation_folder


def save_timeseries_analysis_data(output_folder, all_percent_losses, all_total_loads):
    """Save additional timeseries analysis data"""
    voltage_estimation_folder = os.path.join(output_folder, 'voltage_estimation_data')

    all_percent_losses_df = pd.DataFrame(all_percent_losses, columns=['Percent Loss'])
    all_percent_losses_df.to_csv(os.path.join(voltage_estimation_folder, 'all_percent_losses.csv'), header=True, index=True)

    all_total_loads_df = pd.DataFrame(all_total_loads, columns=['All Load'])
    all_total_loads_df.to_csv(os.path.join(voltage_estimation_folder, 'all_total_loads.csv'), header=True, index=True)

    if len(all_total_loads) > 0 and len(all_percent_losses) > 0:
        correlation = pd.DataFrame([all_total_loads[i]/all_percent_losses[i] if all_percent_losses[i] != 0 else 0 for i in range(len(all_total_loads))], columns=['Load over loss'])
        correlation.to_csv(os.path.join(voltage_estimation_folder, 'correlation.csv'), header=True, index=True)