void CONSTR_DC_FLOW_LIM_count_branch(Constr* c, Branch* br) { // Local variables int* Gcounter; Bus* bus[2]; // Constr data Gcounter = CONSTR_get_Gcounter_ptr(c); if (!Gcounter) return; bus[0] = BRANCH_get_bus_from(br); bus[1] = BRANCH_get_bus_to(br); if (BUS_has_flags(bus[0],FLAG_VARS,BUS_VAR_VANG)) { // wk var // G (*Gcounter)++; } if (BUS_has_flags(bus[1],FLAG_VARS,BUS_VAR_VANG)) { // wm var // G (*Gcounter)++; } if (BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_PHASE)) { // phi var // G (*Gcounter)++; } }
void FUNC_REG_PQ_count_step(Func* f, Branch* br, int t) { // Local variables Bus* bus[2]; Gen* gen; int bus_index_t[2]; int* Hcounter; char* bus_counted; int k; int T; // Num periods T = BRANCH_get_num_periods(br); // Constr data Hcounter = FUNC_get_Hcounter_ptr(f); bus_counted = FUNC_get_bus_counted(f); // Check pointers if (!Hcounter || !bus_counted) return; // Check outage if (BRANCH_is_on_outage(br)) return; // Bus data bus[0] = BRANCH_get_bus_from(br); bus[1] = BRANCH_get_bus_to(br); for (k = 0; k < 2; k++) bus_index_t[k] = BUS_get_index(bus[k])*T+t; // Buses for (k = 0; k < 2; k++) { if (!bus_counted[bus_index_t[k]]) { // Generators for (gen = BUS_get_gen(bus[k]); gen != NULL; gen = GEN_get_next(gen)) { if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q)) // Q var (*Hcounter)++; if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_P)) // P var (*Hcounter)++; } } // Update counted flag bus_counted[bus_index_t[k]] = TRUE; } }
void CONSTR_PAR_GEN_Q_count_branch(Constr* c, Branch* br) { // Local variables Bus* buses[2]; Bus* bus; Gen* gen1; Gen* gen2; int* Acounter; int* Aconstr_index; char* bus_counted; int i; int j; // Constr data Acounter = CONSTR_get_Acounter_ptr(c); Aconstr_index = CONSTR_get_Aconstr_index_ptr(c); bus_counted = CONSTR_get_bus_counted(c); if (!Acounter || !Aconstr_index || !bus_counted) return; // Bus data buses[0] = BRANCH_get_bus_from(br); buses[1] = BRANCH_get_bus_to(br); // Buses for (i = 0; i < 2; i++) { bus = buses[i]; if (!bus_counted[BUS_get_index(bus)]) { // Reactive power of regulating generators if (BUS_is_regulated_by_gen(bus)) { gen1 = BUS_get_reg_gen(bus); for (gen2 = GEN_get_reg_next(gen1); gen2 != NULL; gen2 = GEN_get_reg_next(gen2)) { if (GEN_has_flags(gen1,FLAG_VARS,GEN_VAR_Q)) (*Acounter)++; if (GEN_has_flags(gen2,FLAG_VARS,GEN_VAR_Q)) (*Acounter)++; (*Aconstr_index)++; } } } // Update counted flag bus_counted[BUS_get_index(bus)] = TRUE; } }
void FUNC_REG_PQ_eval_step(Func* f, Branch* br, int t, Vec* var_values) { // Local variables Bus* bus[2]; Gen* gen; int bus_index_t[2]; char* bus_counted; REAL* phi; REAL* gphi; REAL Qmid; REAL Pmid; REAL P; REAL Q; REAL dP; REAL dQ; int k; int T; // Num periods T = BRANCH_get_num_periods(br); // Constr data phi = FUNC_get_phi_ptr(f); gphi = VEC_get_data(FUNC_get_gphi(f)); bus_counted = FUNC_get_bus_counted(f); // Check pointers if (!phi || !gphi || !bus_counted) return; // Check outage if (BRANCH_is_on_outage(br)) return; // Bus data bus[0] = BRANCH_get_bus_from(br); bus[1] = BRANCH_get_bus_to(br); for (k = 0; k < 2; k++) bus_index_t[k] = BUS_get_index(bus[k])*T+t; // Buses for (k = 0; k < 2; k++) { if (!bus_counted[bus_index_t[k]]) { // Generators for (gen = BUS_get_gen(bus[k]); gen != NULL; gen = GEN_get_next(gen)) { // Mid value Qmid = (GEN_get_Q_max(gen)+GEN_get_Q_min(gen))/2.; // p.u. Pmid = (GEN_get_P_max(gen)+GEN_get_P_min(gen))/2.; // p.u. // Normalization factor dQ = GEN_get_Q_max(gen)-GEN_get_Q_min(gen); // p.u. if (dQ < FUNC_REG_PQ_PARAM) dQ = FUNC_REG_PQ_PARAM; dP = GEN_get_P_max(gen)-GEN_get_P_min(gen); // p.u. if (dP < FUNC_REG_PQ_PARAM) dP = FUNC_REG_PQ_PARAM; if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q)) { // Q var // Value Q = VEC_get(var_values,GEN_get_index_Q(gen,t)); // phi (*phi) += 0.5*pow((Q-Qmid)/dQ,2.); // gphi gphi[GEN_get_index_Q(gen,t)] = (Q-Qmid)/(dQ*dQ); } else { // Value Q = GEN_get_Q(gen,t); // phi (*phi) += 0.5*pow((Q-Qmid)/dQ,2.); } if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_P)) { // P var // Value P = VEC_get(var_values,GEN_get_index_P(gen,t)); // phi (*phi) += 0.5*pow((P-Pmid)/dP,2.); // gphi gphi[GEN_get_index_P(gen,t)] = (P-Pmid)/(dP*dP); } else { // Value P = GEN_get_P(gen,t); // phi (*phi) += 0.5*pow((P-Pmid)/dP,2.); } } } // Update counted flag bus_counted[bus_index_t[k]] = TRUE; } }
void FUNC_REG_PQ_analyze_step(Func* f, Branch* br, int t) { // Local variables Bus* bus[2]; Gen* gen; int bus_index_t[2]; int* Hcounter; char* bus_counted; Mat* H; int k; REAL dv; int T; // Num periods T = BRANCH_get_num_periods(br); // Constr data H = FUNC_get_Hphi(f); Hcounter = FUNC_get_Hcounter_ptr(f); bus_counted = FUNC_get_bus_counted(f); // Check pointers if (!Hcounter || !bus_counted) return; // Check outage if (BRANCH_is_on_outage(br)) return; // Bus data bus[0] = BRANCH_get_bus_from(br); bus[1] = BRANCH_get_bus_to(br); for (k = 0; k < 2; k++) bus_index_t[k] = BUS_get_index(bus[k])*T+t; // Buses for (k = 0; k < 2; k++) { if (!bus_counted[bus_index_t[k]]) { // Generators for (gen = BUS_get_gen(bus[k]); gen != NULL; gen = GEN_get_next(gen)) { if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q)) { // Q var dv = GEN_get_Q_max(gen)-GEN_get_Q_min(gen); // p.u. if (dv < FUNC_REG_PQ_PARAM) dv = FUNC_REG_PQ_PARAM; MAT_set_i(H,*Hcounter,GEN_get_index_Q(gen,t)); MAT_set_j(H,*Hcounter,GEN_get_index_Q(gen,t)); MAT_set_d(H,*Hcounter,1./(dv*dv)); (*Hcounter)++; } if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_P)) { // P var dv = GEN_get_P_max(gen)-GEN_get_P_min(gen); // p.u. if (dv < FUNC_REG_PQ_PARAM) dv = FUNC_REG_PQ_PARAM; MAT_set_i(H,*Hcounter,GEN_get_index_P(gen,t)); MAT_set_j(H,*Hcounter,GEN_get_index_P(gen,t)); MAT_set_d(H,*Hcounter,1./(dv*dv)); (*Hcounter)++; } } } // Update counted flag bus_counted[bus_index_t[k]] = TRUE; } }
void CONSTR_FIX_count_step(Constr* c, Branch* br, int t) { // Local variables Bus* buses[2]; Bus* bus; Gen* gen; Vargen* vargen; Shunt* shunt; Load* load; Bat* bat; int* Acounter; int* Aconstr_index; char* bus_counted; int i; int T; // Number of periods T = BRANCH_get_num_periods(br); // Constr data Acounter = CONSTR_get_Acounter_ptr(c); Aconstr_index = CONSTR_get_Aconstr_index_ptr(c); bus_counted = CONSTR_get_bus_counted(c); // Check pointers if (!Acounter || !Aconstr_index || !bus_counted) return; // Check outage if (BRANCH_is_on_outage(br)) return; // Bus data buses[0] = BRANCH_get_bus_from(br); buses[1] = BRANCH_get_bus_to(br); // Tap ratio if (BRANCH_has_flags(br,FLAG_FIXED,BRANCH_VAR_RATIO) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_RATIO)) { (*Acounter)++; (*Aconstr_index)++; } // Phase shift if (BRANCH_has_flags(br,FLAG_FIXED,BRANCH_VAR_PHASE) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_PHASE)) { (*Acounter)++; (*Aconstr_index)++; } // Buses for (i = 0; i < 2; i++) { bus = buses[i]; if (!bus_counted[BUS_get_index(bus)*T+t]) { // Voltage magnitude (V_MAG) if (BUS_has_flags(bus,FLAG_FIXED,BUS_VAR_VMAG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VMAG)) { (*Acounter)++; // Extra nz for regulating generator (for PV-PQ switching?) if (BUS_is_regulated_by_gen(bus) && GEN_has_flags(BUS_get_reg_gen(bus),FLAG_VARS,GEN_VAR_Q)) (*Acounter)++; (*Aconstr_index)++; } // Voltage angle (V_ANG) if (BUS_has_flags(bus,FLAG_FIXED,BUS_VAR_VANG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VANG)) { (*Acounter)++; (*Aconstr_index)++; } // Generators for (gen = BUS_get_gen(bus); gen != NULL; gen = GEN_get_next(gen)) { // Active power (P) if (GEN_has_flags(gen,FLAG_FIXED,GEN_VAR_P) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_P)) { (*Acounter)++; (*Aconstr_index)++; } // Reactive power (Q) if (GEN_has_flags(gen,FLAG_FIXED,GEN_VAR_Q) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q)) { (*Acounter)++; (*Aconstr_index)++; } } // Variable generators for (vargen = BUS_get_vargen(bus); vargen != NULL; vargen = VARGEN_get_next(vargen)) { // Active power (P) if (VARGEN_has_flags(vargen,FLAG_FIXED,VARGEN_VAR_P) && VARGEN_has_flags(vargen,FLAG_VARS,VARGEN_VAR_P)) { (*Acounter)++; (*Aconstr_index)++; } // Reactive power (Q) if (VARGEN_has_flags(vargen,FLAG_FIXED,VARGEN_VAR_Q) && VARGEN_has_flags(vargen,FLAG_VARS,VARGEN_VAR_Q)) { (*Acounter)++; (*Aconstr_index)++; } } // Shunts for (shunt = BUS_get_shunt(bus); shunt != NULL; shunt = SHUNT_get_next(shunt)) { // Susceptance (b) if (SHUNT_has_flags(shunt,FLAG_FIXED,SHUNT_VAR_SUSC) && SHUNT_has_flags(shunt,FLAG_VARS,SHUNT_VAR_SUSC)) { (*Acounter)++; (*Aconstr_index)++; } } // Batteries for (bat = BUS_get_bat(bus); bat != NULL; bat = BAT_get_next(bat)) { // Charging/discharging power (P) if (BAT_has_flags(bat,FLAG_FIXED,BAT_VAR_P) && BAT_has_flags(bat,FLAG_VARS,BAT_VAR_P)) { (*Acounter) += 2; (*Aconstr_index) += 2; } // Energy level (E) if (BAT_has_flags(bat,FLAG_FIXED,BAT_VAR_E) && BAT_has_flags(bat,FLAG_VARS,BAT_VAR_E)) { (*Acounter)++; (*Aconstr_index)++; } } // Loads for (load = BUS_get_load(bus); load != NULL; load = LOAD_get_next(load)) { // Active power (P) if (LOAD_has_flags(load,FLAG_FIXED,LOAD_VAR_P) && LOAD_has_flags(load,FLAG_VARS,LOAD_VAR_P)) { (*Acounter)++; (*Aconstr_index)++; } } } // Update counted flag bus_counted[BUS_get_index(bus)*T+t] = TRUE; } }
void CONSTR_FIX_analyze_step(Constr* c, Branch* br, int t) { // Local variables Bus* buses[2]; Bus* bus; Gen* gen; Vargen* vargen; Bat* bat; Load* load; Shunt* shunt; int* Acounter; int* Aconstr_index; char* bus_counted; Vec* b; Mat* A; int i; REAL Pc; REAL Pd; int T; // Number of periods T = BRANCH_get_num_periods(br); // Cosntr data b = CONSTR_get_b(c); A = CONSTR_get_A(c); Acounter = CONSTR_get_Acounter_ptr(c); Aconstr_index = CONSTR_get_Aconstr_index_ptr(c); bus_counted = CONSTR_get_bus_counted(c); // Check pointers if (!Acounter || !Aconstr_index || !bus_counted) return; // Check outage if (BRANCH_is_on_outage(br)) return; // Bus data buses[0] = BRANCH_get_bus_from(br); buses[1] = BRANCH_get_bus_to(br); // Tap ratio if (BRANCH_has_flags(br,FLAG_FIXED,BRANCH_VAR_RATIO) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_RATIO)) { VEC_set(b,*Aconstr_index,BRANCH_get_ratio(br,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,BRANCH_get_index_ratio(br,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } // Phase shift if (BRANCH_has_flags(br,FLAG_FIXED,BRANCH_VAR_PHASE) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_PHASE)) { VEC_set(b,*Aconstr_index,BRANCH_get_phase(br,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,BRANCH_get_index_phase(br,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } // Buses for (i = 0; i < 2; i++) { bus = buses[i]; if (!bus_counted[BUS_get_index(bus)*T+t]) { // Voltage magnitude (V_MAG) if (BUS_has_flags(bus,FLAG_FIXED,BUS_VAR_VMAG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VMAG)) { if (BUS_is_regulated_by_gen(bus)) VEC_set(b,*Aconstr_index,BUS_get_v_set(bus,t)); else VEC_set(b,*Aconstr_index,BUS_get_v_mag(bus,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,BUS_get_index_v_mag(bus,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; // Extra nz for regulating generator (for PV-PQ switching?) if (BUS_is_regulated_by_gen(bus) && GEN_has_flags(BUS_get_reg_gen(bus),FLAG_VARS,GEN_VAR_Q)) { MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,GEN_get_index_Q(BUS_get_reg_gen(bus),t)); MAT_set_d(A,*Acounter,0.); // placeholder (*Acounter)++; } (*Aconstr_index)++; } // Voltage angle (V_ANG) if (BUS_has_flags(bus,FLAG_FIXED,BUS_VAR_VANG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VANG)) { VEC_set(b,*Aconstr_index,BUS_get_v_ang(bus,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,BUS_get_index_v_ang(bus,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } // Generators for (gen = BUS_get_gen(bus); gen != NULL; gen = GEN_get_next(gen)) { // Active power (P) if (GEN_has_flags(gen,FLAG_FIXED,GEN_VAR_P) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_P)) { VEC_set(b,*Aconstr_index,GEN_get_P(gen,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,GEN_get_index_P(gen,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } // Reactive power (Q) if (GEN_has_flags(gen,FLAG_FIXED,GEN_VAR_Q) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q)) { VEC_set(b,*Aconstr_index,GEN_get_Q(gen,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,GEN_get_index_Q(gen,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } } // Variable generators for (vargen = BUS_get_vargen(bus); vargen != NULL; vargen = VARGEN_get_next(vargen)) { // Active power (P) if (VARGEN_has_flags(vargen,FLAG_FIXED,VARGEN_VAR_P) && VARGEN_has_flags(vargen,FLAG_VARS,VARGEN_VAR_P)) { VEC_set(b,*Aconstr_index,VARGEN_get_P(vargen,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,VARGEN_get_index_P(vargen,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } // Reactive power (Q) if (VARGEN_has_flags(vargen,FLAG_FIXED,VARGEN_VAR_Q) && VARGEN_has_flags(vargen,FLAG_VARS,VARGEN_VAR_Q)) { VEC_set(b,*Aconstr_index,VARGEN_get_Q(vargen,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,VARGEN_get_index_Q(vargen,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } } // Shunts for (shunt = BUS_get_shunt(bus); shunt != NULL; shunt = SHUNT_get_next(shunt)) { // Susceptance (b) if (SHUNT_has_flags(shunt,FLAG_FIXED,SHUNT_VAR_SUSC) && SHUNT_has_flags(shunt,FLAG_VARS,SHUNT_VAR_SUSC)) { VEC_set(b,*Aconstr_index,SHUNT_get_b(shunt,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,SHUNT_get_index_b(shunt,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } } // Batteries for (bat = BUS_get_bat(bus); bat != NULL; bat = BAT_get_next(bat)) { // Charging/discharging power (P) if (BAT_has_flags(bat,FLAG_FIXED,BAT_VAR_P) && BAT_has_flags(bat,FLAG_VARS,BAT_VAR_P)) { if (BAT_get_P(bat,t) >= 0) { Pc = BAT_get_P(bat,t); Pd = 0.; } else { Pc = 0.; Pd = -BAT_get_P(bat,t); } // Pc VEC_set(b,*Aconstr_index,Pc); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,BAT_get_index_Pc(bat,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; // Pd VEC_set(b,*Aconstr_index,Pd); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,BAT_get_index_Pd(bat,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } // Energy level (E) if (BAT_has_flags(bat,FLAG_FIXED,BAT_VAR_E) && BAT_has_flags(bat,FLAG_VARS,BAT_VAR_E)) { VEC_set(b,*Aconstr_index,BAT_get_E(bat,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,BAT_get_index_E(bat,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } } // Loads for (load = BUS_get_load(bus); load != NULL; load = LOAD_get_next(load)) { // Active power (P) if (LOAD_has_flags(load,FLAG_FIXED,LOAD_VAR_P) && LOAD_has_flags(load,FLAG_VARS,LOAD_VAR_P)) { VEC_set(b,*Aconstr_index,LOAD_get_P(load,t)); MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,LOAD_get_index_P(load,t)); MAT_set_d(A,*Acounter,1.); (*Acounter)++; (*Aconstr_index)++; } } } // Update counted flag bus_counted[BUS_get_index(bus)*T+t] = TRUE; } }
void CONSTR_PAR_GEN_Q_analyze_branch(Constr* c, Branch* br) { // Local variables Bus* buses[2]; Bus* bus; Gen* gen1; Gen* gen2; int* Acounter; int* Aconstr_index; char* bus_counted; Vec* b; Mat* A; int i; int j; REAL Qmin1; REAL Qmin2; REAL dQ1; REAL dQ2; // Cosntr data b = CONSTR_get_b(c); A = CONSTR_get_A(c); Acounter = CONSTR_get_Acounter_ptr(c); Aconstr_index = CONSTR_get_Aconstr_index_ptr(c); bus_counted = CONSTR_get_bus_counted(c); if (!Acounter || !Aconstr_index || !bus_counted) return; // Bus data buses[0] = BRANCH_get_bus_from(br); buses[1] = BRANCH_get_bus_to(br); // Buses for (i = 0; i < 2; i++) { bus = buses[i]; if (!bus_counted[BUS_get_index(bus)]) { // Reactive power of regulating generators if (BUS_is_regulated_by_gen(bus)) { gen1 = BUS_get_reg_gen(bus); Qmin1 = GEN_get_Q_min(gen1); dQ1 = GEN_get_Q_max(gen1)-Qmin1; if (dQ1 < CONSTR_PAR_GEN_Q_PARAM) dQ1 = CONSTR_PAR_GEN_Q_PARAM; for (gen2 = GEN_get_reg_next(gen1); gen2 != NULL; gen2 = GEN_get_reg_next(gen2)) { Qmin2 = GEN_get_Q_min(gen2); dQ2 = GEN_get_Q_max(gen2)-Qmin2; if (dQ2 < CONSTR_PAR_GEN_Q_PARAM) dQ2 = CONSTR_PAR_GEN_Q_PARAM; VEC_set(b,*Aconstr_index,Qmin1/dQ1-Qmin2/dQ2); if (GEN_has_flags(gen1,FLAG_VARS,GEN_VAR_Q)) { MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,GEN_get_index_Q(gen1)); MAT_set_d(A,*Acounter,1./dQ1); (*Acounter)++; } else VEC_add_to_entry(b,*Aconstr_index,-GEN_get_Q(gen1)/dQ1); if (GEN_has_flags(gen2,FLAG_VARS,GEN_VAR_Q)) { MAT_set_i(A,*Acounter,*Aconstr_index); MAT_set_j(A,*Acounter,GEN_get_index_Q(gen2)); MAT_set_d(A,*Acounter,-1./dQ2); (*Acounter)++; } else VEC_add_to_entry(b,*Aconstr_index,GEN_get_Q(gen2)/dQ2); (*Aconstr_index)++; } } } // Update counted flag bus_counted[BUS_get_index(bus)] = TRUE; } }
void CONSTR_DC_FLOW_LIM_analyze_branch(Constr* c, Branch* br) { // Local variables Bus* bus[2]; Mat* G; Vec* l; Vec* u; int* Gcounter; REAL b; int index; double rating; // Constr data G = CONSTR_get_G(c); l = CONSTR_get_l(c); u = CONSTR_get_u(c); Gcounter = CONSTR_get_Gcounter_ptr(c); if (!Gcounter) return; bus[0] = BRANCH_get_bus_from(br); bus[1] = BRANCH_get_bus_to(br); b = BRANCH_get_b(br); index = BRANCH_get_index(br); if (BRANCH_get_ratingA(br) > 0) rating = BRANCH_get_ratingA(br); else rating = BRANCH_INF_FLOW; VEC_set(l,index,-rating); // p.u. VEC_set(u,index,rating); // p.u. if (BUS_has_flags(bus[0],FLAG_VARS,BUS_VAR_VANG)) { // wk var // G MAT_set_i(G,*Gcounter,index); MAT_set_j(G,*Gcounter,BUS_get_index_v_ang(bus[0])); // wk MAT_set_d(G,*Gcounter,-b); (*Gcounter)++; } else { // b VEC_add_to_entry(l,index,b*BUS_get_v_ang(bus[0])); VEC_add_to_entry(u,index,b*BUS_get_v_ang(bus[0])); } if (BUS_has_flags(bus[1],FLAG_VARS,BUS_VAR_VANG)) { // wm var // G MAT_set_i(G,*Gcounter,index); MAT_set_j(G,*Gcounter,BUS_get_index_v_ang(bus[1])); // wk MAT_set_d(G,*Gcounter,b); (*Gcounter)++; } else { // b VEC_add_to_entry(l,index,-b*BUS_get_v_ang(bus[1])); VEC_add_to_entry(u,index,-b*BUS_get_v_ang(bus[1])); } if (BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_PHASE)) { // phi var // G MAT_set_i(G,*Gcounter,index); MAT_set_j(G,*Gcounter,BRANCH_get_index_phase(br)); // phi MAT_set_d(G,*Gcounter,b); (*Gcounter)++; } else { // b VEC_add_to_entry(l,index,-b*BRANCH_get_phase(br)); VEC_add_to_entry(u,index,-b*BRANCH_get_phase(br)); } }
void CONSTR_BOUND_store_sens_step(Constr* c, Branch* br, int t, Vec* sA, Vec* sf, Vec* sGu, Vec* sGl) { // Local variables Bus* buses[2]; Bus* bus; Gen* gen; Shunt* shunt; int* Jcounter; char* bus_counted; int bus_index_t[2]; int k; int T; // Number of periods T = BRANCH_get_num_periods(br); // Constr data Jcounter = CONSTR_get_Jcounter_ptr(c); bus_counted = CONSTR_get_bus_counted(c); // Check pointers if (!Jcounter || !bus_counted) return; // Check outage if (BRANCH_is_on_outage(br)) return; // Bus data buses[0] = BRANCH_get_bus_from(br); buses[1] = BRANCH_get_bus_to(br); for (k = 0; k < 2; k++) bus_index_t[k] = BUS_get_index(buses[k])*T+t; // Tap ratio if (BRANCH_has_flags(br,FLAG_BOUNDED,BRANCH_VAR_RATIO) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_RATIO)) { (*Jcounter)++; // upper bound (*Jcounter)++; // lower bound } // Phase shift if (BRANCH_has_flags(br,FLAG_BOUNDED,BRANCH_VAR_PHASE) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_PHASE)) { (*Jcounter)++; // upper bound (*Jcounter)++; // lower bound } // Buses for (k = 0; k < 2; k++) { bus = buses[k]; if (!bus_counted[bus_index_t[k]]) { // not counted yet // Voltage magnitude (V_MAG) if (BUS_has_flags(bus,FLAG_BOUNDED,BUS_VAR_VMAG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VMAG)) { BUS_set_sens_v_mag_u_bound(bus,VEC_get(sf,*Jcounter),t); (*Jcounter)++; // upper bound BUS_set_sens_v_mag_l_bound(bus,VEC_get(sf,*Jcounter),t); (*Jcounter)++; // lower bound } // Volage angle (V_ANG) if (BUS_has_flags(bus,FLAG_BOUNDED,BUS_VAR_VANG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VANG)) { (*Jcounter)++; // upper bound (*Jcounter)++; // lower bound } // Generators for (gen = BUS_get_gen(bus); gen != NULL; gen = GEN_get_next(gen)) { // Active power (P) if (GEN_has_flags(gen,FLAG_BOUNDED,GEN_VAR_P) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_P)) { (*Jcounter)++; // upper bound (*Jcounter)++; // lower bound } // Reactive power (Q) if (GEN_has_flags(gen,FLAG_BOUNDED,GEN_VAR_Q) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q)) { (*Jcounter)++; // upper bound (*Jcounter)++; // lower bound } } // Shunts for (shunt = BUS_get_shunt(bus); shunt != NULL; shunt = SHUNT_get_next(shunt)) { // Susceptance if (SHUNT_has_flags(shunt,FLAG_BOUNDED,SHUNT_VAR_SUSC) && SHUNT_has_flags(shunt,FLAG_VARS,SHUNT_VAR_SUSC)) { (*Jcounter)++; // upper bound (*Jcounter)++; // lower bound } } } // Update counted flag bus_counted[bus_index_t[k]] = TRUE; } }
void CONSTR_BOUND_eval_step(Constr* c, Branch* br, int t, Vec* var_values) { // Local variables Bus* buses[2]; Bus* bus; Gen* gen; Shunt* shunt; Mat* H_array; REAL* f; REAL* J; Mat* H; int* Jcounter; char* bus_counted; int bus_index_t[2]; int k; REAL u; REAL umin; REAL umax; REAL du; REAL a1; REAL a2; REAL b; REAL eps; REAL sqrterm1; REAL sqrterm2; int T; // Number of periods T = BRANCH_get_num_periods(br); // Constr data f = VEC_get_data(CONSTR_get_f(c)); J = MAT_get_data_array(CONSTR_get_J(c)); H_array = CONSTR_get_H_array(c); Jcounter = CONSTR_get_Jcounter_ptr(c); bus_counted = CONSTR_get_bus_counted(c); // Check pointers if (!f || !J || !Jcounter || !bus_counted) return; // Check outage if (BRANCH_is_on_outage(br)) return; // Param eps = CONSTR_BOUND_PARAM; // Bus data buses[0] = BRANCH_get_bus_from(br); buses[1] = BRANCH_get_bus_to(br); for (k = 0; k < 2; k++) bus_index_t[k] = BUS_get_index(buses[k])*T+t; // Branch //******* // Tap ratio if (BRANCH_has_flags(br,FLAG_BOUNDED,BRANCH_VAR_RATIO) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_RATIO)) { u = VEC_get(var_values,BRANCH_get_index_ratio(br,t)); umax = BRANCH_get_ratio_max(br); umin = BRANCH_get_ratio_min(br); du = (umax-umin > eps) ? umax-umin : eps; a1 = umax-u; a2 = u-umin; b = eps*eps/du; sqrterm1 = sqrt(a1*a1+b*b+eps*eps); sqrterm2 = sqrt(a2*a2+b*b+eps*eps); // f f[*Jcounter] = a1 + b - sqrterm1; // upper f[*Jcounter+1] = a2 + b - sqrterm2; // lower // J J[*Jcounter] = -(1-a1/sqrterm1); J[*Jcounter+1] = (1-a2/sqrterm2); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm1*sqrterm1*sqrterm1)); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm2*sqrterm2*sqrterm2)); (*Jcounter)++; (*Jcounter)++; } // Phase shift if (BRANCH_has_flags(br,FLAG_BOUNDED,BRANCH_VAR_PHASE) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_PHASE)) { u = VEC_get(var_values,BRANCH_get_index_phase(br,t)); umax = BRANCH_get_phase_max(br); umin = BRANCH_get_phase_min(br); du = (umax-umin > eps) ? umax-umin : eps; a1 = umax-u; a2 = u-umin; b = eps*eps/du; sqrterm1 = sqrt(a1*a1+b*b+eps*eps); sqrterm2 = sqrt(a2*a2+b*b+eps*eps); // f f[*Jcounter] = a1 + b - sqrterm1; // upper f[*Jcounter+1] = a2 + b - sqrterm2; // lower // J J[*Jcounter] = -(1-a1/sqrterm1); J[*Jcounter+1] = (1-a2/sqrterm2); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm1*sqrterm1*sqrterm1)); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm2*sqrterm2*sqrterm2)); (*Jcounter)++; (*Jcounter)++; } // Buses //****** for (k = 0; k < 2; k++) { bus = buses[k]; if (!bus_counted[bus_index_t[k]]) { // not counted yet // Voltage magnitude (V_MAG) if (BUS_has_flags(bus,FLAG_BOUNDED,BUS_VAR_VMAG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VMAG)) { u = VEC_get(var_values,BUS_get_index_v_mag(bus,t)); umax = BUS_get_v_max(bus); umin = BUS_get_v_min(bus); du = (umax-umin > eps) ? umax-umin : eps; a1 = umax-u; a2 = u-umin; b = eps*eps/du; sqrterm1 = sqrt(a1*a1+b*b+eps*eps); sqrterm2 = sqrt(a2*a2+b*b+eps*eps); // f f[*Jcounter] = a1 + b - sqrterm1; // upper f[*Jcounter+1] = a2 + b - sqrterm2; // lower // J J[*Jcounter] = -(1-a1/sqrterm1); J[*Jcounter+1] = (1-a2/sqrterm2); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm1*sqrterm1*sqrterm1)); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm2*sqrterm2*sqrterm2)); (*Jcounter)++; (*Jcounter)++; } // Volage angle (V_ANG) if (BUS_has_flags(bus,FLAG_BOUNDED,BUS_VAR_VANG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VANG)) { u = VEC_get(var_values,BUS_get_index_v_ang(bus,t)); umax = 2*PI; umin = -2*PI; du = (umax-umin > eps) ? umax-umin : eps; a1 = umax-u; a2 = u-umin; b = eps*eps/du; sqrterm1 = sqrt(a1*a1+b*b+eps*eps); sqrterm2 = sqrt(a2*a2+b*b+eps*eps); // f f[*Jcounter] = a1 + b - sqrterm1; // upper f[*Jcounter+1] = a2 + b - sqrterm2; // lower // J J[*Jcounter] = -(1-a1/sqrterm1); J[*Jcounter+1] = (1-a2/sqrterm2); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm1*sqrterm1*sqrterm1)); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm2*sqrterm2*sqrterm2)); (*Jcounter)++; (*Jcounter)++; } // Generators for (gen = BUS_get_gen(bus); gen != NULL; gen = GEN_get_next(gen)) { // Active power (P) if (GEN_has_flags(gen,FLAG_BOUNDED,GEN_VAR_P) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_P)) { u = VEC_get(var_values,GEN_get_index_P(gen,t)); umax = GEN_get_P_max(gen); umin = GEN_get_P_min(gen); du = (umax-umin > eps) ? umax-umin : eps; a1 = umax-u; a2 = u-umin; b = eps*eps/du; sqrterm1 = sqrt(a1*a1+b*b+eps*eps); sqrterm2 = sqrt(a2*a2+b*b+eps*eps); // f f[*Jcounter] = a1 + b - sqrterm1; // upper f[*Jcounter+1] = a2 + b - sqrterm2; // lower // J J[*Jcounter] = -(1-a1/sqrterm1); J[*Jcounter+1] = (1-a2/sqrterm2); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm1*sqrterm1*sqrterm1)); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm2*sqrterm2*sqrterm2)); (*Jcounter)++; (*Jcounter)++; } // Reactive power (Q) if (GEN_has_flags(gen,FLAG_BOUNDED,GEN_VAR_Q) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q)) { u = VEC_get(var_values,GEN_get_index_Q(gen,t)); umax = GEN_get_Q_max(gen); umin = GEN_get_Q_min(gen); du = (umax-umin > eps) ? umax-umin : eps; a1 = umax-u; a2 = u-umin; b = eps*eps/du; sqrterm1 = sqrt(a1*a1+b*b+eps*eps); sqrterm2 = sqrt(a2*a2+b*b+eps*eps); // f f[*Jcounter] = a1 + b - sqrterm1; // upper f[*Jcounter+1] = a2 + b - sqrterm2; // lower // J J[*Jcounter] = -(1-a1/sqrterm1); J[*Jcounter+1] = (1-a2/sqrterm2); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm1*sqrterm1*sqrterm1)); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm2*sqrterm2*sqrterm2)); (*Jcounter)++; (*Jcounter)++; } } // Shunts for (shunt = BUS_get_shunt(bus); shunt != NULL; shunt = SHUNT_get_next(shunt)) { // Susceptance if (SHUNT_has_flags(shunt,FLAG_BOUNDED,SHUNT_VAR_SUSC) && SHUNT_has_flags(shunt,FLAG_VARS,SHUNT_VAR_SUSC)) { u = VEC_get(var_values,SHUNT_get_index_b(shunt,t)); umax = SHUNT_get_b_max(shunt); umin = SHUNT_get_b_min(shunt); du = (umax-umin > eps) ? umax-umin : eps; a1 = umax-u; a2 = u-umin; b = eps*eps/du; sqrterm1 = sqrt(a1*a1+b*b+eps*eps); sqrterm2 = sqrt(a2*a2+b*b+eps*eps); // f f[*Jcounter] = a1 + b - sqrterm1; // upper f[*Jcounter+1] = a2 + b - sqrterm2; // lower // J J[*Jcounter] = -(1-a1/sqrterm1); J[*Jcounter+1] = (1-a2/sqrterm2); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm1*sqrterm1*sqrterm1)); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_d(H,0,-(b*b+eps*eps)/(sqrterm2*sqrterm2*sqrterm2)); (*Jcounter)++; (*Jcounter)++; } } } // Update counted flag bus_counted[bus_index_t[k]] = TRUE; } }
void CONSTR_BOUND_analyze_step(Constr* c, Branch* br, int t) { // Local variables Bus* buses[2]; Bus* bus; Gen* gen; Shunt* shunt; Mat* J; Mat* H_array; Mat* H; int* Hi; int* Hj; int* Hi_comb; int* Hj_comb; int* Jcounter; char* bus_counted; int bus_index_t[2]; int index_var; int k; int T; // Number of periods T = BRANCH_get_num_periods(br); // Constr data J = CONSTR_get_J(c); H_array = CONSTR_get_H_array(c); Jcounter = CONSTR_get_Jcounter_ptr(c); bus_counted = CONSTR_get_bus_counted(c); // Check pointers if (!Jcounter || !bus_counted) return; // Check outage if (BRANCH_is_on_outage(br)) return; // Bus data buses[0] = BRANCH_get_bus_from(br); buses[1] = BRANCH_get_bus_to(br); for (k = 0; k < 2; k++) bus_index_t[k] = BUS_get_index(buses[k])*T+t; // Branch //******* // Tap ratio if (BRANCH_has_flags(br,FLAG_BOUNDED,BRANCH_VAR_RATIO) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_RATIO)) { index_var = BRANCH_get_index_ratio(br,t); // J MAT_set_i(J,*Jcounter,*Jcounter); MAT_set_j(J,*Jcounter,index_var); MAT_set_i(J,*Jcounter+1,*Jcounter+1); MAT_set_j(J,*Jcounter+1,index_var); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); (*Jcounter)++; (*Jcounter)++; } // Phase shift if (BRANCH_has_flags(br,FLAG_BOUNDED,BRANCH_VAR_PHASE) && BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_PHASE)) { index_var = BRANCH_get_index_phase(br,t); // J MAT_set_i(J,*Jcounter,*Jcounter); MAT_set_j(J,*Jcounter,index_var); MAT_set_i(J,*Jcounter+1,*Jcounter+1); MAT_set_j(J,*Jcounter+1,index_var); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); (*Jcounter)++; (*Jcounter)++; } // Buses //****** for (k = 0; k < 2; k++) { bus = buses[k]; if (!bus_counted[bus_index_t[k]]) { // not counted yet // Voltage magnitude (V_MAG) if (BUS_has_flags(bus,FLAG_BOUNDED,BUS_VAR_VMAG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VMAG)) { index_var = BUS_get_index_v_mag(bus,t); // J MAT_set_i(J,*Jcounter,*Jcounter); MAT_set_j(J,*Jcounter,index_var); MAT_set_i(J,*Jcounter+1,*Jcounter+1); MAT_set_j(J,*Jcounter+1,index_var); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); (*Jcounter)++; (*Jcounter)++; } // Volage angle (V_ANG) if (BUS_has_flags(bus,FLAG_BOUNDED,BUS_VAR_VANG) && BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VANG)) { index_var = BUS_get_index_v_ang(bus,t); // J MAT_set_i(J,*Jcounter,*Jcounter); MAT_set_j(J,*Jcounter,index_var); MAT_set_i(J,*Jcounter+1,*Jcounter+1); MAT_set_j(J,*Jcounter+1,index_var); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); (*Jcounter)++; (*Jcounter)++; } // Generators for (gen = BUS_get_gen(bus); gen != NULL; gen = GEN_get_next(gen)) { // Active power (P) if (GEN_has_flags(gen,FLAG_BOUNDED,GEN_VAR_P) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_P)) { index_var = GEN_get_index_P(gen,t); // J MAT_set_i(J,*Jcounter,*Jcounter); MAT_set_j(J,*Jcounter,index_var); MAT_set_i(J,*Jcounter+1,*Jcounter+1); MAT_set_j(J,*Jcounter+1,index_var); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); (*Jcounter)++; (*Jcounter)++; } // Reactive power (Q) if (GEN_has_flags(gen,FLAG_BOUNDED,GEN_VAR_Q) && GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q)) { index_var = GEN_get_index_Q(gen,t); // J MAT_set_i(J,*Jcounter,*Jcounter); MAT_set_j(J,*Jcounter,index_var); MAT_set_i(J,*Jcounter+1,*Jcounter+1); MAT_set_j(J,*Jcounter+1,index_var); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); (*Jcounter)++; (*Jcounter)++; } } // Shunts for (shunt = BUS_get_shunt(bus); shunt != NULL; shunt = SHUNT_get_next(shunt)) { // Susceptance if (SHUNT_has_flags(shunt,FLAG_BOUNDED,SHUNT_VAR_SUSC) && SHUNT_has_flags(shunt,FLAG_VARS,SHUNT_VAR_SUSC)) { index_var = SHUNT_get_index_b(shunt,t); // J MAT_set_i(J,*Jcounter,*Jcounter); MAT_set_j(J,*Jcounter,index_var); MAT_set_i(J,*Jcounter+1,*Jcounter+1); MAT_set_j(J,*Jcounter+1,index_var); // H H = MAT_array_get(H_array,*Jcounter); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); H = MAT_array_get(H_array,*Jcounter+1); MAT_set_i(H,0,index_var); MAT_set_j(H,0,index_var); (*Jcounter)++; (*Jcounter)++; } } } // Update counted flag bus_counted[bus_index_t[k]] = TRUE; } // Done (last branch and period) if ((t == T-1) && (BRANCH_get_index(br) == NET_get_num_branches(CONSTR_get_network(c))-1)) { // Ensure lower triangular and save struct of H comb Hi_comb = MAT_get_row_array(CONSTR_get_H_combined(c)); Hj_comb = MAT_get_col_array(CONSTR_get_H_combined(c)); for (k = 0; k < CONSTR_get_H_array_size(c); k++) { Hi = MAT_get_row_array(MAT_array_get(H_array,k)); Hj = MAT_get_col_array(MAT_array_get(H_array,k)); Hi_comb[k] = Hi[0]; Hj_comb[k] = Hj[0]; } } }