powerflow/node.h

#ifndef _NODE_H
#define _NODE_H

#include "powerflow.h"

//Deltamode functions
EXPORT SIMULATIONMODE interupdate_node(OBJECT *obj, unsigned int64 delta_time, unsigned long dt, unsigned int iteration_count_val, bool interupdate_pos);
EXPORT STATUS swap_node_swing_status(OBJECT *obj, bool desired_status);
EXPORT STATUS node_reset_disabled_status(OBJECT *nodeObj);
EXPORT STATUS node_map_current_update_function(OBJECT *nodeObj, OBJECT *callObj);
EXPORT STATUS attach_vfd_to_node(OBJECT *obj,OBJECT *calledVFD);

#define I_INJ(V, S, Z, I) (I_S(S, V) + ((Z.IsFinite()) ? I_Z(Z, V) : complex(0.0)) + I_I(I))
#define I_S(S, V) (~((S) / (V)))  // Current injection - constant power load
#define I_Z(Z, V) ((V) / (Z))     // Current injection - constant impedance load
#define I_I(I) (I)                // Current injection - constant current load

//Moved the following to powerflow_object.h, since they are just #defines
//#define NF_NONE           0x0000  ///< flag indicates node has no special conditions */
//#define NF_HASSOURCE  0x0001  ///< flag indicates node has a source for voltage */
//#define NF_ISSOURCE       0x0002  ///< flag indicates node has a source connected directly to it */

// these are only valid when PHASE_S is not set
#define voltageA voltage[0]     
#define voltageB voltage[1]     
#define voltageC voltage[2]     

#define voltageAB voltaged[0]   
#define voltageBC voltaged[1]   
#define voltageCA voltaged[2]   

#define currentA current[0]     
#define currentB current[1]     
#define currentC current[2]     

#define powerA power[0]         
#define powerB power[1]         
#define powerC power[2]         

#define shuntA shunt[0]         
#define shuntB shunt[1]         
#define shuntC shunt[2]         

// these are only valid when phases&PHASE_S is set
#define voltage1 voltage[0]     
#define voltage2 voltage[1]     
#define voltageN voltage[2]     

#define voltage12 voltaged[0]   
#define voltage2N voltaged[1]   
#define voltage1N voltaged[2]   

#define current1 current[0]     
#define current2 current[1]     
#define currentN current[2]     

#define power1 power[0]         
#define power2 power[1]         
#define power12 power[2]        

#define shunt1 shunt[0]         
#define shunt2 shunt[1]         
#define shunt12 shunt[2]        

typedef enum {
        NONE=0,         
        CHILD=1,        
        CHILD_NOINIT=2, 
        PARENT=3,       
        DIFF_CHILD=4,   
        DIFF_PARENT=5   
        } SUBNODETYPE;

typedef enum {
    NORMAL_NODE=0,      
    LOAD_NODE=1,        
    METER_NODE=2        
} DYN_NODE_TYPE;        

//Frequency measurement variable structure
typedef struct {
    complex voltage_val[3]; //Voltage values stored - used for "prev" version
    double x[3];             //integrator state variable
    double anglemeas[3];     //angle measurement
    double fmeas[3];         //frequency measurement
    double average_freq;    //Average of the three-phased frequencies
    double sinangmeas[3];    //sin of bus voltage angle
    double cosangmeas[3];    //cos of bus voltage angle
} FREQM_STATES;


class node : public powerflow_object
{
private:
    complex last_voltage[3];        
    complex current_inj[3];         
    TIMESTAMP prev_NTime;           
    complex last_child_power[4][3]; 
    complex last_child_power_dy[6][3];  
    complex last_child_current12;   
    bool deltamode_inclusive;       
    complex BusHistTerm[3];         
    double prev_delta_time;         
    complex *ahrlloadstore;         
    complex *bhrlloadstore;         
    complex *chrcloadstore;         
    complex *LoadHistTermL;         
    complex *LoadHistTermC;         

    //Frequently measurement variables
    FREQM_STATES curr_freq_state;       //Current state of all vari
    FREQM_STATES prev_freq_state;
    double freq_omega_ref;          //Reference frequency for measurements

    double freq_violation_time_total;       //Keeps track of how long the device has been in a frequency violation, to see if it needs to disconnect or not
    double volt_violation_time_total;       //Keeps track of how long the device has been in a voltage violation, to see if it needs to disconnect or not
    double out_of_violation_time_total;     //Tracking variable to see how long we've been "outside of bad conditions"
    double prev_time_dbl;                   //Tracking variable for GFA functionality
    double GFA_Update_time;
    GL_STRUCT(complex_array,full_Y_matrix);
    GL_STRUCT(complex_array,full_Y_all_matrix);

    //VFD-related items
    bool VFD_attached;                      
    FUNCTIONADDR VFD_updating_function;     
    OBJECT *VFD_object;                     

    double compute_angle_diff(double angle_B, double angle_A);  //Function to do differences, but handle the phase wrap/jump

public:
    double frequency;           
    object reference_bus;       
    static unsigned int n;      
    unsigned short k;           
    complex *prev_voltage_value;    // Pointer for array used to store previous voltage value for Master/Slave functionality
    complex *prev_power_value;      // Pointer for array used to store previous power value for Master/Slave functionality

    bool reset_island_state;            //< Flagging variable - indicates the disabled island state should be re-evaluated
public:
    // status
    enum {
        PQ=0,       
        PV=1,       
        SWING=2,    
        SWING_PQ=3  
    };
    enumeration bustype;
    enum {  NOMINAL=1,      
            UNDERVOLT,      
            OVERVOLT,       
    };
    enumeration status;
    enum { 
        ND_OUT_OF_SERVICE = 0, 
        ND_IN_SERVICE = 1,     
    };
    enum {
        GFA_NONE=0,     
        GFA_UF=1,       
        GFA_OF=2,       
        GFA_UV=3,       
        GFA_OV=4        
    };
    enumeration GFA_trip_method;
    enumeration service_status;
    double service_status_dbl;  
    TIMESTAMP last_disconnect;  
    double previous_uptime;     
    double current_uptime;      

    //Frequency measurement capabilities
    enum {FM_NONE=1, FM_SIMPLE=2, FM_PLL=3};
    enumeration fmeas_type;

    double freq_sfm_Tf; //Transducer time constant
    double freq_pll_Kp; //Proportional gain of PLL frequency measurement
    double freq_pll_Ki; //Integration gain of PLL frequency measurement

    //GFA functionality
    bool GFA_enable;
    double GFA_freq_low_trip;
    double GFA_freq_high_trip;
    double GFA_voltage_low_trip;
    double GFA_voltage_high_trip;
    double GFA_reconnect_time;
    double GFA_freq_disconnect_time;
    double GFA_volt_disconnect_time;
    bool GFA_status;

    SUBNODETYPE SubNode;
    set busflags;           
    set busphasesIn;        
    set busphasesOut;       
    double maximum_voltage_error;  // convergence voltage limit

    // properties
    complex voltage[3];     
    complex voltaged[3];    
    complex current[3];     
    complex pre_rotated_current[3]; 
    complex deltamode_dynamic_current[3];   
    complex deltamode_PGenTotal;            
    complex power[3];       
    complex shunt[3];       
    complex current_dy[6];  
    complex power_dy[6];    
    complex shunt_dy[6];    
    complex *full_Y;        
    complex *full_Y_load;   
    complex *full_Y_all;    
    DYN_NODE_TYPE node_type;
    complex current12;      
    complex nom_res_curr[3];
    bool house_present;     
    bool dynamic_norton;    
    bool dynamic_generator; 
    complex *Triplex_Data;  
    complex *Extra_Data;    
    unsigned int NR_connected_links[2]; 
    unsigned int NR_number_child_nodes[2];  
    node **NR_child_nodes;  
    int *NR_link_table;     
    
    double mean_repair_time;    

    int NR_node_reference;      
    int *NR_subnode_reference;  
    unsigned char prev_phases;  

    inline bool is_split() {return (phases&PHASE_S)!=0;};
public:
    static CLASS *oclass;
    static CLASS *pclass;
    static node *defaults;
public:
    node(MODULE *mod);
    inline node(CLASS *cl=oclass):powerflow_object(cl){};
    int create(void);
    int init(OBJECT *parent=NULL);
    TIMESTAMP presync(TIMESTAMP t0);
    TIMESTAMP sync(TIMESTAMP t0);
    TIMESTAMP postsync(TIMESTAMP t0);
    int isa(char *classname);
    int notify(int update_mode, PROPERTY *prop, char *value);
    SIMULATIONMODE inter_deltaupdate_node(unsigned int64 delta_time, unsigned long dt, unsigned int iteration_count_val, bool interupdate_pos);

    //Functionalized portions for deltamode calls -- allows updates
    TIMESTAMP NR_node_presync_fxn(TIMESTAMP t0_val);
    void NR_node_sync_fxn(OBJECT *obj);
    void BOTH_node_postsync_fxn(OBJECT *obj);
    OBJECT *NR_master_swing_search(char *node_type_value,bool main_swing);

    void init_freq_dynamics(void);
    STATUS calc_freq_dynamics(double deltat);

    double perform_GFA_checks(double timestepvalue);

    STATUS link_VFD_functions(OBJECT *linkVFD);

    bool current_accumulated;

    int NR_populate(void);
    OBJECT *SubNodeParent;  
    int NR_current_update(bool parentcall);
    object TopologicalParent;   

    //NR bus status toggle function
    STATUS NR_swap_swing_status(bool desired_status);

    //Island-condition reset function
    STATUS reset_node_island_condition(void);

    //Function to map "internal powerflow iteration" current injection updates
    STATUS NR_map_current_update_function(OBJECT *callObj);

    friend class link_object;
    friend class meter; // needs access to current_inj
    friend class substation; //needs access to current_inj
    friend class triplex_node;  // Needs access to deltamode stuff
    friend class triplex_meter; // needs access to current_inj
    friend class triplex_load;  // Needs access to deltamode stuff
    friend class load;          // Needs access to deltamode_inclusive
    friend class capacitor;     // Needs access to deltamode stuff
    friend class fuse;          // needs access to current_inj
    friend class frequency_gen; // needs access to current_inj
    friend class motor; // needs access to curr_state

    static int kmlinit(int (*stream)(const char*,...));
    int kmldump(int (*stream)(const char*,...));
};

#endif // _NODE_H

---

GridLAB-D™ Version 4.1

An open-source smart grid simulator created by PNNL for the US Department of Energy Office of Electricity