// Initialize a distribution meter, return 1 on success int meter::init(OBJECT *parent) { if(power_market != 0){ price_prop = gl_get_property(power_market, "current_market.clearing_price"); if(price_prop == 0){ GL_THROW("meter::power_market object \'%s\' does not publish \'current_market.clearing_price\'", (power_market->name ? power_market->name : "(anon)")); } } // Count the number of phases...for use with meter_power_consumption if (meter_power_consumption != complex(0,0)) { no_phases = 0; if (has_phase(PHASE_A)) no_phases += 1; if (has_phase(PHASE_B)) no_phases += 1; if (has_phase(PHASE_C)) no_phases += 1; } check_prices(); last_t = dt = 0; return node::init(parent); }
TIMESTAMP meter::sync(TIMESTAMP t0) { //Luca Meschiari Test- Start //printf("meter sync ||| "); //Luca Meschiari Test- End // Luca Meschiari Test - Start //printf("--- %f ---", proj_power); // Luca Meschiari Test - Start int TempNodeRef; //Reliability check if ((NR_mode == false) && (fault_check_object != NULL) && (solver_method == SM_NR)) //solver cycle and fault_check is present (so might need to set flag { if (NR_node_reference==-99) //Childed { TempNodeRef=*NR_subnode_reference; } else //Normal { //Just assign it to our normal index TempNodeRef=NR_node_reference; } if ((NR_busdata[TempNodeRef].origphases & NR_busdata[TempNodeRef].phases) != NR_busdata[TempNodeRef].origphases) //We have a phase mismatch - something has been lost { meter_interrupted = true; //Someone is out of service, they just may not know it //See if we're flagged for a momentary as well - if we are, clear it if (meter_interrupted_secondary == true) meter_interrupted_secondary = false; } else { meter_interrupted = false; //All is well } } if (meter_power_consumption != complex(0,0)) { if (has_phase(PHASE_A)) power[0] += meter_power_consumption / no_phases; if (has_phase(PHASE_B)) power[1] += meter_power_consumption / no_phases; if (has_phase(PHASE_C)) power[2] += meter_power_consumption / no_phases; } return node::sync(t0); }
int relay::init(OBJECT *parent) { int result = link::init(parent); if (recloser_limit == 0) { recloser_limit = 5; gl_warning("Recloser:%d tries limit was not specified, defaulted to 5 tries",OBJECTHDR(this)->id); /* TROUBLESHOOT The recloser did not have a specified value for the maximum number of recloser tries. 5 was selected as a default value. */ } if (recloser_delay == 0) { recloser_delay = 3; gl_warning("Recloser:%d reclose delay was not specified, defaulted to 3 seconds",OBJECTHDR(this)->id); /* TROUBLESHOOT The recloser did not have a specified value for the recloser try delay. 3 was selected as a default value. */ } if (recloser_delay<1.0) { GL_THROW("recloser delay must be at least 1 second"); /* TROUBLESHOOT The recloser delay must be at least one second long. Please set the value of recloser_delay to something greater than or equal to 1.0. */ } a_mat[0][0] = d_mat[0][0] = A_mat[0][0] = (link::is_closed() && has_phase(PHASE_A) ? 1.0 : 0.0); a_mat[1][1] = d_mat[1][1] = A_mat[1][1] = (link::is_closed() && has_phase(PHASE_B) ? 1.0 : 0.0); a_mat[2][2] = d_mat[2][2] = A_mat[2][2] = (link::is_closed() && has_phase(PHASE_C) ? 1.0 : 0.0); b_mat[0][0] = c_mat[0][0] = B_mat[0][0] = 0.0; b_mat[1][1] = c_mat[1][1] = B_mat[1][1] = 0.0; b_mat[2][2] = c_mat[2][2] = B_mat[2][2] = 0.0; return result; }
//Functionalized portion for deltamode compatibility void meter::BOTH_meter_sync_fxn() { int TempNodeRef; //Reliability check if ((fault_check_object != NULL) && (solver_method == SM_NR)) //proper solver and fault_object isn't null - may need to set a flag { if (NR_node_reference==-99) //Childed { TempNodeRef=*NR_subnode_reference; } else //Normal { //Just assign it to our normal index TempNodeRef=NR_node_reference; } if ((NR_busdata[TempNodeRef].origphases & NR_busdata[TempNodeRef].phases) != NR_busdata[TempNodeRef].origphases) //We have a phase mismatch - something has been lost { meter_interrupted = true; //Someone is out of service, they just may not know it //See if we're flagged for a momentary as well - if we are, clear it if (meter_interrupted_secondary == true) meter_interrupted_secondary = false; } else { meter_interrupted = false; //All is well } } if (meter_power_consumption != complex(0,0)) { if (has_phase(PHASE_A)) power[0] += meter_power_consumption / no_phases; if (has_phase(PHASE_B)) power[1] += meter_power_consumption / no_phases; if (has_phase(PHASE_C)) power[2] += meter_power_consumption / no_phases; } }
int triplex_node::init(OBJECT *parent) { if ( !(has_phase(PHASE_S)) ) { OBJECT *obj = OBJECTHDR(this); gl_warning("Init() triplex_node (name:%s, id:%d): Phases specified did not include phase S. Adding phase S.", obj->name,obj->id); /* TROUBLESHOOT Triplex nodes and meters require a single phase and a phase S component (for split-phase). This particular triplex object did not include it, so it is being added. */ phases = (phases | PHASE_S); } if ((pub_shunt[0] == 0) && (impedance[0] != 0)) shunt[0] = complex(1.0,0)/impedance[0]; if ((pub_shunt[1] == 0) && (impedance[1] != 0)) shunt[1] = complex(1.0,0)/impedance[1]; if ((pub_shunt[2] == 0) && (impedance[2] != 0)) shunt[2] = complex(1.0,0)/impedance[2]; return node::init(parent); }
int powerflow_object::init(OBJECT *parent) { /* unspecified phase inherits from parent, if any */ if (parent && gl_object_isa(parent,"powerflow_object")) { powerflow_object *pParent = OBJECTDATA(parent,powerflow_object); if (phases==NO_PHASE) phases = pParent->phases; } /* no phase info */ if (phases==0) throw "phases not specified"; /* split connection must connect to a phase */ if (has_phase(PHASE_S) && !(has_phase(PHASE_A) || has_phase(PHASE_B) || has_phase(PHASE_C))) throw "split connection is missing A,B, or C phase connection"; /* split connection must connect to only one phase */ if (has_phase(PHASE_S) && ( (has_phase(PHASE_A) && has_phase(PHASE_B)) || (has_phase(PHASE_B) && has_phase(PHASE_C)) || (has_phase(PHASE_C) && has_phase(PHASE_A)))) throw "split connection is connected to two phases simultaneously"; /* split connection is not permitted with delta connection */ if (has_phase(PHASE_S) && has_phase(PHASE_D)) throw "split and delta connection cannot occur simultaneously"; /* split connection is not permitted on neutral */ if (has_phase(PHASE_N) && has_phase(PHASE_S)) { gl_warning("neutral phase ignored on split connection."); phases ^= PHASE_N; } return 1; }
//Function to perform actual fuse sync calls (changes, etc.) - functionalized since essentially used in //reliability calls as well, so need to make sure the two call points are consistent void fuse::fuse_sync_function(void) { unsigned char pres_status; if (solver_method==SM_NR) //Newton-Raphson checks { pres_status = 0x00; //Reset individual status indicator - assumes all start open if (status == LS_OPEN) //Fully opened means all go open { From_Y[0][0] = complex(0.0,0.0); From_Y[1][1] = complex(0.0,0.0); From_Y[2][2] = complex(0.0,0.0); phase_A_state = phase_B_state = phase_C_state = BLOWN; //All open NR_branchdata[NR_branch_reference].phases &= 0xF0; //Remove all our phases } else //Closed means a phase-by-phase basis { if (has_phase(PHASE_A)) { if (phase_A_state == GOOD) { From_Y[0][0] = complex(1/fuse_resistance,1/fuse_resistance); pres_status |= 0x04; NR_branchdata[NR_branch_reference].phases |= 0x04; //Ensure we're set } else //Must be open { From_Y[0][0] = complex(0.0,0.0); NR_branchdata[NR_branch_reference].phases &= 0xFB; //Make sure we're removed } } if (has_phase(PHASE_B)) { if (phase_B_state == GOOD) { From_Y[1][1] = complex(1/fuse_resistance,1/fuse_resistance); pres_status |= 0x02; NR_branchdata[NR_branch_reference].phases |= 0x02; //Ensure we're set } else //Must be open { From_Y[1][1] = complex(0.0,0.0); NR_branchdata[NR_branch_reference].phases &= 0xFD; //Make sure we're removed } } if (has_phase(PHASE_C)) { if (phase_C_state == GOOD) { From_Y[2][2] = complex(1/fuse_resistance,1/fuse_resistance); pres_status |= 0x01; NR_branchdata[NR_branch_reference].phases |= 0x01; //Ensure we're set } else //Must be open { From_Y[2][2] = complex(0.0,0.0); NR_branchdata[NR_branch_reference].phases &= 0xFE; //Make sure we're removed } } } //Check status before running sync (since it will clear it) if ((status != prev_status) || (pres_status != prev_full_status)) { LOCK_OBJECT(NR_swing_bus); //Lock SWING since we'll be modifying this NR_admit_change = true; //Flag an admittance change UNLOCK_OBJECT(NR_swing_bus); //Finished } prev_full_status = pres_status; //Update the status flags }//end SM_NR }
/** * Object initialization is called once after all object have been created * * @param parent a pointer to this object's parent * @return 1 on success, 0 on error */ int fuse::init(OBJECT *parent) { char jindex, kindex; OBJECT *obj = OBJECTHDR(this); if ((phases & PHASE_S) == PHASE_S) { GL_THROW("fuses cannot be placed on triplex circuits"); /* TROUBLESHOOT Fuses do not currently support triplex circuits. Please place the fuse higher upstream in the three-phase power area or utilize another object (such as a circuit breaker in a house model) to limit the current flow. */ } //Special flag moved to be universal for all solvers - mainly so phase checks catch it now SpecialLnk = SWITCH; int result = link_object::init(parent); //Check current limit if (current_limit < 0.0) { GL_THROW("fuse:%s has a negative current limit value!",obj->name); /* TROUBLESHOOT The fuse has a negative value current limit specified. Please specify a positive value for the current and try again. */ } if (current_limit == 0.0) { current_limit = 9999.0; //Set to arbitrary large value gl_warning("fuse:%s has a zero current limit - set to 9999.9 Amps",obj->name); /* TROUBLESHOOT A fuse somehow had a current limit of 0.0 Amps set. This is invalid, so a placeholder value of 9999.0 Amps is used. Please adjust this value accordingly. */ } if (mean_replacement_time<=0.0) //Make sure the time makes sense { gl_warning("Fuse:%s has a negative or 0 mean replacement time - defaulting to 1 hour",obj->name); /* TROUBLESHOOT A fuse has a negative or zero time specified for mean_replacement_time. The value has therefore been overridden to 1 hour. If this is unacceptable, please change the value in your GLM file. */ mean_replacement_time = 3600.0; } //Set mean_repair_time to the same value mean_repair_time = mean_replacement_time; if (solver_method==SM_FBS) { gl_warning("Fuses only work for the attached node in the FBS solver, not any deeper."); /* TROUBLESHOOT Under the Forward-Back sweep method, fuses can only affect their directly attached downstream node. Due to the nature of the FBS algorithm, nodes further downstream (especially constant current loads) will cause an oscillatory nature in the voltage and current injections, so they will no longer be accurate. Either ignore these values or figure out a way to work around this limitation (player objects). */ } //check the fuse resistance value to see that it is not zero if (solver_method == SM_NR){ if(fuse_resistance == 0.0){ gl_warning("Fuse:%s fuse_resistance has been set to zero. This will result singular matrix. Setting to the global default.",obj->name); /* TROUBLESHOOT Under Newton-Raphson solution method the impedance matrix cannot be a singular matrix for the inversion process. Change the value of fuse_resistance to something small but larger that zero. */ } if(fuse_resistance < 0.0){ fuse_resistance = default_resistance; } } //Initialize matrices for (jindex=0;jindex<3;jindex++) { for (kindex=0;kindex<3;kindex++) { a_mat[jindex][kindex] = d_mat[jindex][kindex] = A_mat[jindex][kindex] = 0.0; c_mat[jindex][kindex] = 0.0; B_mat[jindex][kindex] = b_mat[jindex][kindex] = 0.0; } } a_mat[0][0] = d_mat[0][0] = A_mat[0][0] = (is_closed() && has_phase(PHASE_A) ? 1.0 : 0.0); a_mat[1][1] = d_mat[1][1] = A_mat[1][1] = (is_closed() && has_phase(PHASE_B) ? 1.0 : 0.0); a_mat[2][2] = d_mat[2][2] = A_mat[2][2] = (is_closed() && has_phase(PHASE_C) ? 1.0 : 0.0); if (solver_method==SM_FBS) { b_mat[0][0] = c_mat[0][0] = B_mat[0][0] = 0.0; b_mat[1][1] = c_mat[1][1] = B_mat[1][1] = 0.0; b_mat[2][2] = c_mat[2][2] = B_mat[2][2] = 0.0; } else if (solver_method==SM_NR) { //Flagged it as special (we'll forgo inversion processes on this) //Initialize off-diagonals just in case From_Y[0][1] = From_Y[0][2] = From_Y[1][0] = 0.0; From_Y[1][2] = From_Y[2][0] = From_Y[2][1] = 0.0; if (status==LS_OPEN) //Take this as all should be open { From_Y[0][0] = complex(0.0,0.0); From_Y[1][1] = complex(0.0,0.0); From_Y[2][2] = complex(0.0,0.0); phase_A_state = phase_B_state = phase_C_state = BLOWN; //All open prev_full_status = 0x00; //Confirm here } else //LS_CLOSED - handle individually { if (has_phase(PHASE_A)) { if (phase_A_state == GOOD) { From_Y[0][0] = complex(1/fuse_resistance,1/fuse_resistance); prev_full_status |= 0x04; } else //Must be open { From_Y[0][0] = complex(0.0,0.0); prev_full_status &=0xFB; } } if (has_phase(PHASE_B)) { if (phase_B_state == GOOD) { From_Y[1][1] = complex(1/fuse_resistance,1/fuse_resistance); prev_full_status |= 0x02; } else //Must be open { From_Y[1][1] = complex(0.0,0.0); prev_full_status &=0xFD; } } if (has_phase(PHASE_C)) { if (phase_C_state == GOOD) { From_Y[2][2] = complex(1/fuse_resistance,1/fuse_resistance); prev_full_status |= 0x01; } else //Must be open { From_Y[2][2] = complex(0.0,0.0); prev_full_status &=0xFE; } } } } else { GL_THROW("Fuses are not supported by this solver method"); /* TROUBLESHOOT Fuses are currently only supported in Forward-Back Sweep and Newton-Raphson Solvers. Using them in other solvers is untested and may provide erroneous answers (if any at all). */ } //Store fuse status - will get updated as things change later phased_fuse_status = prev_full_status; return result; }
static int gravity_check_input( const ecl_grid_type * ecl_grid , const ecl_file_type * init_file , const ecl_file_type * restart_file1, const ecl_file_type * restart_file2, int * __model_phases, int * __file_phases) { { int model_phases = 0; int file_phases = 0; /* Check which phases are present in the model */ if (ecl_file_has_kw(restart_file1 , "OIL_DEN")) { model_phases += OIL; simulator = ECLIPSE100 ; } else if (ecl_file_has_kw(restart_file1 , "DENO")) { model_phases += OIL; simulator = ECLIPSE300 ; } ; if (ecl_file_has_kw(restart_file1 , "WAT_DEN")) { model_phases += WATER; simulator = ECLIPSE100 ; } else if (ecl_file_has_kw(restart_file1 , "DENW")) { model_phases += WATER; simulator = ECLIPSE300 ; } ; if (ecl_file_has_kw(restart_file1 , "GAS_DEN")) { model_phases += GAS; simulator = ECLIPSE100 ; } else if (ecl_file_has_kw(restart_file1 , "DENG")) { model_phases += GAS; simulator = ECLIPSE300 ; } ; /* Check which phases are present in the restart files. We assume the restart file NEVER has SOIL information */ if (ecl_file_has_kw(restart_file1 , "SWAT")) file_phases += WATER; if (ecl_file_has_kw(restart_file1 , "SGAS")) file_phases += GAS; /* Consiency check */ { /** The following assumptions are made: 1. All restart files should have water, i.e. the SWAT keyword. 2. All phases present in the restart file should also be present as densities, in addition the model must contain one additional phase. 3. The restart files can never contain oil saturation. */ if ( !has_phase( file_phases , WATER ) ) util_exit("Could not locate SWAT keyword in restart files\n"); if ( has_phase( file_phases , OIL )) util_exit("Can not handle restart files with SOIL keyword\n"); if (! has_phase( model_phases , WATER ) ) util_exit("Could not locate WAT_DEN keyword in restart files\n"); if ( has_phase( file_phases , GAS )) { /** Restart file has both water and gas - means we need all three densities. */ if (! (has_phase( model_phases , GAS) && has_phase( model_phases , OIL))) util_exit("Could not find GAS_DEN and OIL_DEN keywords in restart files\n"); } else { /* This is (water + oil) or (water + gas) system. We enforce one of the densities.*/ if ( !has_phase( model_phases , GAS + OIL)) util_exit("Could not find either GAS_DEN or OIL_DEN kewyords in restart files\n"); } } *__model_phases = model_phases; *__file_phases = file_phases; } /* Check that the restart files have RPORV information. This is ensured by giving the argument RPORV to the RPTRST keyword. */ if ( !(ecl_file_has_kw( restart_file1 , "RPORV") && ecl_file_has_kw( restart_file2 , "RPORV")) ) util_exit("Sorry: the restartfiles do not contain RPORV\n"); /** Check that the rporv values are in the right ballpark. For ECLIPSE version 2008.2 they are way f*****g off. Check PORV versus RPORV for ten 'random' locations in the grid. */ { const ecl_kw_type * rporv1_kw = ecl_file_iget_named_kw( restart_file1 , "RPORV" , 0); const ecl_kw_type * rporv2_kw = ecl_file_iget_named_kw( restart_file2 , "RPORV" , 0); const ecl_kw_type * init_porv_kw = ecl_file_iget_named_kw( init_file , "PORV" , 0); int active_index; int active_delta; int active_size; ecl_grid_get_dims( ecl_grid , NULL , NULL , NULL , &active_size ); active_delta = active_size / 12; for (active_index = active_delta; active_index < active_size; active_index += active_delta) { int global_index = ecl_grid_get_global_index1A( ecl_grid , active_index ); double init_porv = ecl_kw_iget_as_double( init_porv_kw , global_index ); /* NB - this uses global indexing. */ double rporv1 = ecl_kw_iget_as_double( rporv1_kw , active_index ); double rporv2 = ecl_kw_iget_as_double( rporv2_kw , active_index ); double rporv12 = 0.5 * ( rporv1 + rporv2 ); double fraction = util_double_min( init_porv , rporv12 ) / util_double_max( init_porv , rporv12 ); if (fraction < 0.50) { fprintf(stderr,"-----------------------------------------------------------------\n"); fprintf(stderr,"INIT PORV: %g \n",init_porv); fprintf(stderr,"RPORV1 : %g \n",rporv1); fprintf(stderr,"RPORV2 : %g \n",rporv2); fprintf(stderr,"Hmmm - the RPORV values extracted from the restart file seem to be \n"); fprintf(stderr,"veeery different from the initial rporv value. This might indicated\n"); fprintf(stderr,"an ECLIPSE bug. Version 2007.2 is known to be ok in this respect, \n"); fprintf(stderr,"whereas version 2008.2 is known to have a bug. \n"); fprintf(stderr,"-----------------------------------------------------------------\n"); exit(1); } } } return 0; }
//Function to perform actual switch sync calls (changes, etc.) - functionalized since essentially used in //reliability calls as well, so need to make sure the two call points are consistent void switch_object::switch_sync_function(void) { unsigned char pres_status; double phase_total, switch_total; pres_status = 0x00; //Reset individual status indicator - assumes all start open if (switch_banked_mode == BANKED_SW) //Banked mode { if (status == prev_status) { //Banked mode is operated by majority rule. If the majority are a different state, all become that state phase_total = (double)(has_phase(PHASE_A) + has_phase(PHASE_B) + has_phase(PHASE_C)); //See how many switches we have switch_total = 0.0; if (has_phase(PHASE_A) && (phase_A_state == CLOSED)) switch_total += 1.0; if (has_phase(PHASE_B) && (phase_B_state == CLOSED)) switch_total += 1.0; if (has_phase(PHASE_C) && (phase_C_state == CLOSED)) switch_total += 1.0; switch_total /= phase_total; if (switch_total > 0.5) //In two switches, a stalemate occurs. We'll consider this a "maintain status quo" state { status = LS_CLOSED; //If it wasn't here, it is now phase_A_state = phase_B_state = phase_C_state = CLOSED; //Set all to closed - phase checks will sort it out } else //Minority or stalemate { if (switch_total == 0.5) //Stalemate { if (status == LS_OPEN) //These check assume phase_X_state will be manipulated, not status { phase_A_state = phase_B_state = phase_C_state = OPEN; } else //Closed { phase_A_state = phase_B_state = phase_C_state = CLOSED; } } else //Not stalemate - open all { status = LS_OPEN; phase_A_state = phase_B_state = phase_C_state = OPEN; //Set all to open - phase checks will sort it out } } }//End status is same else //Not the same - force the inputs { if (status==LS_OPEN) phase_A_state = phase_B_state = phase_C_state = OPEN; //Flag all as open else phase_A_state = phase_B_state = phase_C_state = CLOSED; //Flag all as closed }//End not same if (status==LS_OPEN) { if (has_phase(PHASE_A)) { if (solver_method == SM_NR) { From_Y[0][0] = complex(0.0,0.0); //Update admittance a_mat[0][0] = 0.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[0][0] = 0.0; NR_branchdata[NR_branch_reference].phases &= 0xFB; //Remove this bit } else //Assume FBS { A_mat[0][0] = 0.0; d_mat[0][0] = 0.0; } } if (has_phase(PHASE_B)) { if (solver_method == SM_NR) { From_Y[1][1] = complex(0.0,0.0); //Update admittance a_mat[1][1] = 0.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[1][1] = 0.0; NR_branchdata[NR_branch_reference].phases &= 0xFD; //Remove this bit } else { A_mat[1][1] = 0.0; d_mat[1][1] = 0.0; } } if (has_phase(PHASE_C)) { if (solver_method == SM_NR) { From_Y[2][2] = complex(0.0,0.0); //Update admittance a_mat[2][2] = 0.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[2][2] = 0.0; NR_branchdata[NR_branch_reference].phases &= 0xFE; //Remove this bit } else { A_mat[2][2] = 0.0; d_mat[2][2] = 0.0; } } }//end open else //Must be closed then { if (has_phase(PHASE_A)) { pres_status |= 0x04; //Flag as closed if (solver_method == SM_NR) { From_Y[0][0] = complex(1/switch_resistance,1/switch_resistance); //Update admittance a_mat[0][0] = 1.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[0][0] = 1.0; NR_branchdata[NR_branch_reference].phases |= 0x04; //Ensure we're set } else //Assumed FBS { A_mat[0][0] = 1.0; d_mat[0][0] = 1.0; } } if (has_phase(PHASE_B)) { pres_status |= 0x02; //Flag as closed if (solver_method == SM_NR) { From_Y[1][1] = complex(1/switch_resistance,1/switch_resistance); //Update admittance a_mat[1][1] = 1.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[1][1] = 1.0; NR_branchdata[NR_branch_reference].phases |= 0x02; //Ensure we're set } else { A_mat[1][1] = 1.0; d_mat[1][1] = 1.0; } } if (has_phase(PHASE_C)) { pres_status |= 0x01; //Flag as closed if (solver_method == SM_NR) { From_Y[2][2] = complex(1/switch_resistance,1/switch_resistance); //Update admittance a_mat[2][2] = 1.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[2][2] = 1.0; NR_branchdata[NR_branch_reference].phases |= 0x01; //Ensure we're set } else { A_mat[2][2] = 1.0; d_mat[2][2] = 1.0; } } }//end closed }//End banked mode else //Individual mode { if (status == LS_OPEN) //Fully opened means all go open { phase_A_state = phase_B_state = phase_C_state = OPEN; //All open if (solver_method == SM_NR) { From_Y[0][0] = complex(0.0,0.0); From_Y[1][1] = complex(0.0,0.0); From_Y[2][2] = complex(0.0,0.0); NR_branchdata[NR_branch_reference].phases &= 0xF0; //Remove all our phases } else //Assumed FBS { A_mat[0][0] = 0.0; A_mat[1][1] = 0.0; A_mat[2][2] = 0.0; d_mat[0][0] = 0.0; d_mat[1][1] = 0.0; d_mat[2][2] = 0.0; } } else //Closed means a phase-by-phase basis { if (has_phase(PHASE_A)) { if (phase_A_state == CLOSED) { pres_status |= 0x04; if (solver_method == SM_NR) { From_Y[0][0] = complex(1/switch_resistance,1/switch_resistance); NR_branchdata[NR_branch_reference].phases |= 0x04; //Ensure we're set a_mat[0][0] = 1.0; d_mat[0][0] = 1.0; } else //Assumed FBS { A_mat[0][0] = 1.0; d_mat[0][0] = 1.0; } } else //Must be open { if (solver_method == SM_NR) { From_Y[0][0] = complex(0.0,0.0); NR_branchdata[NR_branch_reference].phases &= 0xFB; //Make sure we're removed a_mat[0][0] = 0.0; d_mat[0][0] = 0.0; } else { A_mat[0][0] = 0.0; d_mat[0][0] = 0.0; } } } if (has_phase(PHASE_B)) { if (phase_B_state == CLOSED) { pres_status |= 0x02; if (solver_method == SM_NR) { From_Y[1][1] = complex(1/switch_resistance,1/switch_resistance); NR_branchdata[NR_branch_reference].phases |= 0x02; //Ensure we're set a_mat[1][1] = 1.0; d_mat[1][1] = 1.0; } else { A_mat[1][1] = 1.0; d_mat[1][1] = 1.0; } } else //Must be open { if (solver_method == SM_NR) { From_Y[1][1] = complex(0.0,0.0); NR_branchdata[NR_branch_reference].phases &= 0xFD; //Make sure we're removed a_mat[1][1] = 0.0; d_mat[1][1] = 0.0; } else { A_mat[1][1] = 0.0; d_mat[1][1] = 0.0; } } } if (has_phase(PHASE_C)) { if (phase_C_state == CLOSED) { pres_status |= 0x01; if (solver_method == SM_NR) { From_Y[2][2] = complex(1/switch_resistance,1/switch_resistance); NR_branchdata[NR_branch_reference].phases |= 0x01; //Ensure we're set a_mat[2][2] = 1.0; d_mat[2][2] = 1.0; } else { A_mat[2][2] = 1.0; d_mat[2][2] = 1.0; } } else //Must be open { if (solver_method == SM_NR) { From_Y[2][2] = complex(0.0,0.0); NR_branchdata[NR_branch_reference].phases &= 0xFE; //Make sure we're removed a_mat[2][2] = 0.0; d_mat[2][2] = 0.0; } else { A_mat[2][2] = 0.0; d_mat[2][2] = 0.0; } } } } }//end individual mode //Check status before running sync (since it will clear it) //NR locking if (solver_method == SM_NR) { if ((status != prev_status) || (pres_status != prev_full_status)) { LOCK_OBJECT(NR_swing_bus); //Lock SWING since we'll be modifying this NR_admit_change = true; //Flag an admittance change UNLOCK_OBJECT(NR_swing_bus); //Finished } } prev_full_status = pres_status; //Update the status flags }
//Function to externally set switch status - mainly for "out of step" updates under NR solver //where admittance needs to be updated void switch_object::set_switch(bool desired_status) { status = desired_status; //Change the status //Check solver method - Only works for NR right now if (solver_method == SM_NR) { if (status != prev_status) //Something's changed { //Copied from sync if (status==LS_OPEN) { if (has_phase(PHASE_A)) { From_Y[0][0] = complex(0.0,0.0); //Update admittance a_mat[0][0] = 0.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[0][0] = 0.0; NR_branchdata[NR_branch_reference].phases &= 0xFB; //Ensure we're not set phase_A_state = OPEN; //Open this phase } if (has_phase(PHASE_B)) { From_Y[1][1] = complex(0.0,0.0); //Update admittance a_mat[1][1] = 0.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[1][1] = 0.0; NR_branchdata[NR_branch_reference].phases &= 0xFD; //Ensure we're not set phase_B_state = OPEN; //Open this phase } if (has_phase(PHASE_C)) { From_Y[2][2] = complex(0.0,0.0); //Update admittance a_mat[2][2] = 0.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[2][2] = 0.0; NR_branchdata[NR_branch_reference].phases &= 0xFE; //Ensure we're not set phase_C_state = OPEN; //Open this phase } }//end open else //Must be closed then { if (has_phase(PHASE_A)) { From_Y[0][0] = complex(1/switch_resistance,1/switch_resistance); //Update admittance a_mat[0][0] = 1.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[0][0] = 1.0; NR_branchdata[NR_branch_reference].phases |= 0x04; //Ensure we're set phase_A_state = CLOSED; //Close this phase } if (has_phase(PHASE_B)) { From_Y[1][1] = complex(1/switch_resistance,1/switch_resistance); //Update admittance a_mat[1][1] = 1.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[1][1] = 1.0; NR_branchdata[NR_branch_reference].phases |= 0x02; //Ensure we're set phase_B_state = CLOSED; //Close this phase } if (has_phase(PHASE_C)) { From_Y[2][2] = complex(1/switch_resistance,1/switch_resistance); //Update admittance a_mat[2][2] = 1.0; //Update the voltage ratio matrix as well (for power calcs) d_mat[2][2] = 1.0; NR_branchdata[NR_branch_reference].phases |= 0x01; //Ensure we're set phase_C_state = CLOSED; //Close this phase } }//end closed //Lock the swing first LOCK_OBJECT(NR_swing_bus); //Flag an update NR_admit_change = true; //Flag an admittance change //Unlock swing UNLOCK_OBJECT(NR_swing_bus); //Update prev_status prev_status = status; } //defaulted else - no change, so nothing needs to be done } else { gl_warning("Switch status updated, but no other changes made."); /* TROUBLESHOOT When changed under solver methods other than NR, only the switch status is changed. The solver handles other details in a specific step, so no other changes are performed. */ } }
int switch_object::init(OBJECT *parent) { double phase_total, switch_total; char indexa, indexb; OBJECT *obj = OBJECTHDR(this); //Special flag moved to be universal for all solvers - mainly so phase checks catch it now SpecialLnk = SWITCH; int result = link_object::init(parent); //secondary init stuff - should have been done, but we'll be safe //Basically zero everything if (solver_method==SM_FBS) { for (indexa=0; indexa<3; indexa++) { for (indexb=0; indexb<3; indexb++) { //These have to be zeroed (nature of switch) b_mat[indexa][indexb] = 0.0; c_mat[indexa][indexb] = 0.0; B_mat[indexa][indexb] = 0.0; //Paranoid initialization a_mat[indexa][indexb] = 0.0; A_mat[indexa][indexb] = 0.0; d_mat[indexa][indexb] = 0.0; } } //Generic warning for switches gl_warning("switch objects may not behave properly under FBS!"); /* TROUBLESHOOT Due to the nature of the forward-backward sweep algorithm, and open switch may induce the desired behavior on the system. If open, it should prevent current flow and set the "to" end voltage to zero. However, this may cause problems in many powerflow conditions or not properly solve. Consider using the Newton-Raphson solver in conjunction with the reliability package, or rearrange your system. */ } else { //Flagged it as special (we'll forgo inversion processes on this) //Index out "voltage_ratio" matrix (same as A_mat, basically) //and From_Y - just because for (indexa=0; indexa<3; indexa++) { for (indexb=0; indexb<3; indexb++) { From_Y[indexa][indexb] = 0.0; a_mat[indexa][indexb] = 0.0; } } if(switch_resistance == 0.0){ gl_warning("Switch:%s switch_resistance has been set to zero. This will result singular matrix. Setting to the global default.",obj->name); /* TROUBLESHOOT Under Newton-Raphson solution method the impedance matrix cannot be a singular matrix for the inversion process. Change the value of switch_resistance to something small but larger that zero. */ } if(switch_resistance < 0.0){ switch_resistance = default_resistance; } }//End NR mode //Make adjustments based on BANKED vs. INDIVIDUAL - replication of later code if (switch_banked_mode == BANKED_SW) { //Set reliability-related flag prefault_banked = true; //Banked mode is operated by majority rule. If the majority are a different state, all become that state phase_total = (double)(has_phase(PHASE_A) + has_phase(PHASE_B) + has_phase(PHASE_C)); //See how many switches we have switch_total = 0.0; if (has_phase(PHASE_A) && (phase_A_state == CLOSED)) switch_total += 1.0; if (has_phase(PHASE_B) && (phase_B_state == CLOSED)) switch_total += 1.0; if (has_phase(PHASE_C) && (phase_C_state == CLOSED)) switch_total += 1.0; switch_total /= phase_total; if (switch_total > 0.5) //In two switches, a stalemate occurs. We'll consider this a "maintain status quo" state { //Initial check, make sure stays open if (status == LS_OPEN) { phase_A_state = phase_B_state = phase_C_state = CLOSED; //Set all to open - phase checks will sort it out } else { phase_A_state = phase_B_state = phase_C_state = CLOSED; //Set all to closed - phase checks will sort it out } } else //Minority or stalemate { if (switch_total == 0.5) //Stalemate { if (status == LS_OPEN) //These check assume phase_X_state will be manipulated, not status { phase_A_state = phase_B_state = phase_C_state = OPEN; } else //Closed { phase_A_state = phase_B_state = phase_C_state = CLOSED; } } else //Not stalemate - open all { status = LS_OPEN; phase_A_state = phase_B_state = phase_C_state = OPEN; //Set all to open - phase checks will sort it out } } if (status==LS_OPEN) { if (solver_method == SM_NR) { From_Y[0][0] = complex(0.0,0.0); From_Y[1][1] = complex(0.0,0.0); From_Y[2][2] = complex(0.0,0.0); //Confirm a_mat is zerod too, just for portability a_mat[0][0] = complex(0.0,0.0); a_mat[1][1] = complex(0.0,0.0); a_mat[2][2] = complex(0.0,0.0); d_mat[0][0] = complex(0.0,0.0); d_mat[1][1] = complex(0.0,0.0); d_mat[2][2] = complex(0.0,0.0); } else //Assumed FBS (GS not considered) { A_mat[0][0] = complex(0.0,0.0); A_mat[1][1] = complex(0.0,0.0); A_mat[2][2] = complex(0.0,0.0); d_mat[0][0] = complex(0.0,0.0); d_mat[1][1] = complex(0.0,0.0); d_mat[2][2] = complex(0.0,0.0); } phase_A_state = phase_B_state = phase_C_state = OPEN; //All open prev_full_status = 0x00; //Confirm here } else { if (has_phase(PHASE_A)) { if (solver_method == SM_NR) { From_Y[0][0] = complex(1/switch_resistance,1/switch_resistance); a_mat[0][0] = 1.0; d_mat[0][0] = 1.0; } else { A_mat[0][0] = 1.0; d_mat[0][0] = 1.0; } phase_A_state = CLOSED; //Flag as closed prev_full_status |= 0x04; } if (has_phase(PHASE_B)) { if (solver_method == SM_NR) { From_Y[1][1] = complex(1/switch_resistance,1/switch_resistance); a_mat[1][1] = 1.0; d_mat[1][1] = 1.0; } else { A_mat[1][1] = 1.0; d_mat[1][1] = 1.0; } phase_B_state = CLOSED; //Flag as closed prev_full_status |= 0x02; } if (has_phase(PHASE_C)) { if (solver_method == SM_NR) { From_Y[2][2] = complex(1/switch_resistance,1/switch_resistance); a_mat[2][2] = 1.0; d_mat[2][2] = 1.0; } else { A_mat[2][2] = 1.0; d_mat[2][2] = 1.0; } phase_C_state = CLOSED; //Flag as closed prev_full_status |= 0x01; } } }//End banked mode else //Individual mode { if (status==LS_OPEN) //Take this as all should be open { if (solver_method == SM_NR) { From_Y[0][0] = complex(0.0,0.0); From_Y[1][1] = complex(0.0,0.0); From_Y[2][2] = complex(0.0,0.0); //Ensure voltage ratio set too (technically not needed) a_mat[0][0] = 0.0; a_mat[1][1] = 0.0; a_mat[2][2] = 0.0; d_mat[0][0] = 0.0; d_mat[1][1] = 0.0; d_mat[2][2] = 0.0; } else //Assumed FBS (GS not considered) { A_mat[0][0] = complex(0.0,0.0); A_mat[1][1] = complex(0.0,0.0); A_mat[2][2] = complex(0.0,0.0); d_mat[0][0] = complex(0.0,0.0); d_mat[1][1] = complex(0.0,0.0); d_mat[2][2] = complex(0.0,0.0); } phase_A_state = phase_B_state = phase_C_state = OPEN; //All open prev_full_status = 0x00; //Confirm here } else //LS_CLOSED - handle individually { if (has_phase(PHASE_A)) { if (phase_A_state == CLOSED) { if (solver_method == SM_NR) { From_Y[0][0] = complex(1/switch_resistance,1/switch_resistance); a_mat[0][0] = 1.0; d_mat[0][0] = 1.0; } else { A_mat[0][0] = 1.0; d_mat[0][0] = 1.0; } prev_full_status |= 0x04; } else //Must be open { if (solver_method == SM_NR) { From_Y[0][0] = complex(0.0,0.0); a_mat[0][0] = complex(0.0,0.0); d_mat[0][0] = complex(0.0,0.0); } else { A_mat[0][0] = complex(0.0,0.0); d_mat[0][0] = complex(0.0,0.0); } prev_full_status &=0xFB; } } if (has_phase(PHASE_B)) { if (phase_B_state == CLOSED) { if (solver_method == SM_NR) { From_Y[1][1] = complex(1/switch_resistance,1/switch_resistance); a_mat[1][1] = 1.0; d_mat[1][1] = 1.0; } else { A_mat[1][1] = 1.0; d_mat[1][1] = 1.0; } prev_full_status |= 0x02; } else //Must be open { if (solver_method == SM_NR) { From_Y[1][1] = complex(0.0,0.0); a_mat[1][1] = complex(0.0,0.0); d_mat[1][1] = complex(0.0,0.0); } else { A_mat[1][1] = complex(0.0,0.0); d_mat[1][1] = complex(0.0,0.0); } prev_full_status &=0xFD; } } if (has_phase(PHASE_C)) { if (phase_C_state == CLOSED) { if (solver_method == SM_NR) { From_Y[2][2] = complex(1/switch_resistance,1/switch_resistance); a_mat[2][2] = 1.0; d_mat[2][2] = 1.0; } else { A_mat[2][2] = 1.0; d_mat[2][2] = 1.0; } prev_full_status |= 0x01; } else //Must be open { if (solver_method == SM_NR) { From_Y[2][2] = complex(0.0,0.0); a_mat[2][2] = complex(0.0,0.0); d_mat[2][2] = complex(0.0,0.0); } else { A_mat[2][2] = complex(0.0,0.0); d_mat[2][2] = complex(0.0,0.0); } prev_full_status &=0xFE; } } } }//end individual //Store switch status - will get updated as things change later phased_switch_status = prev_full_status; return result; }
//Function to replicate sync_switch_function, but not call anything (just for reliability checks) unsigned char switch_object::switch_expected_sync_function(void) { unsigned char phases_out; double phase_total, switch_total; SWITCHSTATE temp_A_state, temp_B_state, temp_C_state; enumeration temp_status; if (solver_method==SM_NR) //Newton-Raphson checks { //Store current phases phases_out = NR_branchdata[NR_branch_reference].phases; temp_A_state = (SWITCHSTATE)phase_A_state; temp_B_state = (SWITCHSTATE)phase_B_state; temp_C_state = (SWITCHSTATE)phase_C_state; temp_status = status; if (switch_banked_mode == BANKED_SW) //Banked mode { if (temp_status == prev_status) { //Banked mode is operated by majority rule. If the majority are a different state, all become that state phase_total = (double)(has_phase(PHASE_A) + has_phase(PHASE_B) + has_phase(PHASE_C)); //See how many switches we have switch_total = 0.0; if (has_phase(PHASE_A) && (temp_A_state == CLOSED)) switch_total += 1.0; if (has_phase(PHASE_B) && (temp_B_state == CLOSED)) switch_total += 1.0; if (has_phase(PHASE_C) && (temp_C_state == CLOSED)) switch_total += 1.0; switch_total /= phase_total; if (switch_total > 0.5) //In two switches, a stalemate occurs. We'll consider this a "maintain status quo" state { temp_status = LS_CLOSED; //If it wasn't here, it is now temp_A_state = temp_B_state = temp_C_state = CLOSED; //Set all to closed - phase checks will sort it out } else //Minority or stalemate { if (switch_total == 0.5) //Stalemate { if (temp_status == LS_OPEN) //These check assume phase_X_state will be manipulated, not status { temp_A_state = temp_B_state = temp_C_state = OPEN; } else //Closed { temp_A_state = temp_B_state = temp_C_state = CLOSED; } } else //Not stalemate - open all { temp_status = LS_OPEN; temp_A_state = temp_B_state = temp_C_state = OPEN; //Set all to open - phase checks will sort it out } } }//End status is same else //Not the same - force the inputs { if (temp_status==LS_OPEN) temp_A_state = temp_B_state = temp_C_state = OPEN; //Flag all as open else temp_A_state = temp_B_state = temp_C_state = CLOSED; //Flag all as closed }//End not same if (temp_status==LS_OPEN) { if (has_phase(PHASE_A)) { phases_out &= 0xFB; //Remove this bit } if (has_phase(PHASE_B)) { phases_out &= 0xFD; //Remove this bit } if (has_phase(PHASE_C)) { phases_out &= 0xFE; //Remove this bit } }//end open else //Must be closed then { if (has_phase(PHASE_A)) { phases_out |= 0x04; //Ensure we're set } if (has_phase(PHASE_B)) { phases_out |= 0x02; //Ensure we're set } if (has_phase(PHASE_C)) { phases_out |= 0x01; //Ensure we're set } }//end closed }//End banked mode else //Individual mode { if (temp_status == LS_OPEN) //Fully opened means all go open { temp_A_state = temp_B_state = temp_C_state = OPEN; //All open phases_out &= 0xF0; //Remove all our phases } else //Closed means a phase-by-phase basis { if (has_phase(PHASE_A)) { if (temp_A_state == CLOSED) { phases_out |= 0x04; //Ensure we're set } else //Must be open { phases_out &= 0xFB; //Make sure we're removed } } if (has_phase(PHASE_B)) { if (temp_B_state == CLOSED) { phases_out |= 0x02; //Ensure we're set } else //Must be open { phases_out &= 0xFD; //Make sure we're removed } } if (has_phase(PHASE_C)) { if (temp_C_state == CLOSED) { phases_out |= 0x01; //Ensure we're set } else //Must be open { phases_out &= 0xFE; //Make sure we're removed } } } }//end individual mode }//end SM_NR //Return the phases return phases_out; }
// Initialize a distribution meter, return 1 on success int substation::init(OBJECT *parent) { OBJECT *hdr = OBJECTHDR(this); int i,n; //Base check higher so can be used below if(base_power <= 0){ gl_warning("substation:%i is using the default base power of 100 VA. This could cause instability on your system.", hdr->id); base_power = 100;//default gives a max power error of 1 VA. } //Check convergence-posting criterion if (power_convergence_value<=0.0) { gl_warning("power_convergence_value not set - defaulting to 0.01 base_power"); /* TROUBLESHOOT A value was not specified for the convergence criterion required before posting an answer up to pw_load. This value has defaulted to 1% of base_power. If a different threshold is desired, set it explicitly. */ power_convergence_value = 0.01*base_power; }//End convergence value check //Check to see if it has a parent (no sense to ISAs if it is empty) if (parent != NULL) { if (gl_object_isa(parent,"pw_load","network")) { //Make sure it is done, otherwise defer if((parent->flags & OF_INIT) != OF_INIT){ char objname[256]; gl_verbose("substation::init(): deferring initialization on %s", gl_name(parent, objname, 255)); return 2; // defer } //Map up the appropriate variables- error checks mostly inside fetch_complex(&pPositiveSequenceVoltage,"load_voltage",parent); fetch_complex(&pConstantPowerLoad,"load_power",parent); fetch_complex(&pConstantCurrentLoad,"load_current",parent); fetch_complex(&pConstantImpedanceLoad,"load_impedance",parent); fetch_double(&pTransNominalVoltage,"bus_nom_volt",parent); //Do a general check for nominal voltages - make sure they match if (fabs(*pTransNominalVoltage-nominal_voltage)>0.001) { gl_error("Nominal voltages of tranmission node (%.1f V) and substation (%.1f) do not match!",*pTransNominalVoltage,nominal_voltage); /* TROUBLESHOOT The nominal voltage of the transmission node in PowerWorld does not match that of the value inside GridLAB-D's substation's nominal_voltage. This could cause information mismatch and is therefore not allowed. Please set the substation to the same nominal voltage as the transmission node. Use transformers to step the voltage down to an appropriate distribution or sub-transmission level. */ return 0; //Fail } //Check our bustype - otherwise we may get overridden (NR-esque check) if (bustype != SWING) { gl_warning("substation attached to pw_load and not a SWING bus - forcing to SWING"); /* TROUBLESHOOT When a substation object is connected to PowerWorld via a pw_load object, the substation must be designated as a SWING bus. This designation will now be forced upon the bus. */ bustype = SWING; }//End bus check //Flag us as pw_load connected has_parent = 1; } else //Parent isn't a pw_load, so we just become a normal node - let it handle things { has_parent = 2; //Flag as "normal" - let node checks sort out if we are really valid or not } }//End parent else //Parent is null, see what mode we're in { //Check for sequence voltages - if not set, we're normal (let node checks handle if we're valid) if ((seq_mat[0] != 0.0) || (seq_mat[1] != 0.0) || (seq_mat[2] != 0.0)) { //See if we're a swing, if not, this is meaningless if (bustype != SWING) { gl_warning("substation is not a SWING bus, so answers may be unexpected"); /* TROUBLESHOOT A substation object appears set to accept sequence voltage values, but it is not a SWING bus. This may end up causing the voltages to be converted from sequence, but then overridden by the distribution powerflow solver. */ } //Explicitly set has_parent = 0; } else //Else, nothing set, we're a normal old node { has_parent = 2; //Normal node //Warn that nothing was found gl_warning("substation:%s is set up as a normal node, no sequence values will be calculated",hdr->name); /* TROUBLESHOOT A substation is currently behaving just like a normal powerflow node. If it was desired that it convert a schedule or player of sequence values, please initialize those values to non-zero along with the player attachment. */ } }//End no parent //Set up reference items if they are needed if (has_parent != 2) //Not a normal node { //New requirement to maintain positive sequence ability - three phases must be had, unless //we're just a normal node. Then, we don't care. if (!has_phase(PHASE_A|PHASE_B|PHASE_C)) { gl_error("substation needs to have all three phases!"); /* TROUBLESHOOT To meet the requirements for sequence voltage conversions, the substation node must have all three phases at the connection point. If only a single phase or subset of full three phase is needed, those must be set in the distribution network, typically after a delta-ground wye transformer. */ return 0; } }//End not a normal node //set the reference phase number to shift the phase voltages appropriatly with the positive sequence voltage if(reference_phase == R_PHASE_A){ reference_number.SetPolar(1,0); } else if(reference_phase == R_PHASE_B){ reference_number.SetPolar(1,2*PI/3); } else if(reference_phase == R_PHASE_C){ reference_number.SetPolar(1,-2*PI/3); } //create the sequence to phase transformation matrix for(i=0; i<3; i++){ for(n=0; n<3; n++){ if((i==1 && n==1) || (i==2 && n==2)){ transformation_matrix[i][n].SetPolar(1,-2*PI/3); } else if((i==2 && n==1) || (i==1 && n==2)){ transformation_matrix[i][n].SetPolar(1,2*PI/3); } else { transformation_matrix[i][n].SetPolar(1,0); } } } return node::init(parent); }
// Initialize a distribution meter, return 1 on success int meter::init(OBJECT *parent) { char temp_buff[128]; if(power_market != 0){ price_prop = gl_get_property(power_market, "current_market.clearing_price"); if(price_prop == 0){ GL_THROW("meter::power_market object \'%s\' does not publish \'current_market.clearing_price\'", (power_market->name ? power_market->name : "(anon)")); } } // Count the number of phases...for use with meter_power_consumption if (meter_power_consumption != complex(0,0)) { no_phases = 0; if (has_phase(PHASE_A)) no_phases += 1; if (has_phase(PHASE_B)) no_phases += 1; if (has_phase(PHASE_C)) no_phases += 1; } check_prices(); last_t = dt = 0; //Update tracking flag //Get server mode variable gl_global_getvar("multirun_mode",temp_buff,sizeof(temp_buff)); //See if we're not in standalone if (strcmp(temp_buff,"STANDALONE")) //strcmp returns a 0 if they are the same { if ((solver_method == SM_NR) && (bustype == SWING)) { meter_NR_servered = true; //Set this flag for later use //Allocate the storage vector prev_voltage_value = (complex *)gl_malloc(3*sizeof(complex)); //Check it if (prev_voltage_value==NULL) { GL_THROW("Failure to allocate memory for voltage tracking array"); /* TROUBLESHOOT While attempting to allocate memory for the voltage tracking array used by the master/slave functionality, an error occurred. Please try again. If the error persists, please submit your code and a bug report via the trac website. */ } //Populate it with zeros for now, just cause - init sets voltages in node prev_voltage_value[0] = complex(0.0,0.0); prev_voltage_value[1] = complex(0.0,0.0); prev_voltage_value[2] = complex(0.0,0.0); } } return node::init(parent); }
int series_reactor::init(OBJECT *parent) { int result = link_object::init(parent); a_mat[0][0] = d_mat[0][0] = A_mat[0][0] = (has_phase(PHASE_A)) ? 1.0 : 0.0; a_mat[1][1] = d_mat[1][1] = A_mat[1][1] = (has_phase(PHASE_B)) ? 1.0 : 0.0; a_mat[2][2] = d_mat[2][2] = A_mat[2][2] = (has_phase(PHASE_C)) ? 1.0 : 0.0; if (solver_method==SM_FBS) { c_mat[0][0] = 0.0; c_mat[1][1] = 0.0; c_mat[2][2] = 0.0; //Pass in impedance values b_mat[0][0] = B_mat[0][0] = phase_A_impedance; b_mat[1][1] = B_mat[1][1] = phase_B_impedance; b_mat[2][2] = B_mat[2][2] = phase_C_impedance; } else { //Flag it as special (we'll forgo inversion processes on this) SpecialLnk = SWITCH; //Initialize off-diagonals just in case From_Y[0][1] = From_Y[0][2] = From_Y[1][0] = 0.0; From_Y[1][2] = From_Y[2][0] = From_Y[2][1] = 0.0; //See if it has a particular phase, if so populate it. If not //and has zero impedance, put a "default" value in its place if (has_phase(PHASE_A)) { if (phase_A_impedance==0.0) From_Y[0][0] = complex(1e4,1e4); else From_Y[0][0] = complex(1.0,0.0)/phase_A_impedance; } else From_Y[0][0] = 0.0; //Should already be 0, but let's be paranoid if (has_phase(PHASE_B)) { if (phase_B_impedance==0.0) From_Y[1][1] = complex(1e4,1e4); else From_Y[1][1] = complex(1.0,0.0)/phase_B_impedance; } else From_Y[1][1] = 0.0; //Should already be 0, but let's be paranoid if (has_phase(PHASE_C)) { if (phase_C_impedance==0.0) From_Y[2][2] = complex(1e4,1e4); else From_Y[2][2] = complex(1.0,0.0)/phase_C_impedance; } else From_Y[2][2] = 0.0; //Should already be 0, but let's be paranoid } return result; }
static double gravity_response(const ecl_grid_type * ecl_grid , const ecl_file_type * init_file , const ecl_file_type * restart_file1 , const ecl_file_type * restart_file2 , const grav_station_type * grav_station , int model_phases, int file_phases) { ecl_kw_type * rporv1_kw = NULL; ecl_kw_type * rporv2_kw = NULL; ecl_kw_type * oil_den1_kw = NULL; ecl_kw_type * oil_den2_kw = NULL; ecl_kw_type * gas_den1_kw = NULL; ecl_kw_type * gas_den2_kw = NULL; ecl_kw_type * wat_den1_kw = NULL; ecl_kw_type * wat_den2_kw = NULL; ecl_kw_type * sgas1_kw = NULL; ecl_kw_type * sgas2_kw = NULL; ecl_kw_type * swat1_kw = NULL; ecl_kw_type * swat2_kw = NULL; ecl_kw_type * aquifern_kw = NULL ; double local_deltag = 0; /* Extracting the pore volumes */ rporv1_kw = ecl_file_iget_named_kw( restart_file1 , "RPORV" , 0); rporv2_kw = ecl_file_iget_named_kw( restart_file2 , "RPORV" , 0); /** Extracting the densities */ { // OIL_DEN if( has_phase(model_phases , OIL) ) { if (simulator == ECLIPSE100) { oil_den1_kw = ecl_file_iget_named_kw(restart_file1, "OIL_DEN", 0); oil_den2_kw = ecl_file_iget_named_kw(restart_file2, "OIL_DEN", 0); } else { // ECLIPSE300 oil_den1_kw = ecl_file_iget_named_kw(restart_file1, "DENO", 0); oil_den2_kw = ecl_file_iget_named_kw(restart_file2, "DENO", 0); } ; } // GAS_DEN if( has_phase( model_phases , GAS) ) { if (simulator == ECLIPSE100) { gas_den1_kw = ecl_file_iget_named_kw(restart_file1, "GAS_DEN", 0); gas_den2_kw = ecl_file_iget_named_kw(restart_file2, "GAS_DEN", 0); } else { // ECLIPSE300 gas_den1_kw = ecl_file_iget_named_kw(restart_file1, "DENG", 0); gas_den2_kw = ecl_file_iget_named_kw(restart_file2, "DENG", 0); } ; } // WAT_DEN if( has_phase( model_phases , WATER) ) { if (simulator == ECLIPSE100) { wat_den1_kw = ecl_file_iget_named_kw(restart_file1, "WAT_DEN", 0); wat_den2_kw = ecl_file_iget_named_kw(restart_file2, "WAT_DEN", 0); } else { // ECLIPSE300 wat_den1_kw = ecl_file_iget_named_kw(restart_file1, "DENW", 0); wat_den2_kw = ecl_file_iget_named_kw(restart_file2, "DENW", 0); } ; } } /* Extracting the saturations */ { // SGAS if( has_phase( file_phases , GAS )) { sgas1_kw = ecl_file_iget_named_kw(restart_file1, "SGAS", 0); sgas2_kw = ecl_file_iget_named_kw(restart_file2, "SGAS", 0); } // SWAT if( has_phase( file_phases , WATER )) { swat1_kw = ecl_file_iget_named_kw(restart_file1, "SWAT", 0); swat2_kw = ecl_file_iget_named_kw(restart_file2, "SWAT", 0); } } /* The numerical aquifer information */ if( ecl_file_has_kw( init_file , "AQUIFERN")) aquifern_kw = ecl_file_iget_named_kw(init_file, "AQUIFERN", 0); { int nactive = ecl_grid_get_active_size( ecl_grid ); float * zero = util_calloc( nactive , sizeof * zero ); /* Fake vector of zeros used for densities / sturations when you do not have data. */ int * int_zero = util_calloc( nactive , sizeof * int_zero ); /* Fake vector of zeros used for AQUIFER when the init file does not supply data. */ /* Observe that the fake vectors are only a coding simplification, they should not be really used. */ { int i; for (i=0; i < nactive; i++) { zero[i] = 0; int_zero[i] = 0; } } { const float * sgas1_v = safe_get_float_ptr( sgas1_kw , NULL ); const float * swat1_v = safe_get_float_ptr( swat1_kw , NULL ); const float * oil_den1 = safe_get_float_ptr( oil_den1_kw , zero ); const float * gas_den1 = safe_get_float_ptr( gas_den1_kw , zero ); const float * wat_den1 = safe_get_float_ptr( wat_den1_kw , zero ); const float * sgas2_v = safe_get_float_ptr( sgas2_kw , NULL ); const float * swat2_v = safe_get_float_ptr( swat2_kw , NULL ); const float * oil_den2 = safe_get_float_ptr( oil_den2_kw , zero ); const float * gas_den2 = safe_get_float_ptr( gas_den2_kw , zero ); const float * wat_den2 = safe_get_float_ptr( wat_den2_kw , zero ); const float * rporv1 = ecl_kw_get_float_ptr(rporv1_kw); const float * rporv2 = ecl_kw_get_float_ptr(rporv2_kw); double utm_x = grav_station->utm_x; double utm_y = grav_station->utm_y; double tvd = grav_station->depth; int * aquifern; int global_index; if (aquifern_kw != NULL) aquifern = ecl_kw_get_int_ptr( aquifern_kw ); else aquifern = int_zero; for (global_index=0;global_index < ecl_grid_get_global_size( ecl_grid ); global_index++){ const int act_index = ecl_grid_get_active_index1( ecl_grid , global_index ); if (act_index >= 0) { // Not numerical aquifer if(aquifern[act_index] >= 0){ float swat1 = swat1_v[act_index]; float swat2 = swat2_v[act_index]; float sgas1 = 0; float sgas2 = 0; float soil1 = 0; float soil2 = 0; truncate_saturation( &swat1 ); truncate_saturation( &swat2 ); if (has_phase( model_phases , GAS)) { if (has_phase( file_phases , GAS )) { sgas1 = sgas1_v[act_index]; sgas2 = sgas2_v[act_index]; truncate_saturation( &sgas1 ); truncate_saturation( &sgas2 ); } else { sgas1 = 1 - swat1; sgas2 = 1 - swat2; } } if (has_phase( model_phases , OIL )) { soil1 = 1 - sgas1 - swat1; soil2 = 1 - sgas2 - swat2; truncate_saturation( &soil1 ); truncate_saturation( &soil2 ); } /* We have found all the info we need for one cell. */ { double mas1 , mas2; double xpos , ypos , zpos; mas1 = rporv1[act_index]*(soil1 * oil_den1[act_index] + sgas1 * gas_den1[act_index] + swat1 * wat_den1[act_index] ); mas2 = rporv2[act_index]*(soil2 * oil_den2[act_index] + sgas2 * gas_den2[act_index] + swat2 * wat_den2[act_index] ); ecl_grid_get_xyz1(ecl_grid , global_index , &xpos , &ypos , &zpos); { double dist_x = xpos - utm_x; double dist_y = ypos - utm_y; double dist_d = zpos - tvd; double dist_sq = dist_x*dist_x + dist_y*dist_y + dist_d*dist_d; if(dist_sq == 0){ exit(1); } local_deltag += 6.67428E-3*(mas2 - mas1)*dist_d/pow(dist_sq, 1.5); // Gravity in units of \mu Gal = 10^{-8} m/s^2 } } } } } } free( zero ); free( int_zero ); } return local_deltag; }