Beispiel #1
0
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)++;
  } 
}
Beispiel #2
0
void HEUR_PVPQ_apply_step(Heur* h, Constr* clist, Net* net, Branch* br, int t, Vec* var_values) {

  // Local variables
  Vec* f;
  Mat* A;
  Vec* b;
  Bus* bus[2];
  Gen* gen;
  char* bus_counted;
  Heur_PVPQ_Data* data;
  char* reg_flag;
  int bus_index_t[2];
  int k;
  int i;
  Constr* pf;
  Constr* fix;
  REAL v;
  REAL v_set;
  REAL Q;
  REAL Qmax;
  REAL Qmin;
  char switch_flag;
  int j_old;
  int j_new;
  REAL b_new;
  int T;
  int num_buses;

  // Num periods
  T = BRANCH_get_num_periods(br);

  // Num buses
  num_buses = NET_get_num_buses(net);

  // Heur data
  bus_counted = HEUR_get_bus_counted(h);
  data = (Heur_PVPQ_Data*)HEUR_get_data(h);
  reg_flag = data->reg_flag;

  // Check outage
  if (BRANCH_is_on_outage(br))
    return;

  // Bus from data
  bus[0] = BRANCH_get_bus_k(br);
  bus_index_t[0] = BUS_get_index(bus[0])*T+t;

  // Bus to data
  bus[1] = BRANCH_get_bus_m(br);
  bus_index_t[1] = BUS_get_index(bus[1])*T+t;

  // Power flow constraints
  for (pf = clist; pf != NULL; pf = CONSTR_get_next(pf)) {
    if (strcmp(CONSTR_get_name(pf),"AC power balance") == 0)
      break;
  }
  if (!pf)
    return;

  // Fix constraints
  for (fix = clist; fix != NULL; fix = CONSTR_get_next(fix)) {
    if (strcmp(CONSTR_get_name(fix),"variable fixing") == 0)
      break;
  }
  if (!fix)
    return;

  // Constr data
  f = CONSTR_get_f(pf);
  A = CONSTR_get_A(fix);
  b = CONSTR_get_b(fix);

  // Buses
  for (k = 0; k < 2; k++) {

    if (!bus_counted[bus_index_t[k]] &&                   // not counted
	!BUS_is_slack(bus[k]) &&                          // not slack
	BUS_is_regulated_by_gen(bus[k]) &&                // regulated
	BUS_has_flags(bus[k],FLAG_VARS,BUS_VAR_VMAG) &&   // v mag is variable
	BUS_has_flags(bus[k],FLAG_FIXED,BUS_VAR_VMAG) &&  // v mag is fixed
	GEN_has_flags(BUS_get_reg_gen(bus[k]),FLAG_VARS,GEN_VAR_Q)) { // reg gen Q is variable

      // Voltage magnitude
      v = VEC_get(var_values,BUS_get_index_v_mag(bus[k],t));
      v_set = BUS_get_v_set(bus[k],t);

      // Regulating generator (first one in list of reg gens)
      gen = BUS_get_reg_gen(bus[k]);
      Q = VEC_get(var_values,GEN_get_index_Q(gen,t)); // per unit
      Qmax = GEN_get_Q_max(gen);                      // per unit
      Qmin = GEN_get_Q_min(gen);                      // per unit

      // Switch flag
      switch_flag = FALSE;

      // Currently regulated
      if (reg_flag[bus_index_t[k]]) {

	// Violations
	if (Q > Qmax) {

	  // Set data
	  j_old = BUS_get_index_v_mag(bus[k],t);
	  j_new = GEN_get_index_Q(gen,t);
	  b_new = Qmax;
	  switch_flag = TRUE;
	  reg_flag[bus_index_t[k]] = FALSE;

	  // Update vector of var values
	  while (gen) {
	    if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q))
	      VEC_set(var_values,GEN_get_index_Q(gen,t),GEN_get_Q_max(gen));
	    gen = GEN_get_reg_next(gen);
	  }
	}
	else if (Q < Qmin) {

	  // Set data
	  j_old = BUS_get_index_v_mag(bus[k],t);
	  j_new = GEN_get_index_Q(gen,t);
	  b_new = Qmin;
	  switch_flag = TRUE;
	  reg_flag[bus_index_t[k]] = FALSE;

	  // Update vector of var values
	  while (gen) {
	    if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q))
	      VEC_set(var_values,GEN_get_index_Q(gen,t),GEN_get_Q_min(gen));
	    gen = GEN_get_reg_next(gen);
	  }
	}
      }

      // Previously regulated
      else {

	// Q at Qmin and v < v_set
	if (fabs(Q-Qmin) < fabs(Q-Qmax) && v < v_set) {

	  Q = Q - VEC_get(f,BUS_get_index_Q(GEN_get_bus(gen))+t*2*num_buses); // per unit (see constr_PF)

	  if (Q >= Qmax) {

	    // Set data
	    j_old = GEN_get_index_Q(gen,t);
	    j_new = GEN_get_index_Q(gen,t);
	    b_new = Qmax;
	    switch_flag = TRUE;

	    // Update vector of var values
	    while (gen) {
	      if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q))
		VEC_set(var_values,GEN_get_index_Q(gen,t),GEN_get_Q_max(gen));
	      gen = GEN_get_reg_next(gen);
	    }
	  }
	  else if (Qmin < Q && Q < Qmax) {

	    // Set data
	    j_old = GEN_get_index_Q(gen,t);
	    j_new = BUS_get_index_v_mag(bus[k],t);
	    b_new = v_set;
	    switch_flag = TRUE;
	    reg_flag[bus_index_t[k]] = TRUE;

	    // Udpate vector of var values
	    VEC_set(var_values,j_new,b_new);
	  }
	}

	// Q at Qmax and v > v_set
	else if (fabs(Q-Qmax) < fabs(Q-Qmin) && v > v_set) {

	  Q = Q - VEC_get(f,BUS_get_index_Q(GEN_get_bus(gen))+t*2*num_buses); // per unit (see constr_PF)

	  if (Q <= Qmin) {

	    // Set data
	    j_old = GEN_get_index_Q(gen,t);
	    j_new = GEN_get_index_Q(gen,t);
	    b_new = Qmin;
	    switch_flag = TRUE;

	    // Update vector of var values
	    while (gen) {
	      if (GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q))
		VEC_set(var_values,GEN_get_index_Q(gen,t),GEN_get_Q_min(gen));
	      gen = GEN_get_reg_next(gen);
	    }
	  }
	  else if (Qmin < Q && Q < Qmax) {

	    // Set data
	    j_old = GEN_get_index_Q(gen,t);
	    j_new = BUS_get_index_v_mag(bus[k],t);
	    b_new = v_set;
	    switch_flag = TRUE;
	    reg_flag[bus_index_t[k]] = TRUE;

	    // Udpate vector of var values
	    VEC_set(var_values,j_new,b_new);
	  }
	}
      }

      // Update fix constraints
      if (switch_flag) {
	for (i = 0; i < MAT_get_nnz(A); i++) {
	  if (MAT_get_j(A,i) == j_old)
	    MAT_set_d(A,i,0.);
	  if (MAT_get_j(A,i) == j_new) {
	    MAT_set_d(A,i,1.);
	    VEC_set(b,MAT_get_i(A,i),b_new);
	  }
	}
      }
    }

    // Update counted flag
    bus_counted[bus_index_t[k]] = TRUE;
  }
}
Beispiel #3
0
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* A_nnz;
  int* A_row;
  char* bus_counted;
  int i;
  int T;

  // Number of periods
  T = BRANCH_get_num_periods(br);

  // Constr data
  A_nnz = CONSTR_get_A_nnz_ptr(c);
  A_row = CONSTR_get_A_row_ptr(c);
  bus_counted = CONSTR_get_bus_counted(c);

  // Check pointers
  if (!A_nnz || !A_row || !bus_counted)
    return;

  // Check outage
  if (BRANCH_is_on_outage(br))
    return;

  // Bus data
  buses[0] = BRANCH_get_bus_k(br);
  buses[1] = BRANCH_get_bus_m(br);

  // Tap ratio
  if (BRANCH_has_flags(br,FLAG_FIXED,BRANCH_VAR_RATIO) &&
      BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_RATIO)) {
    (*A_nnz)++;
    (*A_row)++;
  }

  // Phase shift
  if (BRANCH_has_flags(br,FLAG_FIXED,BRANCH_VAR_PHASE) &&
      BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_PHASE)) {
    (*A_nnz)++;
    (*A_row)++;
  }

  // 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)) {
	(*A_nnz)++;

	// 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))
	  (*A_nnz)++;

	(*A_row)++;
      }

      // Voltage angle (V_ANG)
      if (BUS_has_flags(bus,FLAG_FIXED,BUS_VAR_VANG) &&
	  BUS_has_flags(bus,FLAG_VARS,BUS_VAR_VANG)) {
	(*A_nnz)++;
	(*A_row)++;
      }

      // 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)) {
	  (*A_nnz)++;
	  (*A_row)++;
	}

	// Reactive power (Q)
	if (GEN_has_flags(gen,FLAG_FIXED,GEN_VAR_Q) &&
	    GEN_has_flags(gen,FLAG_VARS,GEN_VAR_Q)) {
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }

      // 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)) {
	  (*A_nnz)++;
	  (*A_row)++;
	}

	// Reactive power (Q)
	if (VARGEN_has_flags(vargen,FLAG_FIXED,VARGEN_VAR_Q) &&
	    VARGEN_has_flags(vargen,FLAG_VARS,VARGEN_VAR_Q)) {
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }

      // 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)) {
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }

      // 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)) {
	  (*A_nnz) += 2;
	  (*A_row) += 2;
	}

	// Energy level (E)
	if (BAT_has_flags(bat,FLAG_FIXED,BAT_VAR_E) &&
	    BAT_has_flags(bat,FLAG_VARS,BAT_VAR_E)) {
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }

      // 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)) {
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }
    }

    // Update counted flag
    bus_counted[BUS_get_index(bus)*T+t] = TRUE;
  }
}
Beispiel #4
0
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* A_nnz;
  int* A_row;
  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);
  A_nnz = CONSTR_get_A_nnz_ptr(c);
  A_row = CONSTR_get_A_row_ptr(c);
  bus_counted = CONSTR_get_bus_counted(c);

  // Check pointers
  if (!A_nnz || !A_row || !bus_counted)
    return;

  // Check outage
  if (BRANCH_is_on_outage(br))
    return;

  // Bus data
  buses[0] = BRANCH_get_bus_k(br);
  buses[1] = BRANCH_get_bus_m(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,*A_row,BRANCH_get_ratio(br,t));
    MAT_set_i(A,*A_nnz,*A_row);
    MAT_set_j(A,*A_nnz,BRANCH_get_index_ratio(br,t));
    MAT_set_d(A,*A_nnz,1.);
    (*A_nnz)++;
    (*A_row)++;
  }

  // Phase shift
  if (BRANCH_has_flags(br,FLAG_FIXED,BRANCH_VAR_PHASE) &&
      BRANCH_has_flags(br,FLAG_VARS,BRANCH_VAR_PHASE)) {
    VEC_set(b,*A_row,BRANCH_get_phase(br,t));
    MAT_set_i(A,*A_nnz,*A_row);
    MAT_set_j(A,*A_nnz,BRANCH_get_index_phase(br,t));
    MAT_set_d(A,*A_nnz,1.);
    (*A_nnz)++;
    (*A_row)++;
  }

  // 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,*A_row,BUS_get_v_set(bus,t));
	else
	  VEC_set(b,*A_row,BUS_get_v_mag(bus,t));
	MAT_set_i(A,*A_nnz,*A_row);
	MAT_set_j(A,*A_nnz,BUS_get_index_v_mag(bus,t));
	MAT_set_d(A,*A_nnz,1.);
	(*A_nnz)++;

	// 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,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,GEN_get_index_Q(BUS_get_reg_gen(bus),t));
	  MAT_set_d(A,*A_nnz,0.); // placeholder
	  (*A_nnz)++;
	}

	(*A_row)++;
      }

      // 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,*A_row,BUS_get_v_ang(bus,t));
	MAT_set_i(A,*A_nnz,*A_row);
	MAT_set_j(A,*A_nnz,BUS_get_index_v_ang(bus,t));
	MAT_set_d(A,*A_nnz,1.);
	(*A_nnz)++;
	(*A_row)++;
      }

      // 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,*A_row,GEN_get_P(gen,t));
	  MAT_set_i(A,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,GEN_get_index_P(gen,t));
	  MAT_set_d(A,*A_nnz,1.);
	  (*A_nnz)++;
	  (*A_row)++;
	}

	// 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,*A_row,GEN_get_Q(gen,t));
	  MAT_set_i(A,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,GEN_get_index_Q(gen,t));
	  MAT_set_d(A,*A_nnz,1.);
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }

      // 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,*A_row,VARGEN_get_P(vargen,t));
	  MAT_set_i(A,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,VARGEN_get_index_P(vargen,t));
	  MAT_set_d(A,*A_nnz,1.);
	  (*A_nnz)++;
	  (*A_row)++;
	}

	// 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,*A_row,VARGEN_get_Q(vargen,t));
	  MAT_set_i(A,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,VARGEN_get_index_Q(vargen,t));
	  MAT_set_d(A,*A_nnz,1.);
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }

      // 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,*A_row,SHUNT_get_b(shunt,t));
	  MAT_set_i(A,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,SHUNT_get_index_b(shunt,t));
	  MAT_set_d(A,*A_nnz,1.);
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }

      // 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,*A_row,Pc);
	  MAT_set_i(A,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,BAT_get_index_Pc(bat,t));
	  MAT_set_d(A,*A_nnz,1.);
	  (*A_nnz)++;
	  (*A_row)++;

	  // Pd
	  VEC_set(b,*A_row,Pd);
	  MAT_set_i(A,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,BAT_get_index_Pd(bat,t));
	  MAT_set_d(A,*A_nnz,1.);
	  (*A_nnz)++;
	  (*A_row)++;
	}

	// 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,*A_row,BAT_get_E(bat,t));
	  MAT_set_i(A,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,BAT_get_index_E(bat,t));
	  MAT_set_d(A,*A_nnz,1.);
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }

      // 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,*A_row,LOAD_get_P(load,t));
	  MAT_set_i(A,*A_nnz,*A_row);
	  MAT_set_j(A,*A_nnz,LOAD_get_index_P(load,t));
	  MAT_set_d(A,*A_nnz,1.);
	  (*A_nnz)++;
	  (*A_row)++;
	}
      }
    }

    // Update counted flag
    bus_counted[BUS_get_index(bus)*T+t] = TRUE;
  }
}
Beispiel #5
0
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));
  }
}
Beispiel #6
0
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;
  }
}
Beispiel #7
0
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;
  }
}
Beispiel #8
0
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];
    }
  }
}