Updated Create_network.m and scenario length in code

Author: bRizeakos

Dataset Creation/Create_network.m

@@ -15,40 +15,64 @@
 
 % Shuffle the values retaining the same instance from the file above
 Active_Loads = Active_Power.arr(:, 1:48);
+PV = Active_Power.arr(:, 56:60);
+% Each scenario corresponds to a minute of time and we want to create 
+% scenarios for every 5 seconds of the recorded loads by interpolating them
+timestep = 60/5; 
+
+curr_gran = 1:1:length(Active_Loads);
+end_gran = 1:(1/timestep):length(Active_Loads);
+Int_Active_Loads = zeros(length(end_gran),48);
+Int_PV = zeros(length(end_gran),5);
+for i=1:48
+    Int_Active_Loads(:,i) = interpn(curr_gran,Active_Loads(:,i),end_gran,'makima');
+end
+for i=1:5
+    Int_PV(:,i) = interpn(curr_gran,PV(:,i),end_gran,'makima');
+end
 
-% Check for non-positive or very low values in Active_Loads and convert them to mean
+% Check for non-positive or very low values in Int_Active_Loads and convert them to mean
 for i=1:48
-    for j=1:44580
-        if Active_Loads(j,i)<=10
-            Active_Loads(j,i) = mean(Active_Loads(:,i));
+    for j=1:length(Int_Active_Loads)
+        if j==1
+            if Int_Active_Loads(j,i)<=10
+                Int_Active_Loads(j,i) = mean(Int_Active_Loads(:,i));
+            end
+        elseif Int_Active_Loads(j,i)<=10
+            Int_Active_Loads(j,i) = Int_Active_Loads(j-1,i);
         end
     end
 end
 
-Reactive_Loads = Active_Loads * tan(acos(PF_load));
-PV = Active_Power.arr(:, 56:60);
-random_idx = randperm(size(Active_Loads,1));
-Shuffled_Active_Loads = Active_Loads(random_idx,:);
-Shuffled_PV = PV(random_idx,:);
+% Check for non-positive or very low values in Int_PV_Loads and convert them to mean
+for i=1:5
+    for j=1:length(Int_PV)
+        if Int_PV(j,i)<0
+            Int_PV(j,i) = 0;
+        end
+    end
+end
+
+Int_Reactive_Loads = Int_Active_Loads * tan(acos(PF_load));
 
+Per_Fault=[3715,9535,9535,9535,1022,1022,1022,2384,2384,2384,817,1225];
+Int_Per_Fault=12*Per_Fault;
+Int_Per_Fault(12)=Int_Per_Fault(12)-11;
 % Specify every possible fault we are going to simulate
 Scenario.Name = {'Healthy','A-G','B-G','C-G','A-B','B-C','A-C','A-B-G','B-C-G','A-C-G','A-B-C','A-B-C-G'};
 
-% For each scenario make a cell containing loads and PVs
-Load1 = {Shuffled_Active_Loads(1:3715, :), Shuffled_PV(1:3715, :)};
-Load2 = {Shuffled_Active_Loads(3716:13250, :), Shuffled_PV(3716:13250, :)};
-Load3 = {Shuffled_Active_Loads(13251:22785, :), Shuffled_PV(13251:22785, :)};
-Load4 = {Shuffled_Active_Loads(22786:32320, :), Shuffled_PV(22786:32320, :)};
-Load5 = {Shuffled_Active_Loads(32321:33342, :), Shuffled_PV(32321:33342, :)};
-Load6 = {Shuffled_Active_Loads(33343:34364, :), Shuffled_PV(33343:34364, :)};
-Load7 = {Shuffled_Active_Loads(34365:35386, :), Shuffled_PV(34365:35386, :)};
-Load8 = {Shuffled_Active_Loads(35387:37770, :), Shuffled_PV(35387:37770, :)};
-Load9 = {Shuffled_Active_Loads(37771:40154, :), Shuffled_PV(37771:40154, :)};
-Load10= {Shuffled_Active_Loads(40155:42538, :), Shuffled_PV(40155:42538, :)};
-Load11= {Shuffled_Active_Loads(42539:43355, :), Shuffled_PV(42539:43355, :)};
-Load12= {Shuffled_Active_Loads(43356:44580, :), Shuffled_PV(43356:44580, :)};
-
-Scenario.Loads = {Load1, Load2, Load3, Load4, Load5, Load6, Load7, Load8, Load9, Load10, Load11, Load12};
+Load = cell(length(Int_Active_Loads),3);
+for i=1:length(Int_Active_Loads)
+    if i~=length(Int_Active_Loads)
+        Load_i={Int_Active_Loads(i,:),Int_Active_Loads(i+1,:),Int_PV(i,:)};
+    else
+        Load_i={Int_Active_Loads(i,:),Int_Active_Loads(i,:),Int_PV(i,:)};
+    end
+    Load(i,:)=Load_i;
+end
+
+random_idx = randperm(length(Int_Active_Loads));
+Load = Load(random_idx,:);
 
 % Fault Resistance - LogNormal Distribution Generator
 % Makes 
@@ -57,58 +81,42 @@
 mu = log((m^2)/sqrt(v+m^2));
 sigma = sqrt(log(v/(m^2)+1));
 
-Rs = lognrnd(mu, sigma, 44580, 1);
+Rs = lognrnd(mu, sigma, length(Int_Active_Loads), 1);
 
 % For each scenario make a cell containing Rs
-R1 = Rs(1:3715);
-R2 = Rs(3716:13250);
-R3 = Rs(13251:22785);
-R4 = Rs(22786:32320);
-R5 = Rs(32321:33342);
-R6 = Rs(33343:34364);
-R7 = Rs(34365:35386);
-R8 = Rs(35387:37770);
-R9 = Rs(37771:40154);
-R10= Rs(40155:42538);
-R11= Rs(42539:43355);
-R12= Rs(43356:44580);
-
-Scenario.Rs = {R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12};
 
 % Fault Duration - Weibull Distribution Generator
 
 a = 0.3;    % scale parameter
 b = 1.2;    % shape parameter
 
-Fault_Duration = wblrnd(a, b, 44580, 1);
-for i=1:44580
+Fault_Duration = wblrnd(a, b, length(Int_Active_Loads), 1);
+for i=1:length(Int_Active_Loads)
     while Fault_Duration(i)<=20e-3
         Fault_Duration(i) = wblrnd(a, b);
     end
 end
-Fault_Start = Tm + rand(44580,1).*(Ts - Tm - Fault_Duration);
+Fault_Start = Tm + rand(length(Int_Active_Loads),1).*(Ts - Tm - Fault_Duration);
 
 % For each scenario make a cell containing Fault_Duration and Fault_Start
-T1 = {Fault_Start(1:3715), Fault_Duration(1:3715)};
-T2 = {Fault_Start(3716:13250), Fault_Duration(3716:13250)};
-T3 = {Fault_Start(13251:22785), Fault_Duration(13251:22785)};
-T4 = {Fault_Start(22786:32320), Fault_Duration(22786:32320)};
-T5 = {Fault_Start(32321:33342), Fault_Duration(32321:33342)};
-T6 = {Fault_Start(33343:34364), Fault_Duration(33343:34364)};
-T7 = {Fault_Start(34365:35386), Fault_Duration(34365:35386)};
-T8 = {Fault_Start(35387:37770), Fault_Duration(35387:37770)};
-T9 = {Fault_Start(37771:40154), Fault_Duration(37771:40154)};
-T10= {Fault_Start(40155:42538), Fault_Duration(40155:42538)};
-T11= {Fault_Start(42539:43355), Fault_Duration(42539:43355)};
-T12= {Fault_Start(43356:44580), Fault_Duration(43356:44580)};
-
-Scenario.Time = {T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12};
-
-% We need 15 (743x108)x1000 matrices to include all 44580 scenarios
-% Each matrix constists of ((4x250)=20sec) rows x ((99 V + 9 A) = 108
-% features x 743 scenarios = 80244) columns
-Scenario.Output = cell(4,743,15);
-Scenario.Class  = cell(4,743,15);
+
+Scenario.Loads = cell(1,length(Scenario.Name));
+Scenario.Time = cell(2,length(Scenario.Name));
+Scenario.Rs = cell(1,length(Scenario.Name));
+for i=1:12
+    if i==1
+        idx_start=1;
+    else
+        idx_start=sum(Int_Per_Fault(1:i-1))+1;
+    end
+    idx_stop=sum(Int_Per_Fault(1:i));
+    Scenario.Loads(1,i)={Load(idx_start:idx_stop,:)};
+    Scenario.Time(:,i)={Fault_Start(idx_start:idx_stop), Fault_Duration(idx_start:idx_stop)};
+    Scenario.Rs(1,i)={Rs(idx_start:idx_stop)};
+end   
+
+Scenario.Output = cell(1,length(Int_Active_Loads));
+Scenario.Class  = cell(1,length(Int_Active_Loads));
 %% Save Scenario structure for exporting
 
-save('Int_Scenario.mat', '-struct', 'Scenario');
+save('Int_Scenario.mat', '-struct', 'Scenario');

FLITC applications/fault_train_best_models_DMDCWT.py

@@ -65,9 +65,7 @@ def shuffle_dataset(dataset, output_class, rs, dur):
     x_trn, x_tst, y_trn, y_tst = [], [], [], []
     rs_trn, rs_tst, dur_trn, dur_tst = [], [], [], []
 
-    scenario_length = [1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-    array = np.array(scenario_length) * 3
-    scenario_length = list(array)
+    scenario_length = [114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
     for idx in range(len(scenario_length)):
         x_train, x_test, y_train, y_test, rs_train, rs_test, dur_train, dur_test = train_test_split(

FLITC applications/feeder_train_best_models_CWT.py

@@ -52,9 +52,7 @@ def shuffle_dataset(dataset, output_class, rs, dur):
     x_trn, x_tst, y_trn, y_tst = [], [], [], []
     rs_trn, rs_tst, dur_trn, dur_tst = [], [], [], []
 
-    scenario_length = [743, 1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-    array = np.array(scenario_length) * 3
-    scenario_length = list(array)
+    scenario_length = [44580, 114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
     for idx in range(len(scenario_length)):
         x_train, x_test, y_train, y_test, rs_train, rs_test, dur_train, dur_test = train_test_split(

FLITC applications/run_best_models.py

@@ -34,9 +34,7 @@
 distance_dic = results_dic + r'\Distance_ID'
 
 # Scenario length initialization
-scenario_length = [743, 1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-array = np.array(scenario_length) * 3
-scenario_length = list(array)
+scenario_length = [44580, 114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
 # LVDG topology recreation
 tree, nodes, grid_length = top.create_grid()

Hyperparameter Tuning/Dataset_Parser.py

@@ -34,9 +34,7 @@ def create_dataset():
     print("Directory is ",directory)
 
     # scenario_length = datapoints for each scenario
-    scenario_length = [743, 1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-    array = np.array(scenario_length) * 3
-    scenario_length = list(array)
+    scenario_length = [44580, 114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
     Name = []
     Loads = [[] for _ in range(12)]

Hyperparameter Tuning/Fault_HyperOpt_DMDCWT_not_full_v2.py

@@ -65,9 +65,7 @@ def shuffle_dataset(dataset, output_class, rs, dur):
     x_trn, x_tst, y_trn, y_tst = [], [], [], []
     rs_trn, rs_tst, dur_trn, dur_tst = [], [], [], []
 
-    scenario_length = [1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-    array = np.array(scenario_length) * 3
-    scenario_length = list(array)
+    scenario_length = [114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
     for idx in range(len(scenario_length)):
         x_train, x_test, y_train, y_test, rs_train, rs_test, dur_train, dur_test = train_test_split(

Hyperparameter Tuning/Feeder_HyperOpt_CWT_not_full_v1.py

@@ -48,9 +48,7 @@ def shuffle_dataset(dataset, output_class, rs, dur):
     x_trn, x_tst, y_trn, y_tst = [], [], [], []
     rs_trn, rs_tst, dur_trn, dur_tst = [], [], [], []
 
-    scenario_length = [743, 1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-    array = np.array(scenario_length) * 3
-    scenario_length = list(array)
+    scenario_length = [44580, 114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
     for idx in range(len(scenario_length)):
         x_train, x_test, y_train, y_test, rs_train, rs_test, dur_train, dur_test = train_test_split(

Hyperparameter Tuning/class_encoding.py

@@ -8,9 +8,7 @@
 Dataset_path = directory + r'\Dataset.joblib'   
 
 # scenario_length = datapoints for each scenario
-scenario_length = [743, 1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-array = np.array(scenario_length) * 3
-scenario_length = list(array)
+scenario_length = [44580, 114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
 Dataset = joblib.load(Dataset_path)
 names = Dataset['Name']

Hyperparameter Tuning/preprocessing_stage.py

@@ -56,9 +56,7 @@ def preprocess():
     voltage_int_path = directory + r'\V_int.joblib'
     Iabc_path = directory + r'\Iabc.joblib'
     class_path = directory + r'\Class.joblib'
-    scenario_length = [743, 1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-    array = np.array(scenario_length) * 3
-    scenario_length = list(array)
+    scenario_length = [44580, 114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
     if not (os.path.exists(dataset_path) and os.path.exists(class_path)):
         parser.create_dataset()

Hyperparameter Tuning/reduce_fault_class.py

@@ -12,9 +12,7 @@
 Fault_Class = np.array(joblib.load(Fault_Class_path))
 
 
-scenario_length = [1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-array = np.array(scenario_length) * 3
-scenario_length = list(array)
+scenario_length = [114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
 Fault_Class_reduced = np.zeros([Fault_Class.shape[0], 7], dtype=int)
 

Hyperparameter Tuning/sort_distances.py

@@ -8,7 +8,7 @@
 Distance_Class = joblib.load(Distance_Class_path)
 
 def distributer(dist_class):
-    new_class = dist_class[3*743:]
+    new_class = dist_class[44580:]
 
     return new_class
 

Hyperparameter Tuning/sort_metadata.py

@@ -22,9 +22,7 @@ def sort_meta(dataset):
 directory = os.getcwd()
 
 # scenario_length = datapoints for each scenario
-scenario_length = [743, 1907, 1907, 1907, 205, 205, 205, 477, 477, 477, 163, 245]
-array = np.array(scenario_length) * 3
-scenario_length = list(array)
+scenario_length = [44580, 114420, 114420, 114420, 12264, 12264, 12264, 28608, 28608, 28608, 9804, 14689]
 
 # Open  dataset file
 dataset_path = directory + r'\Dataset.joblib'