From d87127d966947de0b8f89ad2ca90a632df656fb9 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Sun, 23 Jun 2024 21:53:37 -0400 Subject: [PATCH 01/16] Update DC-OPF with correct PU and additional flow limit constraints This PR attempts to correct enhance flexibility of per-unit system of units in the DC-OPF and also impose line-flow MW limit constraint to represent thermally constrained lines. --- src/model/core/transmission/dcopf_transmission.jl | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/model/core/transmission/dcopf_transmission.jl b/src/model/core/transmission/dcopf_transmission.jl index ab2537ca01..cdc29625ad 100644 --- a/src/model/core/transmission/dcopf_transmission.jl +++ b/src/model/core/transmission/dcopf_transmission.jl @@ -43,6 +43,13 @@ function dcopf_transmission!(EP::Model, inputs::Dict, setup::Dict) t]==inputs["pDC_OPF_coeff"][l] * sum(inputs["pNet_Map"][l, z] * vANGLE[z, t] for z in 1:Z)) + # Maximum power flows, power flow on each transmission line cannot exceed maximum capacity of the line at any hour "t" + @constraints(EP, + begin + cMaxFlow_out[l = 1:L, t = 1:T], vFLOW[l, t] <= EP[:eAvail_Trans_Cap][l] + cMaxFlow_in[l = 1:L, t = 1:T], vFLOW[l, t] >= -EP[:eAvail_Trans_Cap][l] + end) + # Bus angle limits (except slack bus) @constraints(EP, begin From 718abdf39a0d404394931c284cca7bf116a93bd5 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Mon, 24 Jun 2024 07:28:12 -0400 Subject: [PATCH 02/16] Update load_network_data.jl Added base quantity definitions explicitly --- src/load_inputs/load_network_data.jl | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index ac7f2b1c8c..549e22b878 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -42,6 +42,13 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) setup["NetworkExpansion"] = 0 end println("Reading DC-OPF values...") + #Adding the base quantities + # Base voltage (in kV) + line_voltage_kV_Base = to_floats(:Line_Voltage_kV_Base) + # MVA_Base (in MVA) + MVA_Base = to_floats(:MVA_Base) + # Base reactance + line_reactance_Ohms_Base = (line_voltage_kV .^ 2) ./ MVA_Base # Transmission line voltage (in kV) line_voltage_kV = to_floats(:Line_Voltage_kV) # Transmission line reactance (in Ohms) @@ -52,6 +59,8 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) # MW = (kV)^2/Ohms inputs_nw["pDC_OPF_coeff"] = ((line_voltage_kV .^ 2) ./ line_reactance_Ohms) / scale_factor + #Reactance in pu + inputs_nw["pu_reactance'] = line_reactance_Ohms ./ line_reactance_Ohms_Base end # Maximum possible flow after reinforcement for use in linear segments of piecewise approximation From 426d57590f651eec52acdb3670dba14ff4f55b1c Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Mon, 24 Jun 2024 07:30:41 -0400 Subject: [PATCH 03/16] Update dcopf_transmission.jl Added pu reactance instead of P DC Coefficient --- src/model/core/transmission/dcopf_transmission.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/model/core/transmission/dcopf_transmission.jl b/src/model/core/transmission/dcopf_transmission.jl index cdc29625ad..b2f0ea9c57 100644 --- a/src/model/core/transmission/dcopf_transmission.jl +++ b/src/model/core/transmission/dcopf_transmission.jl @@ -40,8 +40,9 @@ function dcopf_transmission!(EP::Model, inputs::Dict, setup::Dict) @constraint(EP, cPOWER_FLOW_OPF[l = 1:L, t = 1:T], EP[:vFLOW][l, - t]==inputs["pDC_OPF_coeff"][l] * + t]==(1/inputs["pu_reactance"][l]) * sum(inputs["pNet_Map"][l, z] * vANGLE[z, t] for z in 1:Z)) + # Maximum power flows, power flow on each transmission line cannot exceed maximum capacity of the line at any hour "t" @constraints(EP, From 62dc3d3ee38709b7549e82cfadac16764ad02ea8 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Mon, 24 Jun 2024 07:31:21 -0400 Subject: [PATCH 04/16] Update load_network_data.jl Minor typo fix --- src/load_inputs/load_network_data.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index 549e22b878..74199ad039 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -60,7 +60,7 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) inputs_nw["pDC_OPF_coeff"] = ((line_voltage_kV .^ 2) ./ line_reactance_Ohms) / scale_factor #Reactance in pu - inputs_nw["pu_reactance'] = line_reactance_Ohms ./ line_reactance_Ohms_Base + inputs_nw["pu_reactance"] = line_reactance_Ohms ./ line_reactance_Ohms_Base end # Maximum possible flow after reinforcement for use in linear segments of piecewise approximation From 2f937df83a09c59ef540ed49709ee21489d9ad55 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Mon, 24 Jun 2024 07:49:33 -0400 Subject: [PATCH 05/16] Update load_network_data.jl Adding transformer details; work in progress --- src/load_inputs/load_network_data.jl | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index 74199ad039..eefb96c1ec 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -49,6 +49,9 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) MVA_Base = to_floats(:MVA_Base) # Base reactance line_reactance_Ohms_Base = (line_voltage_kV .^ 2) ./ MVA_Base + #Adding Transformer data + line_transformer_ht_turns = :Transformer_HT_Turns + line_transformer_ht_turns = :Transformer_LT_Turns # Transmission line voltage (in kV) line_voltage_kV = to_floats(:Line_Voltage_kV) # Transmission line reactance (in Ohms) From f7b0ca15bea781b441191a704e33defe5f93bfb2 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Mon, 24 Jun 2024 07:50:02 -0400 Subject: [PATCH 06/16] Update src/model/core/transmission/dcopf_transmission.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- src/model/core/transmission/dcopf_transmission.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/model/core/transmission/dcopf_transmission.jl b/src/model/core/transmission/dcopf_transmission.jl index b2f0ea9c57..2606457a05 100644 --- a/src/model/core/transmission/dcopf_transmission.jl +++ b/src/model/core/transmission/dcopf_transmission.jl @@ -40,7 +40,7 @@ function dcopf_transmission!(EP::Model, inputs::Dict, setup::Dict) @constraint(EP, cPOWER_FLOW_OPF[l = 1:L, t = 1:T], EP[:vFLOW][l, - t]==(1/inputs["pu_reactance"][l]) * + t]==(1 / inputs["pu_reactance"][l]) * sum(inputs["pNet_Map"][l, z] * vANGLE[z, t] for z in 1:Z)) From 2c728d077cc8bdd433aae0ba6122fa8767e1eb40 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Mon, 24 Jun 2024 13:46:16 -0400 Subject: [PATCH 07/16] Update load_network_data.jl Added transformer data for HT and LT sides --- src/load_inputs/load_network_data.jl | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index eefb96c1ec..7e3a952b89 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -50,8 +50,15 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) # Base reactance line_reactance_Ohms_Base = (line_voltage_kV .^ 2) ./ MVA_Base #Adding Transformer data + line_transformer_MVA_base = :Transformer_MVA_Base + #Transformer turns ratio line_transformer_ht_turns = :Transformer_HT_Turns - line_transformer_ht_turns = :Transformer_LT_Turns + line_transformer_lt_turns = :Transformer_LT_Turns + #Transformer LT side data + line_transformer_lt_pu_reactance = :Transformer_LT_Reactance + #Transformer HT side data + line_transformer_ht_pu_reactance = :Transformer_HT_Reactance + #Transformer HT side data # Transmission line voltage (in kV) line_voltage_kV = to_floats(:Line_Voltage_kV) # Transmission line reactance (in Ohms) From e8da8668f3a559b6a86139a9c54bedf86abb6734 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Mon, 1 Jul 2024 18:48:38 -0400 Subject: [PATCH 08/16] Update load_network_data.jl Added completed transformer details --- src/load_inputs/load_network_data.jl | 55 +++++++++++++++++++++++----- 1 file changed, 46 insertions(+), 9 deletions(-) diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index 7e3a952b89..711aa173c1 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -44,21 +44,58 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) println("Reading DC-OPF values...") #Adding the base quantities # Base voltage (in kV) - line_voltage_kV_Base = to_floats(:Line_Voltage_kV_Base) + line_voltage_kV = to_floats(:Line_Voltage_kV_Base) # MVA_Base (in MVA) MVA_Base = to_floats(:MVA_Base) # Base reactance line_reactance_Ohms_Base = (line_voltage_kV .^ 2) ./ MVA_Base - #Adding Transformer data + + ##Adding Transformer data line_transformer_MVA_base = :Transformer_MVA_Base - #Transformer turns ratio - line_transformer_ht_turns = :Transformer_HT_Turns + + ##Transformer LT side data + # LT Base voltage (in kV) + transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) + #Transformer LT Reactance in Ohms + line_transformer_lt_reactance = :Transformer_LT_Reactance_Ohms + #Transformer LT Turns line_transformer_lt_turns = :Transformer_LT_Turns - #Transformer LT side data - line_transformer_lt_pu_reactance = :Transformer_LT_Reactance - #Transformer HT side data - line_transformer_ht_pu_reactance = :Transformer_HT_Reactance - #Transformer HT side data + # LT Base reactance + lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base + #Transformer LT Reactance in pu + transformer_lt_reactance_pu = :Transformer_LT_Reactance_Ohms ./ lt_reactance_Base + + + ##Transformer HT side data + # HT Base voltage (in kV) + transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) + #Transformer HT Reactance in Ohms + line_transformer_ht_reactance = :Transformer_HT_Reactance_Ohms + #Transformer HT Turns + line_transformer_ht_turns = :Transformer_HT_Turns + # HT Base reactance + ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base + #Transformer LT Reactance in pu + transformer_ht_reactance_pu = :Transformer_HT_Reactance_Ohms ./ ht_reactance_Base + + + #LT Transformer Reactance referred to HT side in Ohms + lt_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_transformer_lt_reactance + #HT Transformer Reactance referred to LT side in Ohms + ht_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_transformer_ht_reactance + #Total LT Reactance in Ohms + total_lt_reactance_ohms = line_transformer_lt_reactance + ht_reactance_referred_to_lt + #Total LT Reactance in pu + total_lt_reactance_pu = total_lt_reactance_ohms ./ lt_reactance_Base + #Total HT Reactance in Ohms + total_ht_reactance_ohms = line_transformer_ht_reactance + lt_reactance_referred_to_ht + #Total HT Reactance in pu + total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base + + #Conversion of Transformer pu reactance to system pu + total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) + total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) + # Transmission line voltage (in kV) line_voltage_kV = to_floats(:Line_Voltage_kV) # Transmission line reactance (in Ohms) From ebca1f0834f5df063a1bb0d3031937eb99453eb4 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Sat, 6 Jul 2024 00:08:36 -0400 Subject: [PATCH 09/16] Modified Network.csv to house in transformer data --- .../9_IEEE_9_bus_DC_OPF/system/Network.csv | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv diff --git a/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv b/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv new file mode 100644 index 0000000000..6c248f4540 --- /dev/null +++ b/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv @@ -0,0 +1,11 @@ +,Network_zones,Network_Lines,Start_Zone,End_Zone,Line_Max_Flow_MW,transmission_path_name,distance_mile,Line_Loss_Percentage,Line_Max_Reinforcement_MW,Line_Reinforcement_Cost_per_MWyr,DerateCapRes_1,CapRes_1,CapRes_Excl_1,Angle_Limit_Rad,Line_Voltage_kV,Line_Resistance_Ohms,Line_Reactance_Ohms,MVA_Base,Has_Transformer,Transformer_MVA_Base,Transformer_LT_Voltage_kV_Base,Transformer_HT_Voltage_kV_Base,Transformer_LT_Reactance_Ohms,Transformer_HT_Reactance_Ohms,Transformer_LT_Turns,Transformer_HT_Turns +BUS1,z1,1,1,4,250,BUS1_to_BUS4,0.5,0.015,500,12000,0.95,0,0,0.785398,345,0,68.5584,100,0,,,,,,, +BUS2,z2,2,4,5,250,BUS4_to_BUS5,0.5,0.015,500,12000,0.95,0,0,0.785398,345,20.23425,109.503,100,1,200,150,350,70.85,177.125,150000,350000 +BUS3,z3,3,5,6,150,BUS5_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,46.41975,202.3425,100,0,,,,,,, +BUS4,z4,4,3,6,300,BUS3_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,0,69.74865,100,1,100,350,1000,81.34,203.35,350000,1000000 +BUS5,z5,5,6,7,150,BUS6_to_BUS7,0.5,0.015,500,12000,0.95,0,0,0.785398,345,14.163975,119.9772,100,1,300,400,1000,65.92,164.8,400000,1000000 +BUS6,z6,6,7,8,250,BUS7_to_BUS8,0.5,0.015,500,12000,0.95,0,0,0.785398,345,10.117125,85.698,100,1,450,400,1000,87.01,217.525,400000,1000000 +BUS7,z7,7,8,2,250,BUS8_to_BUS2,0.5,0.015,500,12000,0.95,0,0,0.785398,345,0,74.390625,100,1,375,100,350,78.44,196.1,100000,350000 +BUS8,z8,8,8,9,250,BUS8_to_BUS9,0.5,0.015,500,12000,0.95,0,0,0.785398,345,38.088,191.63025,100,0,,,,,,, +BUS9,z9,9,9,4,250,BUS9_to_BUS4,0.5,0.015,500,12000,0.95,0,0,0.785398,345,11.9025,101.17125,100,0,,,,,,, +,,10,1,6,250,BUS1_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,11.9025,101.17125,100,1,200,200,400,78.66,196.65,200000,400000 \ No newline at end of file From 78d0bf0bfe7109f0cbba02b731e1d6f1552d91c9 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Thu, 11 Jul 2024 10:29:01 -0400 Subject: [PATCH 10/16] Completed transformer addition to Network.csv and associated loading script --- docs/src/User_Guide/model_configuration.md | 9 +++++++++ src/load_inputs/load_network_data.jl | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/docs/src/User_Guide/model_configuration.md b/docs/src/User_Guide/model_configuration.md index 3713227099..8cfdd26485 100644 --- a/docs/src/User_Guide/model_configuration.md +++ b/docs/src/User_Guide/model_configuration.md @@ -149,4 +149,13 @@ The following tables summarize the model settings parameters and their default/p |ResourcePoliciesFolder | Name of the folder inside the `ResourcesFolder` where the input data for resource policy assignments is stored (default = "policy_assignments").| |TimeDomainReductionFolder | Name of the folder inside the current working directory where time domain reduced input data is stored.| + +"ComputeConflicts" => 0, + "StorageVirtualDischarge" => 1, + "ResourcesFolder" => "resources", + "ResourcePoliciesFolder" => "policy_assignments", + "SystemFolder" => "system", + "PoliciesFolder" => "policies", + "ObjScale" + The next step in configuring a GenX model is to specify the solver settings parameters using a `[solver_name]_settings.yml` file inside the `settings` folder. The solver settings parameters are solver specific and are described in the following section. diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index 711aa173c1..0b5011d36b 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -49,7 +49,7 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) MVA_Base = to_floats(:MVA_Base) # Base reactance line_reactance_Ohms_Base = (line_voltage_kV .^ 2) ./ MVA_Base - + if (Has_Transformer) ##Adding Transformer data line_transformer_MVA_base = :Transformer_MVA_Base @@ -95,7 +95,7 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) #Conversion of Transformer pu reactance to system pu total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) - + end # Transmission line voltage (in kV) line_voltage_kV = to_floats(:Line_Voltage_kV) # Transmission line reactance (in Ohms) From cafb68d3b04c81c7081eda52af1d29d0f8371f99 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Tue, 17 Dec 2024 11:29:25 -0500 Subject: [PATCH 11/16] Minor transformer remodeling for testing DC-OPF with transformers and PU measurements --- src/load_inputs/load_network_data.jl | 84 ++++++++++++++-------------- 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index 0b5011d36b..cd36ba9573 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -50,51 +50,51 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) # Base reactance line_reactance_Ohms_Base = (line_voltage_kV .^ 2) ./ MVA_Base if (Has_Transformer) - ##Adding Transformer data - line_transformer_MVA_base = :Transformer_MVA_Base + ##Adding Transformer data + line_transformer_MVA_base = :Transformer_MVA_Base - ##Transformer LT side data - # LT Base voltage (in kV) - transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) - #Transformer LT Reactance in Ohms - line_transformer_lt_reactance = :Transformer_LT_Reactance_Ohms - #Transformer LT Turns - line_transformer_lt_turns = :Transformer_LT_Turns - # LT Base reactance - lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base - #Transformer LT Reactance in pu - transformer_lt_reactance_pu = :Transformer_LT_Reactance_Ohms ./ lt_reactance_Base + ##Transformer LT side data + # LT Base voltage (in kV) + transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) + #Transformer LT Reactance in Ohms + line_transformer_lt_reactance = :Transformer_LT_Reactance_Ohms + #Transformer LT Turns + line_transformer_lt_turns = :Transformer_LT_Turns + # LT Base reactance + lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base + #Transformer LT Reactance in pu + transformer_lt_reactance_pu = :Transformer_LT_Reactance_Ohms ./ lt_reactance_Base - ##Transformer HT side data - # HT Base voltage (in kV) - transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) - #Transformer HT Reactance in Ohms - line_transformer_ht_reactance = :Transformer_HT_Reactance_Ohms - #Transformer HT Turns - line_transformer_ht_turns = :Transformer_HT_Turns - # HT Base reactance - ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base - #Transformer LT Reactance in pu - transformer_ht_reactance_pu = :Transformer_HT_Reactance_Ohms ./ ht_reactance_Base - - - #LT Transformer Reactance referred to HT side in Ohms - lt_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_transformer_lt_reactance - #HT Transformer Reactance referred to LT side in Ohms - ht_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_transformer_ht_reactance - #Total LT Reactance in Ohms - total_lt_reactance_ohms = line_transformer_lt_reactance + ht_reactance_referred_to_lt - #Total LT Reactance in pu - total_lt_reactance_pu = total_lt_reactance_ohms ./ lt_reactance_Base - #Total HT Reactance in Ohms - total_ht_reactance_ohms = line_transformer_ht_reactance + lt_reactance_referred_to_ht - #Total HT Reactance in pu - total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base - - #Conversion of Transformer pu reactance to system pu - total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) - total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) + ##Transformer HT side data + # HT Base voltage (in kV) + transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) + #Transformer HT Reactance in Ohms + line_transformer_ht_reactance = :Transformer_HT_Reactance_Ohms + #Transformer HT Turns + line_transformer_ht_turns = :Transformer_HT_Turns + # HT Base reactance + ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base + #Transformer LT Reactance in pu + transformer_ht_reactance_pu = :Transformer_HT_Reactance_Ohms ./ ht_reactance_Base + + + #LT Transformer Reactance referred to HT side in Ohms + lt_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_transformer_lt_reactance + #HT Transformer Reactance referred to LT side in Ohms + ht_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_transformer_ht_reactance + #Total LT Reactance in Ohms + total_lt_reactance_ohms = line_transformer_lt_reactance + ht_reactance_referred_to_lt + #Total LT Reactance in pu + total_lt_reactance_pu = total_lt_reactance_ohms ./ lt_reactance_Base + #Total HT Reactance in Ohms + total_ht_reactance_ohms = line_transformer_ht_reactance + lt_reactance_referred_to_ht + #Total HT Reactance in pu + total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base + + #Conversion of Transformer pu reactance to system pu + total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) + total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) end # Transmission line voltage (in kV) line_voltage_kV = to_floats(:Line_Voltage_kV) From c44c07f373dc2a07283c04a7b379408eeb3a323b Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Tue, 17 Dec 2024 22:45:34 -0500 Subject: [PATCH 12/16] Transformer modeling and PU calculations complete for DC-OPF; Summation of transformer reactance to line reactance remaining --- src/load_inputs/load_network_data.jl | 33 ++++++++++++------- .../core/transmission/dcopf_transmission.jl | 4 +-- 2 files changed, 23 insertions(+), 14 deletions(-) diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index cd36ba9573..7b0e93ed14 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -44,39 +44,45 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) println("Reading DC-OPF values...") #Adding the base quantities # Base voltage (in kV) - line_voltage_kV = to_floats(:Line_Voltage_kV_Base) + line_voltage_kV = to_floats(:Line_Voltage_kV) # MVA_Base (in MVA) MVA_Base = to_floats(:MVA_Base) # Base reactance line_reactance_Ohms_Base = (line_voltage_kV .^ 2) ./ MVA_Base - if (Has_Transformer) + #if (inputs_nw["Has_Transformer"] == 1) + # Base voltage (in kV) + line_voltage_kV_trans_df = network_var[network_var[!,:Has_Transformer] .== 1, :] + line_voltage_kV_trans = collect(skipmissing(line_voltage_kV_trans_df[!, :Line_Voltage_kV])) + # MVA_Base (in MVA) + MVA_Base_trans_df = network_var[network_var[!,:Has_Transformer] .== 1, :] + MVA_Base_trans = collect(skipmissing(MVA_Base_trans_df[!, :MVA_Base])) ##Adding Transformer data - line_transformer_MVA_base = :Transformer_MVA_Base + line_transformer_MVA_base = to_floats(:Transformer_MVA_Base) ##Transformer LT side data # LT Base voltage (in kV) transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) #Transformer LT Reactance in Ohms - line_transformer_lt_reactance = :Transformer_LT_Reactance_Ohms + line_transformer_lt_reactance = to_floats(:Transformer_LT_Reactance_Ohms) #Transformer LT Turns - line_transformer_lt_turns = :Transformer_LT_Turns + line_transformer_lt_turns = to_floats(:Transformer_LT_Turns) # LT Base reactance lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base #Transformer LT Reactance in pu - transformer_lt_reactance_pu = :Transformer_LT_Reactance_Ohms ./ lt_reactance_Base + transformer_lt_reactance_pu = to_floats(:Transformer_LT_Reactance_Ohms) ./ lt_reactance_Base ##Transformer HT side data # HT Base voltage (in kV) transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) #Transformer HT Reactance in Ohms - line_transformer_ht_reactance = :Transformer_HT_Reactance_Ohms + line_transformer_ht_reactance = to_floats(:Transformer_HT_Reactance_Ohms) #Transformer HT Turns - line_transformer_ht_turns = :Transformer_HT_Turns + line_transformer_ht_turns = to_floats(:Transformer_HT_Turns) # HT Base reactance ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base #Transformer LT Reactance in pu - transformer_ht_reactance_pu = :Transformer_HT_Reactance_Ohms ./ ht_reactance_Base + transformer_ht_reactance_pu = to_floats(:Transformer_HT_Reactance_Ohms) ./ ht_reactance_Base #LT Transformer Reactance referred to HT side in Ohms @@ -93,9 +99,12 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base #Conversion of Transformer pu reactance to system pu - total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) - total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) - end + total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV_trans) .^ 2) .* (MVA_Base_trans ./ line_transformer_MVA_base) + total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV_trans) .^ 2) .* (MVA_Base_trans ./ line_transformer_MVA_base) + println("Transformer data read successfully!") + println(total_ht_reactance_system_pu) + println(total_lt_reactance_system_pu) + #end # Transmission line voltage (in kV) line_voltage_kV = to_floats(:Line_Voltage_kV) # Transmission line reactance (in Ohms) diff --git a/src/model/core/transmission/dcopf_transmission.jl b/src/model/core/transmission/dcopf_transmission.jl index 2606457a05..62920094c7 100644 --- a/src/model/core/transmission/dcopf_transmission.jl +++ b/src/model/core/transmission/dcopf_transmission.jl @@ -47,8 +47,8 @@ function dcopf_transmission!(EP::Model, inputs::Dict, setup::Dict) # Maximum power flows, power flow on each transmission line cannot exceed maximum capacity of the line at any hour "t" @constraints(EP, begin - cMaxFlow_out[l = 1:L, t = 1:T], vFLOW[l, t] <= EP[:eAvail_Trans_Cap][l] - cMaxFlow_in[l = 1:L, t = 1:T], vFLOW[l, t] >= -EP[:eAvail_Trans_Cap][l] + cMaxFlow_out_dc_opf[l = 1:L, t = 1:T], EP[:vFLOW][l, t] <= EP[:eAvail_Trans_Cap][l] + cMaxFlow_in_dc_opf[l = 1:L, t = 1:T], EP[:vFLOW][l, t] >= -EP[:eAvail_Trans_Cap][l] end) # Bus angle limits (except slack bus) From ad24d4bb4afd694985dffc4a382cff7213cd3935 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Thu, 15 May 2025 08:38:06 -0400 Subject: [PATCH 13/16] Updated loading network --- .../9_IEEE_9_bus_DC_OPF/system/Network.csv | 22 +-- src/load_inputs/load_network_data.jl | 185 ++++++++++++------ 2 files changed, 133 insertions(+), 74 deletions(-) diff --git a/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv b/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv index 6c248f4540..9770c40d1e 100644 --- a/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv +++ b/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv @@ -1,11 +1,11 @@ -,Network_zones,Network_Lines,Start_Zone,End_Zone,Line_Max_Flow_MW,transmission_path_name,distance_mile,Line_Loss_Percentage,Line_Max_Reinforcement_MW,Line_Reinforcement_Cost_per_MWyr,DerateCapRes_1,CapRes_1,CapRes_Excl_1,Angle_Limit_Rad,Line_Voltage_kV,Line_Resistance_Ohms,Line_Reactance_Ohms,MVA_Base,Has_Transformer,Transformer_MVA_Base,Transformer_LT_Voltage_kV_Base,Transformer_HT_Voltage_kV_Base,Transformer_LT_Reactance_Ohms,Transformer_HT_Reactance_Ohms,Transformer_LT_Turns,Transformer_HT_Turns -BUS1,z1,1,1,4,250,BUS1_to_BUS4,0.5,0.015,500,12000,0.95,0,0,0.785398,345,0,68.5584,100,0,,,,,,, -BUS2,z2,2,4,5,250,BUS4_to_BUS5,0.5,0.015,500,12000,0.95,0,0,0.785398,345,20.23425,109.503,100,1,200,150,350,70.85,177.125,150000,350000 -BUS3,z3,3,5,6,150,BUS5_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,46.41975,202.3425,100,0,,,,,,, -BUS4,z4,4,3,6,300,BUS3_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,0,69.74865,100,1,100,350,1000,81.34,203.35,350000,1000000 -BUS5,z5,5,6,7,150,BUS6_to_BUS7,0.5,0.015,500,12000,0.95,0,0,0.785398,345,14.163975,119.9772,100,1,300,400,1000,65.92,164.8,400000,1000000 -BUS6,z6,6,7,8,250,BUS7_to_BUS8,0.5,0.015,500,12000,0.95,0,0,0.785398,345,10.117125,85.698,100,1,450,400,1000,87.01,217.525,400000,1000000 -BUS7,z7,7,8,2,250,BUS8_to_BUS2,0.5,0.015,500,12000,0.95,0,0,0.785398,345,0,74.390625,100,1,375,100,350,78.44,196.1,100000,350000 -BUS8,z8,8,8,9,250,BUS8_to_BUS9,0.5,0.015,500,12000,0.95,0,0,0.785398,345,38.088,191.63025,100,0,,,,,,, -BUS9,z9,9,9,4,250,BUS9_to_BUS4,0.5,0.015,500,12000,0.95,0,0,0.785398,345,11.9025,101.17125,100,0,,,,,,, -,,10,1,6,250,BUS1_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,11.9025,101.17125,100,1,200,200,400,78.66,196.65,200000,400000 \ No newline at end of file +,Network_zones,Network_Lines,Start_Zone,End_Zone,Line_Max_Flow_MW,transmission_path_name,distance_mile,Line_Loss_Percentage,Line_Max_Reinforcement_MW,Line_Reinforcement_Cost_per_MWyr,DerateCapRes_1,CapRes_1,CapRes_Excl_1,Angle_Limit_Rad,Line_Voltage_kV_LT,Line_Voltage_kV_HT,Line_Resistance_Ohms_LT,Line_Resistance_Ohms_HT,Line_Reactance_Ohms_LT,Line_Reactance_Ohms_HT,MVA_Base,Has_Transformer,Transformer_MVA_Base,Transformer_LT_Voltage_kV_Base,Transformer_HT_Voltage_kV_Base,Transformer_LT_Reactance_Ohms,Transformer_HT_Reactance_Ohms,Transformer_LT_Turns,Transformer_HT_Turns +BUS1,z1,1,1,4,250,BUS1_to_BUS4,0.5,0.015,500,12000,0.95,0,0,0.785398,345,345,0,0,68.5584,68.5584,100,0,100,345,345,0,0,1,1 +BUS2,z2,2,4,5,250,BUS4_to_BUS5,0.5,0.015,500,12000,0.95,0,0,0.785398,145,345,20.23425,50.585625,109.503,273.7575,100,1,200,150,350,70.85,177.125,150000,350000 +BUS3,z3,3,5,6,150,BUS5_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,345,46.41975,46.41975,202.3425,202.3425,100,0,100,345,345,0,0,1,1 +BUS4,z4,4,3,6,300,BUS3_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,985,0,0,69.74865,174.371625,100,1,100,350,1000,81.34,203.35,350000,1000000 +BUS5,z5,5,6,7,150,BUS6_to_BUS7,0.5,0.015,500,12000,0.95,0,0,0.785398,345,860,14.163975,35.4099375,119.9772,299.943,100,1,300,400,1000,65.92,164.8,400000,1000000 +BUS6,z6,6,7,8,250,BUS7_to_BUS8,0.5,0.015,500,12000,0.95,0,0,0.785398,345,860,10.117125,25.2928125,85.698,214.245,100,1,450,400,1000,87.01,217.525,400000,1000000 +BUS7,z7,7,8,2,250,BUS8_to_BUS2,0.5,0.015,500,12000,0.95,0,0,0.785398,100,345,0,0,74.390625,185.9765625,100,1,375,100,350,78.44,196.1,100000,350000 +BUS8,z8,8,8,9,250,BUS8_to_BUS9,0.5,0.015,500,12000,0.95,0,0,0.785398,345,345,38.088,38.088,191.63025,191.63025,100,0,100,345,345,0,0,1,1 +BUS9,z9,9,9,4,250,BUS9_to_BUS4,0.5,0.015,500,12000,0.95,0,0,0.785398,345,345,11.9025,11.9025,101.17125,101.17125,100,0,100,345,345,0,0,1,1 +,,10,1,6,250,BUS1_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,690,11.9025,29.75625,101.17125,252.928125,100,1,200,200,400,78.66,196.65,200000,400000 \ No newline at end of file diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index 7b0e93ed14..c24042bdc3 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -1,7 +1,8 @@ @doc raw""" load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) -Function for reading input parameters related to the electricity transmission network +Function for reading input parameters related to the electricity transmission network. When representing the presence of transformers, using DC-OPF, and/or using the +per-unit system of units, the scale_factor is also interpreted as the system base MVA, unless specified differently, otherwise. """ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) scale_factor = setup["ParameterScale"] == 1 ? ModelScalingFactor : 1 @@ -30,9 +31,11 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) inputs_nw["pPercent_Loss"] = to_floats(:Line_Loss_Percentage) elseif setup["Trans_Loss_Segments"] >= 2 # Transmission line voltage (in kV) - inputs_nw["kV"] = to_floats(:Line_Voltage_kV) + inputs_nw["kV_LT"] = to_floats(:Line_Voltage_kV_LT) + inputs_nw["kV_HT"] = to_floats(:Line_Voltage_kV_HT) # Transmission line resistance (in Ohms) - Used when modeling quadratic transmission losses - inputs_nw["Ohms"] = to_floats(:Line_Resistance_Ohms) + inputs_nw["Ohms_LT"] = to_floats(:Line_Resistance_Ohms_LT) + inputs_nw["Ohms_HT"] = to_floats(:Line_Resistance_Ohms_HT) end ## Inputs for the DC-OPF @@ -44,79 +47,135 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) println("Reading DC-OPF values...") #Adding the base quantities # Base voltage (in kV) - line_voltage_kV = to_floats(:Line_Voltage_kV) + line_voltage_kV_LT = to_floats(:Line_Voltage_kV_LT) + line_voltage_kV_HT = to_floats(:Line_Voltage_kV_HT) # MVA_Base (in MVA) MVA_Base = to_floats(:MVA_Base) # Base reactance - line_reactance_Ohms_Base = (line_voltage_kV .^ 2) ./ MVA_Base - #if (inputs_nw["Has_Transformer"] == 1) - # Base voltage (in kV) - line_voltage_kV_trans_df = network_var[network_var[!,:Has_Transformer] .== 1, :] - line_voltage_kV_trans = collect(skipmissing(line_voltage_kV_trans_df[!, :Line_Voltage_kV])) - # MVA_Base (in MVA) - MVA_Base_trans_df = network_var[network_var[!,:Has_Transformer] .== 1, :] - MVA_Base_trans = collect(skipmissing(MVA_Base_trans_df[!, :MVA_Base])) - ##Adding Transformer data - line_transformer_MVA_base = to_floats(:Transformer_MVA_Base) + line_reactance_Ohms_Base_LT = (line_voltage_kV_LT .^ 2) ./ MVA_Base + line_reactance_Ohms_Base_HT = (line_voltage_kV_HT .^ 2) ./ MVA_Base + # Base voltage (in kV) + line_voltage_kV_trans_df = network_var[network_var[!,:Has_Transformer] .== 1, :] + line_voltage_kV_trans_LT = collect(skipmissing(line_voltage_kV_trans_df[!, :Line_Voltage_kV_LT])) + line_voltage_kV_trans_HT = collect(skipmissing(line_voltage_kV_trans_df[!, :Line_Voltage_kV_HT])) + # MVA_Base (in MVA) + MVA_Base_trans = collect(skipmissing(line_voltage_kV_trans_df[!, :MVA_Base])) + ##Adding Transformer data + line_transformer_MVA_base = to_floats(:Transformer_MVA_Base) - ##Transformer LT side data - # LT Base voltage (in kV) - transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) - #Transformer LT Reactance in Ohms - line_transformer_lt_reactance = to_floats(:Transformer_LT_Reactance_Ohms) - #Transformer LT Turns - line_transformer_lt_turns = to_floats(:Transformer_LT_Turns) - # LT Base reactance - lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base - #Transformer LT Reactance in pu - transformer_lt_reactance_pu = to_floats(:Transformer_LT_Reactance_Ohms) ./ lt_reactance_Base + ##Transformer LT side data + # LT Base voltage (in kV) + transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) + #Transformer LT Reactance in Ohms + line_transformer_lt_reactance = to_floats(:Transformer_LT_Reactance_Ohms) + #Transformer LT Turns + line_transformer_lt_turns = to_floats(:Transformer_LT_Turns) + # LT Base reactance + lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base + #Transformer LT Reactance in pu + transformer_lt_reactance_pu = to_floats(:Transformer_LT_Reactance_Ohms) ./ lt_reactance_Base + println("P.U. values of LT Reactance") + println(transformer_lt_reactance_pu) - ##Transformer HT side data - # HT Base voltage (in kV) - transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) - #Transformer HT Reactance in Ohms - line_transformer_ht_reactance = to_floats(:Transformer_HT_Reactance_Ohms) - #Transformer HT Turns - line_transformer_ht_turns = to_floats(:Transformer_HT_Turns) - # HT Base reactance - ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base - #Transformer LT Reactance in pu - transformer_ht_reactance_pu = to_floats(:Transformer_HT_Reactance_Ohms) ./ ht_reactance_Base - - - #LT Transformer Reactance referred to HT side in Ohms - lt_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_transformer_lt_reactance - #HT Transformer Reactance referred to LT side in Ohms - ht_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_transformer_ht_reactance - #Total LT Reactance in Ohms - total_lt_reactance_ohms = line_transformer_lt_reactance + ht_reactance_referred_to_lt - #Total LT Reactance in pu - total_lt_reactance_pu = total_lt_reactance_ohms ./ lt_reactance_Base - #Total HT Reactance in Ohms - total_ht_reactance_ohms = line_transformer_ht_reactance + lt_reactance_referred_to_ht - #Total HT Reactance in pu - total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base - - #Conversion of Transformer pu reactance to system pu - total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV_trans) .^ 2) .* (MVA_Base_trans ./ line_transformer_MVA_base) - total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV_trans) .^ 2) .* (MVA_Base_trans ./ line_transformer_MVA_base) - println("Transformer data read successfully!") - println(total_ht_reactance_system_pu) - println(total_lt_reactance_system_pu) - #end + ##Transformer HT side data + # HT Base voltage (in kV) + transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) + #Transformer HT Reactance in Ohms + line_transformer_ht_reactance = to_floats(:Transformer_HT_Reactance_Ohms) + #Transformer HT Turns + line_transformer_ht_turns = to_floats(:Transformer_HT_Turns) + # HT Base reactance + ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base + #Transformer LT Reactance in pu + transformer_ht_reactance_pu = to_floats(:Transformer_HT_Reactance_Ohms) ./ ht_reactance_Base + println("P.U. values of HT Reactance") + println(transformer_ht_reactance_pu) + + #Transmission Line parameters # Transmission line voltage (in kV) - line_voltage_kV = to_floats(:Line_Voltage_kV) + line_voltage_kV_LT = to_floats(:Line_Voltage_kV_LT) + line_voltage_kV_HT = to_floats(:Line_Voltage_kV_HT) # Transmission line reactance (in Ohms) - line_reactance_Ohms = to_floats(:Line_Reactance_Ohms) + line_reactance_Ohms_LT = to_floats(:Line_Reactance_Ohms_LT) + line_reactance_Ohms_HT = to_floats(:Line_Reactance_Ohms_HT) # Line angle limit (in radians) inputs_nw["Line_Angle_Limit"] = to_floats(:Angle_Limit_Rad) # DC-OPF coefficient for each line (in MW when not scaled, in GW when scaled) # MW = (kV)^2/Ohms - inputs_nw["pDC_OPF_coeff"] = ((line_voltage_kV .^ 2) ./ line_reactance_Ohms) / - scale_factor #Reactance in pu - inputs_nw["pu_reactance"] = line_reactance_Ohms ./ line_reactance_Ohms_Base + inputs_nw["pu_reactance_lt"] = line_reactance_Ohms_LT ./ line_reactance_Ohms_Base_LT + println("P.U. values of Transmission Line Reactance on LT side") + println(inputs_nw["pu_reactance_lt"]) + inputs_nw["pu_reactance_ht"] = line_reactance_Ohms_HT ./ line_reactance_Ohms_Base_HT + println("P.U. values of Transmission Line Reactance on HT side") + println(inputs_nw["pu_reactance_ht"]) + #Transmission Line Reactance referred to LT side in Ohms + line_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_reactance_Ohms_HT + #Transmission Line Reactance referred to HT side in Ohms + line_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_reactance_Ohms_LT + #Total LT Reactance in Ohms + total_line_reactance_ohms_lt = line_reactance_Ohms_LT + line_reactance_referred_to_lt + #Total HT Reactance in Ohms + total_line_reactance_ohms_ht = line_reactance_Ohms_HT + line_reactance_referred_to_ht + #Total LT Reactance in pu + total_line_reactance_pu_lt = total_line_reactance_ohms_lt ./ line_reactance_Ohms_Base_LT + #Total HT Reactance in pu + total_line_reactance_pu_ht = total_line_reactance_ohms_ht ./ line_reactance_Ohms_Base_HT + println("P.U. values of Total LT Reactance") + println(total_line_reactance_pu_lt) + println("P.U. values of Total HT Reactance") + println(total_line_reactance_pu_ht) + #Conversion of Transmission line reactance to system pu + + + #LT Transformer Reactance referred to HT side in Ohms + lt_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_transformer_lt_reactance + #HT Transformer Reactance referred to LT side in Ohms + ht_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_transformer_ht_reactance + #Total LT Reactance in Ohms + total_lt_reactance_ohms = line_transformer_lt_reactance + ht_reactance_referred_to_lt + #Total LT Reactance in pu + total_lt_reactance_pu = total_lt_reactance_ohms ./ lt_reactance_Base + #Total HT Reactance in Ohms + total_ht_reactance_ohms = line_transformer_ht_reactance + lt_reactance_referred_to_ht + #Total HT Reactance in pu + total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base + println("P.U. values of Total LT Reactance") + println(total_lt_reactance_pu) + println("P.U. values of Total HT Reactance") + println(total_ht_reactance_pu) + + #Conversion of Transformer pu reactance to system pu + total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV_trans_HT) .^ 2) .* (MVA_Base_trans ./ line_transformer_MVA_base) + total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV_trans_LT) .^ 2) .* (MVA_Base_trans ./ line_transformer_MVA_base) + println("Transformer data read successfully!") + println("Total HT reactance in System P.U", total_ht_reactance_system_pu) + println("Total LT reactance in System P.U", total_lt_reactance_system_pu) + total_ht_reactance_txr_line_system_pu = total_ht_reactance_system_pu + total_line_reactance_pu_ht + total_lt_reactance_txr_line_system_pu = total_lt_reactance_system_pu + total_line_reactance_pu_lt + println("Total HT reactance in System P.U", total_ht_reactance_txr_line_system_pu) + println("Total LT reactance in System P.U", total_lt_reactance_txr_line_system_pu) + total_ht_reactance_txr_line_Ohms = total_ht_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_HT + total_lt_reactance_txr_line_Ohms = total_lt_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_LT + println("Total HT reactance in Ohms", total_ht_reactance_txr_line_Ohms) + println("Total LT reactance in Ohms", total_lt_reactance_txr_line_Ohms) + #DC-OPF coefficient for each line (in MW when not scaled, in GW when scaled) + # MW = (kV)^2/Ohms + #inputs_nw["pDC_OPF_coeff"] = ((line_voltage_kV .^ 2) ./ line_reactance_Ohms) / + #scale_factor + inputs_nw["pDC_OPF_coeff_ht"] = (total_ht_reactance_txr_line_system_pu*100) / + scale_factor + println("DC-OPF Coefficient HT") + println(inputs_nw["pDC_OPF_coeff_ht"]) + inputs_nw["pDC_OPF_coeff_lt"] = (total_lt_reactance_txr_line_system_pu*100) / + scale_factor + println("DC-OPF Coefficient LT") + println(inputs_nw["pDC_OPF_coeff_lt"]) + #DC-OPF coefficient for each transformer (in MW when not scaled, in GW when scaled) + # MW = (kV)^2/Ohms + #inputs_nw["pDC_OPF_coeff"] = ((line_voltage_kV .^ 2) ./ line_reactance_Ohms) / + #scale_factor end # Maximum possible flow after reinforcement for use in linear segments of piecewise approximation From 1fac5179dd074e1b9ffe80d1f96bbcfe542e6b1d Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Fri, 13 Jun 2025 10:02:29 -0400 Subject: [PATCH 14/16] Cleaned up and successfully tested transformer PU system --- src/load_inputs/load_network_data.jl | 91 +++++++++---------- .../core/transmission/dcopf_transmission.jl | 2 +- 2 files changed, 45 insertions(+), 48 deletions(-) diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index c24042bdc3..1011c1008f 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -47,81 +47,75 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) println("Reading DC-OPF values...") #Adding the base quantities # Base voltage (in kV) - line_voltage_kV_LT = to_floats(:Line_Voltage_kV_LT) - line_voltage_kV_HT = to_floats(:Line_Voltage_kV_HT) + line_voltage_kV_LT = to_floats(:Line_Voltage_kV_LT) #of size 10 + line_voltage_kV_HT = to_floats(:Line_Voltage_kV_HT) #of size 10 # MVA_Base (in MVA) - MVA_Base = to_floats(:MVA_Base) + MVA_Base = to_floats(:MVA_Base) #of size 10 # Base reactance - line_reactance_Ohms_Base_LT = (line_voltage_kV_LT .^ 2) ./ MVA_Base - line_reactance_Ohms_Base_HT = (line_voltage_kV_HT .^ 2) ./ MVA_Base - # Base voltage (in kV) - line_voltage_kV_trans_df = network_var[network_var[!,:Has_Transformer] .== 1, :] - line_voltage_kV_trans_LT = collect(skipmissing(line_voltage_kV_trans_df[!, :Line_Voltage_kV_LT])) - line_voltage_kV_trans_HT = collect(skipmissing(line_voltage_kV_trans_df[!, :Line_Voltage_kV_HT])) - # MVA_Base (in MVA) - MVA_Base_trans = collect(skipmissing(line_voltage_kV_trans_df[!, :MVA_Base])) + line_reactance_Ohms_Base_LT = (line_voltage_kV_LT .^ 2) ./ MVA_Base #of size 10 + line_reactance_Ohms_Base_HT = (line_voltage_kV_HT .^ 2) ./ MVA_Base #of size 10 ##Adding Transformer data - line_transformer_MVA_base = to_floats(:Transformer_MVA_Base) + line_transformer_MVA_base = to_floats(:Transformer_MVA_Base) #of size 10 ##Transformer LT side data # LT Base voltage (in kV) - transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) + transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) #of size 10 #Transformer LT Reactance in Ohms - line_transformer_lt_reactance = to_floats(:Transformer_LT_Reactance_Ohms) + line_transformer_lt_reactance = to_floats(:Transformer_LT_Reactance_Ohms) #of size 10 #Transformer LT Turns - line_transformer_lt_turns = to_floats(:Transformer_LT_Turns) + line_transformer_lt_turns = to_floats(:Transformer_LT_Turns) #of size 10 # LT Base reactance - lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base + lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base #of size 10 #Transformer LT Reactance in pu - transformer_lt_reactance_pu = to_floats(:Transformer_LT_Reactance_Ohms) ./ lt_reactance_Base + transformer_lt_reactance_pu = to_floats(:Transformer_LT_Reactance_Ohms) ./ lt_reactance_Base #of size 10 println("P.U. values of LT Reactance") println(transformer_lt_reactance_pu) ##Transformer HT side data # HT Base voltage (in kV) - transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) + transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) #of size 10 #Transformer HT Reactance in Ohms - line_transformer_ht_reactance = to_floats(:Transformer_HT_Reactance_Ohms) + line_transformer_ht_reactance = to_floats(:Transformer_HT_Reactance_Ohms) #of size 10 #Transformer HT Turns - line_transformer_ht_turns = to_floats(:Transformer_HT_Turns) + line_transformer_ht_turns = to_floats(:Transformer_HT_Turns) #of size 10 # HT Base reactance - ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base + ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base #of size 10 #Transformer LT Reactance in pu - transformer_ht_reactance_pu = to_floats(:Transformer_HT_Reactance_Ohms) ./ ht_reactance_Base + transformer_ht_reactance_pu = to_floats(:Transformer_HT_Reactance_Ohms) ./ ht_reactance_Base #of size 10 println("P.U. values of HT Reactance") println(transformer_ht_reactance_pu) #Transmission Line parameters # Transmission line voltage (in kV) - line_voltage_kV_LT = to_floats(:Line_Voltage_kV_LT) - line_voltage_kV_HT = to_floats(:Line_Voltage_kV_HT) + line_voltage_kV_LT = to_floats(:Line_Voltage_kV_LT) #of size 10 + line_voltage_kV_HT = to_floats(:Line_Voltage_kV_HT) #of size 10 # Transmission line reactance (in Ohms) - line_reactance_Ohms_LT = to_floats(:Line_Reactance_Ohms_LT) - line_reactance_Ohms_HT = to_floats(:Line_Reactance_Ohms_HT) + line_reactance_Ohms_LT = to_floats(:Line_Reactance_Ohms_LT) #of size 10 + line_reactance_Ohms_HT = to_floats(:Line_Reactance_Ohms_HT) #of size 10 # Line angle limit (in radians) - inputs_nw["Line_Angle_Limit"] = to_floats(:Angle_Limit_Rad) + inputs_nw["Line_Angle_Limit"] = to_floats(:Angle_Limit_Rad) #of size 10 # DC-OPF coefficient for each line (in MW when not scaled, in GW when scaled) # MW = (kV)^2/Ohms #Reactance in pu - inputs_nw["pu_reactance_lt"] = line_reactance_Ohms_LT ./ line_reactance_Ohms_Base_LT + inputs_nw["pu_reactance_lt"] = line_reactance_Ohms_LT ./ line_reactance_Ohms_Base_LT #of size 10 println("P.U. values of Transmission Line Reactance on LT side") println(inputs_nw["pu_reactance_lt"]) - inputs_nw["pu_reactance_ht"] = line_reactance_Ohms_HT ./ line_reactance_Ohms_Base_HT + inputs_nw["pu_reactance_ht"] = line_reactance_Ohms_HT ./ line_reactance_Ohms_Base_HT #of size 10 println("P.U. values of Transmission Line Reactance on HT side") println(inputs_nw["pu_reactance_ht"]) #Transmission Line Reactance referred to LT side in Ohms - line_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_reactance_Ohms_HT + line_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_reactance_Ohms_HT #of size 10 #Transmission Line Reactance referred to HT side in Ohms - line_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_reactance_Ohms_LT + line_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_reactance_Ohms_LT #of size 10 #Total LT Reactance in Ohms - total_line_reactance_ohms_lt = line_reactance_Ohms_LT + line_reactance_referred_to_lt + total_line_reactance_ohms_lt = line_reactance_Ohms_LT + line_reactance_referred_to_lt #of size 10 #Total HT Reactance in Ohms - total_line_reactance_ohms_ht = line_reactance_Ohms_HT + line_reactance_referred_to_ht + total_line_reactance_ohms_ht = line_reactance_Ohms_HT + line_reactance_referred_to_ht #of size 10 #Total LT Reactance in pu - total_line_reactance_pu_lt = total_line_reactance_ohms_lt ./ line_reactance_Ohms_Base_LT + total_line_reactance_pu_lt = total_line_reactance_ohms_lt ./ line_reactance_Ohms_Base_LT #of size 10 #Total HT Reactance in pu - total_line_reactance_pu_ht = total_line_reactance_ohms_ht ./ line_reactance_Ohms_Base_HT + total_line_reactance_pu_ht = total_line_reactance_ohms_ht ./ line_reactance_Ohms_Base_HT #of size 10 println("P.U. values of Total LT Reactance") println(total_line_reactance_pu_lt) println("P.U. values of Total HT Reactance") @@ -130,34 +124,37 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) #LT Transformer Reactance referred to HT side in Ohms - lt_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_transformer_lt_reactance + lt_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_transformer_lt_reactance #of size 10 #HT Transformer Reactance referred to LT side in Ohms - ht_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_transformer_ht_reactance + ht_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_transformer_ht_reactance #of size 10 #Total LT Reactance in Ohms - total_lt_reactance_ohms = line_transformer_lt_reactance + ht_reactance_referred_to_lt + total_lt_reactance_ohms = line_transformer_lt_reactance + ht_reactance_referred_to_lt #of size 10 #Total LT Reactance in pu - total_lt_reactance_pu = total_lt_reactance_ohms ./ lt_reactance_Base + total_lt_reactance_pu = total_lt_reactance_ohms ./ lt_reactance_Base #of size 10 #Total HT Reactance in Ohms - total_ht_reactance_ohms = line_transformer_ht_reactance + lt_reactance_referred_to_ht + total_ht_reactance_ohms = line_transformer_ht_reactance + lt_reactance_referred_to_ht #of size 10 #Total HT Reactance in pu - total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base + total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base #of size 10 println("P.U. values of Total LT Reactance") println(total_lt_reactance_pu) println("P.U. values of Total HT Reactance") println(total_ht_reactance_pu) #Conversion of Transformer pu reactance to system pu - total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV_trans_HT) .^ 2) .* (MVA_Base_trans ./ line_transformer_MVA_base) - total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV_trans_LT) .^ 2) .* (MVA_Base_trans ./ line_transformer_MVA_base) + println("Converting Transformer Reactance to System P.U") + println("Transformer LT Voltage Base in kV", collect(skipmissing(transformer_lt_voltage_kV_Base))) + println("Transformer HT Voltage Base in kV", collect(skipmissing(transformer_ht_voltage_kV_Base))) + total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV_HT) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) #of size 10 + total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV_LT) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) #of size 10 println("Transformer data read successfully!") println("Total HT reactance in System P.U", total_ht_reactance_system_pu) println("Total LT reactance in System P.U", total_lt_reactance_system_pu) - total_ht_reactance_txr_line_system_pu = total_ht_reactance_system_pu + total_line_reactance_pu_ht - total_lt_reactance_txr_line_system_pu = total_lt_reactance_system_pu + total_line_reactance_pu_lt + total_ht_reactance_txr_line_system_pu = total_ht_reactance_system_pu + total_line_reactance_pu_ht #of size 10 + total_lt_reactance_txr_line_system_pu = total_lt_reactance_system_pu + total_line_reactance_pu_lt #of size 10 println("Total HT reactance in System P.U", total_ht_reactance_txr_line_system_pu) println("Total LT reactance in System P.U", total_lt_reactance_txr_line_system_pu) - total_ht_reactance_txr_line_Ohms = total_ht_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_HT - total_lt_reactance_txr_line_Ohms = total_lt_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_LT + total_ht_reactance_txr_line_Ohms = total_ht_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_HT #of size 10 + total_lt_reactance_txr_line_Ohms = total_lt_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_LT #of size 10 println("Total HT reactance in Ohms", total_ht_reactance_txr_line_Ohms) println("Total LT reactance in Ohms", total_lt_reactance_txr_line_Ohms) #DC-OPF coefficient for each line (in MW when not scaled, in GW when scaled) diff --git a/src/model/core/transmission/dcopf_transmission.jl b/src/model/core/transmission/dcopf_transmission.jl index 62920094c7..4641318773 100644 --- a/src/model/core/transmission/dcopf_transmission.jl +++ b/src/model/core/transmission/dcopf_transmission.jl @@ -40,7 +40,7 @@ function dcopf_transmission!(EP::Model, inputs::Dict, setup::Dict) @constraint(EP, cPOWER_FLOW_OPF[l = 1:L, t = 1:T], EP[:vFLOW][l, - t]==(1 / inputs["pu_reactance"][l]) * + t]==(inputs["pDC_OPF_coeff_lt"][l]) * sum(inputs["pNet_Map"][l, z] * vANGLE[z, t] for z in 1:Z)) From 84425ccb3bfcdb4832cf9a0ea62820cdca28e529 Mon Sep 17 00:00:00 2001 From: "Chakrabarti, Sambuddha (Sam)" Date: Fri, 13 Jun 2025 16:32:57 -0400 Subject: [PATCH 15/16] Cleaned up lod_network_data.jl and tested successfully --- src/load_inputs/load_network_data.jl | 104 +++++++++++++-------------- 1 file changed, 49 insertions(+), 55 deletions(-) diff --git a/src/load_inputs/load_network_data.jl b/src/load_inputs/load_network_data.jl index 1011c1008f..ac823641ad 100644 --- a/src/load_inputs/load_network_data.jl +++ b/src/load_inputs/load_network_data.jl @@ -24,7 +24,13 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) inputs_nw["pNet_Map"] = load_network_map(network_var, Z, L) # Transmission capacity of the network (in MW) - inputs_nw["pTrans_Max"] = to_floats(:Line_Max_Flow_MW) / scale_factor # convert to GW + if setup["DC_OPF"] == 1 + # DC-OPF requires the transmission capacity to be in pu + inputs_nw["pTrans_Max"] = to_floats(:Line_Max_Flow_MW) / to_floats(:MVA_Base)[1] # convert to GW + else + # AC-OPF requires the transmission capacity to be in GW + inputs_nw["pTrans_Max"] = to_floats(:Line_Max_Flow_MW) / scale_factor # convert to GW + end if setup["Trans_Loss_Segments"] == 1 # Line percentage Loss - valid for case when modeling losses as a fixed percent of absolute value of power flows @@ -47,75 +53,72 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) println("Reading DC-OPF values...") #Adding the base quantities # Base voltage (in kV) - line_voltage_kV_LT = to_floats(:Line_Voltage_kV_LT) #of size 10 - line_voltage_kV_HT = to_floats(:Line_Voltage_kV_HT) #of size 10 + line_voltage_kV_LT = to_floats(:Line_Voltage_kV_LT) + line_voltage_kV_HT = to_floats(:Line_Voltage_kV_HT) # MVA_Base (in MVA) - MVA_Base = to_floats(:MVA_Base) #of size 10 + MVA_Base = to_floats(:MVA_Base) # Base reactance - line_reactance_Ohms_Base_LT = (line_voltage_kV_LT .^ 2) ./ MVA_Base #of size 10 - line_reactance_Ohms_Base_HT = (line_voltage_kV_HT .^ 2) ./ MVA_Base #of size 10 + line_reactance_Ohms_Base_LT = (line_voltage_kV_LT .^ 2) ./ MVA_Base + line_reactance_Ohms_Base_HT = (line_voltage_kV_HT .^ 2) ./ MVA_Base ##Adding Transformer data - line_transformer_MVA_base = to_floats(:Transformer_MVA_Base) #of size 10 + line_transformer_MVA_base = to_floats(:Transformer_MVA_Base) ##Transformer LT side data # LT Base voltage (in kV) - transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) #of size 10 + transformer_lt_voltage_kV_Base = to_floats(:Transformer_LT_Voltage_kV_Base) #Transformer LT Reactance in Ohms - line_transformer_lt_reactance = to_floats(:Transformer_LT_Reactance_Ohms) #of size 10 + line_transformer_lt_reactance = to_floats(:Transformer_LT_Reactance_Ohms) #Transformer LT Turns - line_transformer_lt_turns = to_floats(:Transformer_LT_Turns) #of size 10 + line_transformer_lt_turns = to_floats(:Transformer_LT_Turns) # LT Base reactance - lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base #of size 10 + lt_reactance_Base = (transformer_lt_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base #Transformer LT Reactance in pu - transformer_lt_reactance_pu = to_floats(:Transformer_LT_Reactance_Ohms) ./ lt_reactance_Base #of size 10 + transformer_lt_reactance_pu = to_floats(:Transformer_LT_Reactance_Ohms) ./ lt_reactance_Base println("P.U. values of LT Reactance") println(transformer_lt_reactance_pu) ##Transformer HT side data # HT Base voltage (in kV) - transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) #of size 10 + transformer_ht_voltage_kV_Base = to_floats(:Transformer_HT_Voltage_kV_Base) #Transformer HT Reactance in Ohms - line_transformer_ht_reactance = to_floats(:Transformer_HT_Reactance_Ohms) #of size 10 + line_transformer_ht_reactance = to_floats(:Transformer_HT_Reactance_Ohms) #Transformer HT Turns - line_transformer_ht_turns = to_floats(:Transformer_HT_Turns) #of size 10 + line_transformer_ht_turns = to_floats(:Transformer_HT_Turns) # HT Base reactance - ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base #of size 10 + ht_reactance_Base = (transformer_ht_voltage_kV_Base .^ 2) ./ line_transformer_MVA_base #Transformer LT Reactance in pu - transformer_ht_reactance_pu = to_floats(:Transformer_HT_Reactance_Ohms) ./ ht_reactance_Base #of size 10 + transformer_ht_reactance_pu = to_floats(:Transformer_HT_Reactance_Ohms) ./ ht_reactance_Base println("P.U. values of HT Reactance") println(transformer_ht_reactance_pu) #Transmission Line parameters - # Transmission line voltage (in kV) - line_voltage_kV_LT = to_floats(:Line_Voltage_kV_LT) #of size 10 - line_voltage_kV_HT = to_floats(:Line_Voltage_kV_HT) #of size 10 # Transmission line reactance (in Ohms) - line_reactance_Ohms_LT = to_floats(:Line_Reactance_Ohms_LT) #of size 10 - line_reactance_Ohms_HT = to_floats(:Line_Reactance_Ohms_HT) #of size 10 + line_reactance_Ohms_LT = to_floats(:Line_Reactance_Ohms_LT) + line_reactance_Ohms_HT = to_floats(:Line_Reactance_Ohms_HT) # Line angle limit (in radians) - inputs_nw["Line_Angle_Limit"] = to_floats(:Angle_Limit_Rad) #of size 10 + inputs_nw["Line_Angle_Limit"] = to_floats(:Angle_Limit_Rad) # DC-OPF coefficient for each line (in MW when not scaled, in GW when scaled) # MW = (kV)^2/Ohms #Reactance in pu - inputs_nw["pu_reactance_lt"] = line_reactance_Ohms_LT ./ line_reactance_Ohms_Base_LT #of size 10 + inputs_nw["pu_reactance_lt"] = line_reactance_Ohms_LT ./ line_reactance_Ohms_Base_LT println("P.U. values of Transmission Line Reactance on LT side") println(inputs_nw["pu_reactance_lt"]) - inputs_nw["pu_reactance_ht"] = line_reactance_Ohms_HT ./ line_reactance_Ohms_Base_HT #of size 10 + inputs_nw["pu_reactance_ht"] = line_reactance_Ohms_HT ./ line_reactance_Ohms_Base_HT println("P.U. values of Transmission Line Reactance on HT side") println(inputs_nw["pu_reactance_ht"]) #Transmission Line Reactance referred to LT side in Ohms - line_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_reactance_Ohms_HT #of size 10 + line_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_reactance_Ohms_HT #Transmission Line Reactance referred to HT side in Ohms - line_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_reactance_Ohms_LT #of size 10 + line_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_reactance_Ohms_LT #Total LT Reactance in Ohms - total_line_reactance_ohms_lt = line_reactance_Ohms_LT + line_reactance_referred_to_lt #of size 10 + total_line_reactance_ohms_lt = line_reactance_Ohms_LT + line_reactance_referred_to_lt #Total HT Reactance in Ohms - total_line_reactance_ohms_ht = line_reactance_Ohms_HT + line_reactance_referred_to_ht #of size 10 + total_line_reactance_ohms_ht = line_reactance_Ohms_HT + line_reactance_referred_to_ht #Total LT Reactance in pu - total_line_reactance_pu_lt = total_line_reactance_ohms_lt ./ line_reactance_Ohms_Base_LT #of size 10 + total_line_reactance_pu_lt = total_line_reactance_ohms_lt ./ line_reactance_Ohms_Base_LT #Total HT Reactance in pu - total_line_reactance_pu_ht = total_line_reactance_ohms_ht ./ line_reactance_Ohms_Base_HT #of size 10 + total_line_reactance_pu_ht = total_line_reactance_ohms_ht ./ line_reactance_Ohms_Base_HT println("P.U. values of Total LT Reactance") println(total_line_reactance_pu_lt) println("P.U. values of Total HT Reactance") @@ -124,17 +127,17 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) #LT Transformer Reactance referred to HT side in Ohms - lt_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_transformer_lt_reactance #of size 10 + lt_reactance_referred_to_ht = ((line_transformer_ht_turns ./ line_transformer_lt_turns) .^ 2) .* line_transformer_lt_reactance #HT Transformer Reactance referred to LT side in Ohms - ht_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_transformer_ht_reactance #of size 10 + ht_reactance_referred_to_lt = ((line_transformer_lt_turns ./ line_transformer_ht_turns) .^ 2) .* line_transformer_ht_reactance #Total LT Reactance in Ohms - total_lt_reactance_ohms = line_transformer_lt_reactance + ht_reactance_referred_to_lt #of size 10 + total_lt_reactance_ohms = line_transformer_lt_reactance + ht_reactance_referred_to_lt #Total LT Reactance in pu - total_lt_reactance_pu = total_lt_reactance_ohms ./ lt_reactance_Base #of size 10 + total_lt_reactance_pu = total_lt_reactance_ohms ./ lt_reactance_Base #Total HT Reactance in Ohms - total_ht_reactance_ohms = line_transformer_ht_reactance + lt_reactance_referred_to_ht #of size 10 + total_ht_reactance_ohms = line_transformer_ht_reactance + lt_reactance_referred_to_ht #Total HT Reactance in pu - total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base #of size 10 + total_ht_reactance_pu = total_ht_reactance_ohms ./ ht_reactance_Base println("P.U. values of Total LT Reactance") println(total_lt_reactance_pu) println("P.U. values of Total HT Reactance") @@ -144,35 +147,26 @@ function load_network_data!(setup::Dict, path::AbstractString, inputs_nw::Dict) println("Converting Transformer Reactance to System P.U") println("Transformer LT Voltage Base in kV", collect(skipmissing(transformer_lt_voltage_kV_Base))) println("Transformer HT Voltage Base in kV", collect(skipmissing(transformer_ht_voltage_kV_Base))) - total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV_HT) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) #of size 10 - total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV_LT) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) #of size 10 + total_ht_reactance_system_pu = total_ht_reactance_pu .* ((transformer_ht_voltage_kV_Base ./ line_voltage_kV_HT) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) + total_lt_reactance_system_pu = total_lt_reactance_pu .* ((transformer_lt_voltage_kV_Base ./ line_voltage_kV_LT) .^ 2) .* (MVA_Base ./ line_transformer_MVA_base) println("Transformer data read successfully!") println("Total HT reactance in System P.U", total_ht_reactance_system_pu) println("Total LT reactance in System P.U", total_lt_reactance_system_pu) - total_ht_reactance_txr_line_system_pu = total_ht_reactance_system_pu + total_line_reactance_pu_ht #of size 10 - total_lt_reactance_txr_line_system_pu = total_lt_reactance_system_pu + total_line_reactance_pu_lt #of size 10 + total_ht_reactance_txr_line_system_pu = total_ht_reactance_system_pu + total_line_reactance_pu_ht + total_lt_reactance_txr_line_system_pu = total_lt_reactance_system_pu + total_line_reactance_pu_lt println("Total HT reactance in System P.U", total_ht_reactance_txr_line_system_pu) println("Total LT reactance in System P.U", total_lt_reactance_txr_line_system_pu) - total_ht_reactance_txr_line_Ohms = total_ht_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_HT #of size 10 - total_lt_reactance_txr_line_Ohms = total_lt_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_LT #of size 10 + total_ht_reactance_txr_line_Ohms = total_ht_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_HT + total_lt_reactance_txr_line_Ohms = total_lt_reactance_txr_line_system_pu .* line_reactance_Ohms_Base_LT println("Total HT reactance in Ohms", total_ht_reactance_txr_line_Ohms) println("Total LT reactance in Ohms", total_lt_reactance_txr_line_Ohms) - #DC-OPF coefficient for each line (in MW when not scaled, in GW when scaled) - # MW = (kV)^2/Ohms - #inputs_nw["pDC_OPF_coeff"] = ((line_voltage_kV .^ 2) ./ line_reactance_Ohms) / - #scale_factor - inputs_nw["pDC_OPF_coeff_ht"] = (total_ht_reactance_txr_line_system_pu*100) / - scale_factor + #DC-OPF coefficient for each line (in MW when not scaled, in p.u. when scaled) + inputs_nw["pDC_OPF_coeff_ht"] = 1 ./ (total_ht_reactance_txr_line_system_pu) println("DC-OPF Coefficient HT") println(inputs_nw["pDC_OPF_coeff_ht"]) - inputs_nw["pDC_OPF_coeff_lt"] = (total_lt_reactance_txr_line_system_pu*100) / - scale_factor + inputs_nw["pDC_OPF_coeff_lt"] = 1 ./ (total_lt_reactance_txr_line_system_pu) println("DC-OPF Coefficient LT") println(inputs_nw["pDC_OPF_coeff_lt"]) - #DC-OPF coefficient for each transformer (in MW when not scaled, in GW when scaled) - # MW = (kV)^2/Ohms - #inputs_nw["pDC_OPF_coeff"] = ((line_voltage_kV .^ 2) ./ line_reactance_Ohms) / - #scale_factor end # Maximum possible flow after reinforcement for use in linear segments of piecewise approximation From c039a0d0b4c32ab1515feb003e838dd9154a8b58 Mon Sep 17 00:00:00 2001 From: lbonaldo Date: Wed, 18 Jun 2025 11:16:04 +0200 Subject: [PATCH 16/16] Clean up after rebase --- docs/src/User_Guide/model_configuration.md | 9 -------- .../10_IEEE_9_bus_DC_OPF/system/Network.csv | 22 +++++++++---------- .../9_IEEE_9_bus_DC_OPF/system/Network.csv | 11 ---------- .../core/transmission/dcopf_transmission.jl | 1 - 4 files changed, 11 insertions(+), 32 deletions(-) delete mode 100644 example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv diff --git a/docs/src/User_Guide/model_configuration.md b/docs/src/User_Guide/model_configuration.md index 8cfdd26485..3713227099 100644 --- a/docs/src/User_Guide/model_configuration.md +++ b/docs/src/User_Guide/model_configuration.md @@ -149,13 +149,4 @@ The following tables summarize the model settings parameters and their default/p |ResourcePoliciesFolder | Name of the folder inside the `ResourcesFolder` where the input data for resource policy assignments is stored (default = "policy_assignments").| |TimeDomainReductionFolder | Name of the folder inside the current working directory where time domain reduced input data is stored.| - -"ComputeConflicts" => 0, - "StorageVirtualDischarge" => 1, - "ResourcesFolder" => "resources", - "ResourcePoliciesFolder" => "policy_assignments", - "SystemFolder" => "system", - "PoliciesFolder" => "policies", - "ObjScale" - The next step in configuring a GenX model is to specify the solver settings parameters using a `[solver_name]_settings.yml` file inside the `settings` folder. The solver settings parameters are solver specific and are described in the following section. diff --git a/example_systems/10_IEEE_9_bus_DC_OPF/system/Network.csv b/example_systems/10_IEEE_9_bus_DC_OPF/system/Network.csv index 0677a9450a..7d7fa528fd 100644 --- a/example_systems/10_IEEE_9_bus_DC_OPF/system/Network.csv +++ b/example_systems/10_IEEE_9_bus_DC_OPF/system/Network.csv @@ -1,11 +1,11 @@ -,Network_zones,Network_Lines,Start_Zone,End_Zone,Line_Max_Flow_MW,transmission_path_name,distance_mile,Line_Loss_Percentage,Line_Max_Reinforcement_MW,Line_Reinforcement_Cost_per_MWyr,DerateCapRes_1,CapRes_Excl_1,Angle_Limit_Rad,Line_Voltage_kV,Line_Resistance_Ohms,Line_Reactance_Ohms -BUS1,z1,1,1,4,250,BUS1_to_BUS4,0.5,0.015,500,12000,0.95,0,0.785398,345,0,68.5584 -BUS2,z2,2,4,5,250,BUS4_to_BUS5,0.5,0.015,500,12000,0.95,0,0.785398,345,20.23425,109.503 -BUS3,z3,3,5,6,150,BUS5_to_BUS6,0.5,0.015,500,12000,0.95,0,0.785398,345,46.41975,202.3425 -BUS4,z4,4,3,6,300,BUS3_to_BUS6,0.5,0.015,500,12000,0.95,0,0.785398,345,0,69.74865 -BUS5,z5,5,6,7,150,BUS6_to_BUS7,0.5,0.015,500,12000,0.95,0,0.785398,345,14.163975,119.9772 -BUS6,z6,6,7,8,250,BUS7_to_BUS8,0.5,0.015,500,12000,0.95,0,0.785398,345,10.117125,85.698 -BUS7,z7,7,8,2,250,BUS8_to_BUS2,0.5,0.015,500,12000,0.95,0,0.785398,345,0,74.390625 -BUS8,z8,8,8,9,250,BUS8_to_BUS9,0.5,0.015,500,12000,0.95,0,0.785398,345,38.088,191.63025 -BUS9,z9,9,9,4,250,BUS9_to_BUS4,0.5,0.015,500,12000,0.95,0,0.785398,345,11.9025,101.17125 -,,10,1,6,250,BUS1_to_BUS6,0.5,0.015,500,12000,0.95,0,0.785398,345,11.9025,101.17125 \ No newline at end of file +,Network_zones,Network_Lines,Start_Zone,End_Zone,Line_Max_Flow_MW,transmission_path_name,distance_mile,Line_Loss_Percentage,Line_Max_Reinforcement_MW,Line_Reinforcement_Cost_per_MWyr,DerateCapRes_1,CapRes_Excl_1,Angle_Limit_Rad,Line_Voltage_kV_LT,Line_Voltage_kV_HT,Line_Resistance_Ohms_LT,Line_Resistance_Ohms_HT,Line_Reactance_Ohms_LT,Line_Reactance_Ohms_HT,MVA_Base,Has_Transformer,Transformer_MVA_Base,Transformer_LT_Voltage_kV_Base,Transformer_HT_Voltage_kV_Base,Transformer_LT_Reactance_Ohms,Transformer_HT_Reactance_Ohms,Transformer_LT_Turns,Transformer_HT_Turns +BUS1,z1,1,1,4,250,BUS1_to_BUS4,0.5,0.015,500,12000,0.95,0,0.785398,345,345,0,0,68.5584,68.5584,100,0,100,345,345,0,0,1,1 +BUS2,z2,2,4,5,250,BUS4_to_BUS5,0.5,0.015,500,12000,0.95,0,0.785398,145,345,20.23425,50.585625,109.503,273.7575,100,1,200,150,350,70.85,177.125,150000,350000 +BUS3,z3,3,5,6,150,BUS5_to_BUS6,0.5,0.015,500,12000,0.95,0,0.785398,345,345,46.41975,46.41975,202.3425,202.3425,100,0,100,345,345,0,0,1,1 +BUS4,z4,4,3,6,300,BUS3_to_BUS6,0.5,0.015,500,12000,0.95,0,0.785398,345,985,0,0,69.74865,174.371625,100,1,100,350,1000,81.34,203.35,350000,1000000 +BUS5,z5,5,6,7,150,BUS6_to_BUS7,0.5,0.015,500,12000,0.95,0,0.785398,345,860,14.163975,35.4099375,119.9772,299.943,100,1,300,400,1000,65.92,164.8,400000,1000000 +BUS6,z6,6,7,8,250,BUS7_to_BUS8,0.5,0.015,500,12000,0.95,0,0.785398,345,860,10.117125,25.2928125,85.698,214.245,100,1,450,400,1000,87.01,217.525,400000,1000000 +BUS7,z7,7,8,2,250,BUS8_to_BUS2,0.5,0.015,500,12000,0.95,0,0.785398,100,345,0,0,74.390625,185.9765625,100,1,375,100,350,78.44,196.1,100000,350000 +BUS8,z8,8,8,9,250,BUS8_to_BUS9,0.5,0.015,500,12000,0.95,0,0.785398,345,345,38.088,38.088,191.63025,191.63025,100,0,100,345,345,0,0,1,1 +BUS9,z9,9,9,4,250,BUS9_to_BUS4,0.5,0.015,500,12000,0.95,0,0.785398,345,345,11.9025,11.9025,101.17125,101.17125,100,0,100,345,345,0,0,1,1 +,,10,1,6,250,BUS1_to_BUS6,0.5,0.015,500,12000,0.95,0,0.785398,345,690,11.9025,29.75625,101.17125,252.928125,100,1,200,200,400,78.66,196.65,200000,400000 \ No newline at end of file diff --git a/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv b/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv deleted file mode 100644 index 9770c40d1e..0000000000 --- a/example_systems/9_IEEE_9_bus_DC_OPF/system/Network.csv +++ /dev/null @@ -1,11 +0,0 @@ -,Network_zones,Network_Lines,Start_Zone,End_Zone,Line_Max_Flow_MW,transmission_path_name,distance_mile,Line_Loss_Percentage,Line_Max_Reinforcement_MW,Line_Reinforcement_Cost_per_MWyr,DerateCapRes_1,CapRes_1,CapRes_Excl_1,Angle_Limit_Rad,Line_Voltage_kV_LT,Line_Voltage_kV_HT,Line_Resistance_Ohms_LT,Line_Resistance_Ohms_HT,Line_Reactance_Ohms_LT,Line_Reactance_Ohms_HT,MVA_Base,Has_Transformer,Transformer_MVA_Base,Transformer_LT_Voltage_kV_Base,Transformer_HT_Voltage_kV_Base,Transformer_LT_Reactance_Ohms,Transformer_HT_Reactance_Ohms,Transformer_LT_Turns,Transformer_HT_Turns -BUS1,z1,1,1,4,250,BUS1_to_BUS4,0.5,0.015,500,12000,0.95,0,0,0.785398,345,345,0,0,68.5584,68.5584,100,0,100,345,345,0,0,1,1 -BUS2,z2,2,4,5,250,BUS4_to_BUS5,0.5,0.015,500,12000,0.95,0,0,0.785398,145,345,20.23425,50.585625,109.503,273.7575,100,1,200,150,350,70.85,177.125,150000,350000 -BUS3,z3,3,5,6,150,BUS5_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,345,46.41975,46.41975,202.3425,202.3425,100,0,100,345,345,0,0,1,1 -BUS4,z4,4,3,6,300,BUS3_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,985,0,0,69.74865,174.371625,100,1,100,350,1000,81.34,203.35,350000,1000000 -BUS5,z5,5,6,7,150,BUS6_to_BUS7,0.5,0.015,500,12000,0.95,0,0,0.785398,345,860,14.163975,35.4099375,119.9772,299.943,100,1,300,400,1000,65.92,164.8,400000,1000000 -BUS6,z6,6,7,8,250,BUS7_to_BUS8,0.5,0.015,500,12000,0.95,0,0,0.785398,345,860,10.117125,25.2928125,85.698,214.245,100,1,450,400,1000,87.01,217.525,400000,1000000 -BUS7,z7,7,8,2,250,BUS8_to_BUS2,0.5,0.015,500,12000,0.95,0,0,0.785398,100,345,0,0,74.390625,185.9765625,100,1,375,100,350,78.44,196.1,100000,350000 -BUS8,z8,8,8,9,250,BUS8_to_BUS9,0.5,0.015,500,12000,0.95,0,0,0.785398,345,345,38.088,38.088,191.63025,191.63025,100,0,100,345,345,0,0,1,1 -BUS9,z9,9,9,4,250,BUS9_to_BUS4,0.5,0.015,500,12000,0.95,0,0,0.785398,345,345,11.9025,11.9025,101.17125,101.17125,100,0,100,345,345,0,0,1,1 -,,10,1,6,250,BUS1_to_BUS6,0.5,0.015,500,12000,0.95,0,0,0.785398,345,690,11.9025,29.75625,101.17125,252.928125,100,1,200,200,400,78.66,196.65,200000,400000 \ No newline at end of file diff --git a/src/model/core/transmission/dcopf_transmission.jl b/src/model/core/transmission/dcopf_transmission.jl index 4641318773..4470050516 100644 --- a/src/model/core/transmission/dcopf_transmission.jl +++ b/src/model/core/transmission/dcopf_transmission.jl @@ -42,7 +42,6 @@ function dcopf_transmission!(EP::Model, inputs::Dict, setup::Dict) EP[:vFLOW][l, t]==(inputs["pDC_OPF_coeff_lt"][l]) * sum(inputs["pNet_Map"][l, z] * vANGLE[z, t] for z in 1:Z)) - # Maximum power flows, power flow on each transmission line cannot exceed maximum capacity of the line at any hour "t" @constraints(EP,