////////////////////////////////////////////////////////////////////////// // IMPLEMENTATION OF DELTA MODE ////////////////////////////////////////////////////////////////////////// //Module-level call SIMULATIONMODE triplex_node::inter_deltaupdate_triplex_node(unsigned int64 delta_time, unsigned long dt, unsigned int iteration_count_val,bool interupdate_pos) { //unsigned char pass_mod; OBJECT *hdr = OBJECTHDR(this); if (interupdate_pos == false) //Before powerflow call { //Call triplex-specific call BOTH_triplex_node_presync_fxn(); //Call node presync-equivalent items NR_node_presync_fxn(); //Call sync-equivalent of triplex portion first BOTH_triplex_node_sync_fxn(); //Call node sync-equivalent items (solver occurs at end of sync) NR_node_sync_fxn(hdr); return SM_DELTA; //Just return something other than SM_ERROR for this call } else //After the call { //No triplex-specific postsync for node //Perform node postsync-like updates on the values BOTH_node_postsync_fxn(hdr); //No control required at this time - powerflow defers to the whims of other modules //Code below implements predictor/corrector-type logic, even though it effectively does nothing return SM_EVENT; ////Do deltamode-related logic //if (bustype==SWING) //We're the SWING bus, control our destiny (which is really controlled elsewhere) //{ // //See what we're on // pass_mod = iteration_count_val - ((iteration_count_val >> 1) << 1); // //Check pass // if (pass_mod==0) //Predictor pass // { // return SM_DELTA_ITER; //Reiterate - to get us to corrector pass // } // else //Corrector pass // { // //As of right now, we're always ready to leave // //Other objects will dictate if we stay (powerflow is indifferent) // return SM_EVENT; // }//End corrector pass //}//End SWING bus handling //else //Normal bus //{ // return SM_EVENT; //Normal nodes want event mode all the time here - SWING bus will // //control the reiteration process for pred/corr steps //} } }
//Module-level call SIMULATIONMODE meter::inter_deltaupdate_meter(unsigned int64 delta_time, unsigned long dt, unsigned int iteration_count_val,bool interupdate_pos) { //unsigned char pass_mod; OBJECT *hdr = OBJECTHDR(this); if (interupdate_pos == false) //Before powerflow call { //Meter-specific presync items if (meter_power_consumption != complex(0,0)) power[0] = power[1] = power[2] = 0.0; //Reliability addition - if momentary flag set - clear it if (meter_interrupted_secondary == true) meter_interrupted_secondary = false; //Call presync-equivalent items NR_node_presync_fxn(); //Meter sync objects BOTH_meter_sync_fxn(); //Call sync-equivalent items (solver occurs at end of sync) NR_node_sync_fxn(hdr); return SM_DELTA; //Just return something other than SM_ERROR for this call } else //After the call { //Perform postsync-like updates on the values BOTH_node_postsync_fxn(hdr); //Perform postsync meter functions -- doesn't do energy right now measured_voltage[0] = voltageA; measured_voltage[1] = voltageB; measured_voltage[2] = voltageC; measured_voltageD[0] = voltageA - voltageB; measured_voltageD[1] = voltageB - voltageC; measured_voltageD[2] = voltageC - voltageA; measured_current[0] = current_inj[0]; measured_current[1] = current_inj[1]; measured_current[2] = current_inj[2]; // compute demand power indiv_measured_power[0] = measured_voltage[0]*(~measured_current[0]); indiv_measured_power[1] = measured_voltage[1]*(~measured_current[1]); indiv_measured_power[2] = measured_voltage[2]*(~measured_current[2]); measured_power = indiv_measured_power[0] + indiv_measured_power[1] + indiv_measured_power[2]; measured_real_power = (indiv_measured_power[0]).Re() + (indiv_measured_power[1]).Re() + (indiv_measured_power[2]).Re(); measured_reactive_power = (indiv_measured_power[0]).Im() + (indiv_measured_power[1]).Im() + (indiv_measured_power[2]).Im(); if (measured_real_power > measured_demand) measured_demand = measured_real_power; //No control required at this time - powerflow defers to the whims of other modules //Code below implements predictor/corrector-type logic, even though it effectively does nothing return SM_EVENT; ////Do deltamode-related logic //if (bustype==SWING) //We're the SWING bus, control our destiny (which is really controlled elsewhere) //{ // //See what we're on // pass_mod = iteration_count_val - ((iteration_count_val >> 1) << 1); // //Check pass // if (pass_mod==0) //Predictor pass // { // return SM_DELTA_ITER; //Reiterate - to get us to corrector pass // } // else //Corrector pass // { // //As of right now, we're always ready to leave // //Other objects will dictate if we stay (powerflow is indifferent) // return SM_EVENT; // }//End corrector pass //}//End SWING bus handling //else //Normal bus //{ // return SM_EVENT; //Normal nodes want event mode all the time here - SWING bus will // //control the reiteration process for pred/corr steps //} } }
////////////////////////////////////////////////////////////////////////// // IMPLEMENTATION OF DELTA MODE ////////////////////////////////////////////////////////////////////////// //Module-level call SIMULATIONMODE triplex_load::inter_deltaupdate_triplex_load(unsigned int64 delta_time, unsigned long dt, unsigned int iteration_count_val,bool interupdate_pos) { //unsigned char pass_mod; OBJECT *hdr = OBJECTHDR(this); bool fault_mode; if (interupdate_pos == false) //Before powerflow call { //Triplex_load presync items if ((solver_method!=SM_FBS) && (SubNode==PARENT)) //Need to do something slightly different with GS and parented node { shunt[0] = shunt[1] = shunt[2] = 0.0; power[0] = power[1] = power[2] = 0.0; current[0] = current[1] = current[2] = 0.0; } //Call triplex-specific call BOTH_triplex_node_presync_fxn(); //Call node presync-equivalent items NR_node_presync_fxn(); //Triplex_load-specific sync calls //See if we're reliability-enabled if (fault_check_object == NULL) fault_mode = false; else fault_mode = true; //Functionalized so deltamode can parttake triplex_load_update_fxn(); //Call sync-equivalent of triplex portion first BOTH_triplex_node_sync_fxn(); //Call node sync-equivalent items (solver occurs at end of sync) NR_node_sync_fxn(hdr); return SM_DELTA; //Just return something other than SM_ERROR for this call } else //After the call { //Perform node postsync-like updates on the values BOTH_node_postsync_fxn(hdr); //Triplex_load-specific postsync items measured_voltage_1.SetPolar(voltage1.Mag(),voltage1.Arg()); //Used for testing and xml output measured_voltage_2.SetPolar(voltage2.Mag(),voltage2.Arg()); measured_voltage_12.SetPolar(voltage12.Mag(),voltage12.Arg()); //No control required at this time - powerflow defers to the whims of other modules //Code below implements predictor/corrector-type logic, even though it effectively does nothing return SM_EVENT; ////Do deltamode-related logic //if (bustype==SWING) //We're the SWING bus, control our destiny (which is really controlled elsewhere) //{ // //See what we're on // pass_mod = iteration_count_val - ((iteration_count_val >> 1) << 1); // //Check pass // if (pass_mod==0) //Predictor pass // { // return SM_DELTA_ITER; //Reiterate - to get us to corrector pass // } // else //Corrector pass // { // //As of right now, we're always ready to leave // //Other objects will dictate if we stay (powerflow is indifferent) // return SM_EVENT; // }//End corrector pass //}//End SWING bus handling //else //Normal bus //{ // return SM_EVENT; //Normal nodes want event mode all the time here - SWING bus will // //control the reiteration process for pred/corr steps //} } }
////////////////////////////////////////////////////////////////////////// // IMPLEMENTATION OF DELTA MODE ////////////////////////////////////////////////////////////////////////// //Module-level call SIMULATIONMODE triplex_meter::inter_deltaupdate_triplex_meter(unsigned int64 delta_time, unsigned long dt, unsigned int iteration_count_val,bool interupdate_pos) { //unsigned char pass_mod; OBJECT *hdr = OBJECTHDR(this); int TempNodeRef; if (interupdate_pos == false) //Before powerflow call { //Triplex meter presync items if (tpmeter_power_consumption != complex(0,0)) power[0] = power[1] = 0.0; //Reliability addition - clear momentary flag if set if (tpmeter_interrupted_secondary == true) tpmeter_interrupted_secondary = false; //Call triplex-specific call BOTH_triplex_node_presync_fxn(); //Call node presync-equivalent items NR_node_presync_fxn(); //Triplex-meter specific sync items //Reliability check if ((fault_check_object != NULL) && (solver_method == SM_NR)) //proper solver 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 { tpmeter_interrupted = true; //Someone is out of service, they just may not know it //See if we were "momentary" as well - if so, clear us. if (tpmeter_interrupted_secondary == true) tpmeter_interrupted_secondary = false; } else { tpmeter_interrupted = false; //All is well } } if (tpmeter_power_consumption != complex(0,0)) { power[0] += tpmeter_power_consumption/2; power[1] += tpmeter_power_consumption/2; } //Call sync-equivalent of triplex portion first BOTH_triplex_node_sync_fxn(); //Call node sync-equivalent items (solver occurs at end of sync) NR_node_sync_fxn(hdr); return SM_DELTA; //Just return something other than SM_ERROR for this call } else //After the call { //Perform node postsync-like updates on the values - call first so current is right BOTH_node_postsync_fxn(hdr); //Triplex_meter-specific postsync measured_voltage[0].SetPolar(voltageA.Mag(),voltageA.Arg()); measured_voltage[1].SetPolar(voltageB.Mag(),voltageB.Arg()); measured_voltage[2].SetPolar(voltageC.Mag(),voltageC.Arg()); measured_current[0] = current_inj[0]; measured_current[1] = current_inj[1]; measured_current[2] = -(measured_current[1]+measured_current[0]); indiv_measured_power[0] = measured_voltage[0]*(~measured_current[0]); indiv_measured_power[1] = complex(-1,0) * measured_voltage[1]*(~measured_current[1]); indiv_measured_power[2] = measured_voltage[2]*(~measured_current[2]); measured_power = indiv_measured_power[0] + indiv_measured_power[1] + indiv_measured_power[2]; measured_real_power = (indiv_measured_power[0]).Re() + (indiv_measured_power[1]).Re() + (indiv_measured_power[2]).Re(); measured_reactive_power = (indiv_measured_power[0]).Im() + (indiv_measured_power[1]).Im() + (indiv_measured_power[2]).Im(); if (measured_real_power>measured_demand) measured_demand=measured_real_power; //No control required at this time - powerflow defers to the whims of other modules //Code below implements predictor/corrector-type logic, even though it effectively does nothing return SM_EVENT; ////Do deltamode-related logic //if (bustype==SWING) //We're the SWING bus, control our destiny (which is really controlled elsewhere) //{ // //See what we're on // pass_mod = iteration_count_val - ((iteration_count_val >> 1) << 1); // //Check pass // if (pass_mod==0) //Predictor pass // { // return SM_DELTA_ITER; //Reiterate - to get us to corrector pass // } // else //Corrector pass // { // //As of right now, we're always ready to leave // //Other objects will dictate if we stay (powerflow is indifferent) // return SM_EVENT; // }//End corrector pass //}//End SWING bus handling //else //Normal bus //{ // return SM_EVENT; //Normal nodes want event mode all the time here - SWING bus will // //control the reiteration process for pred/corr steps //} } }