Ejemplo n.º 1
0
void CONSTR_DC_FLOW_LIM_store_sens_branch(Constr* c, Branch* br, Vec* sA, Vec* sf, Vec* sGu, Vec* sGl) {
  
  // Store sensitivies
  BRANCH_set_sens_P_u_bound(br,VEC_get(sGu,BRANCH_get_index(br)));
  BRANCH_set_sens_P_l_bound(br,VEC_get(sGl,BRANCH_get_index(br)));
}
Ejemplo n.º 2
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));
  }
}
Ejemplo n.º 3
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];
    }
  }
}