core/rt/gridlabd.h

#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <time.h>
#include <stdarg.h>
#include <memory.h>
#include <float.h>
#include <string.h>

#ifdef _WINDOWS
#define isfinite _finite
#endif

#define int64 long long

typedef enum {I='i',J='j',A='d'} CNOTATION; 
#define CNOTATION_DEFAULT J /* never set this to A */
#define PI 3.1415926535897932384626433832795
#define E 2.71828182845905

/* only cpp code may actually do complex math */
class complex {
private:
    double r; 
    double i; 
    CNOTATION f; 
public:
    inline complex() 
    {
        r = 0;
        i = 0;
        f = CNOTATION_DEFAULT;
    };
    inline complex(double re) 
    {
        r = re;
        i = 0;
        f = CNOTATION_DEFAULT;
    };
    inline complex(double re, double im, CNOTATION nf=CNOTATION_DEFAULT) 
    {
        r = re;
        i = im;
        f = nf;
    };

    /* assignment operations */
    inline complex &operator = (complex x) 
    {
        r = x.r;
        i = x.i;
        f = x.f;
        return *this;
    };
    inline complex &operator = (double x) 
    {
        r = x;
        i = 0;
        f = CNOTATION_DEFAULT;
        return *this;
    };

    /* access operations */
    inline double & Re(void) 
    {
        return r;
    };
    inline double & Im(void) 
    {
        return i;
    };
    inline CNOTATION & Notation(void) 
    {
        return f;
    };
    inline double Mag(void) const 
    {
        return sqrt(r*r+i*i);
    };
    inline double Mag(double m)  
    {
        double old = sqrt(r*r+i*i);
        r *= m/old;
        i *= m/old;
        return m;
    };
    inline double Arg(void) const 
    {
        if (r==0)
        {
            if (i>0)
                return PI/2;
            else if (i==0)
                return 0;
            else
                return -PI/2;
        }
        else if (r>0)
            return atan(i/r);
        else
            return PI+atan(i/r);
    };
    inline double Arg(double a)  
    {
        SetPolar(Mag(),a,f);
        return a;
    };
    inline complex Log(void) const 
    {
        return complex(log(Mag()),Arg(),f);
    };
    inline void SetReal(double v) 
    {
        r = v;
    };
    inline void SetImag(double v) 
    {
        i = v;
    };
    inline void SetNotation(CNOTATION nf) 
    {
        f = nf;
    }
    inline void SetRect(double rp, double ip, CNOTATION nf=CNOTATION_DEFAULT) 
    {
        r = rp;
        i = ip;
        f = nf;
    };
    inline void SetPolar(double m, double a, CNOTATION nf=A) 
    {
        r = (m*cos(a));
        i = (m*sin(a));
        f = nf;
    };

#if 0
    //inline operator const double (void) const /**< cast real part to double */
    //{
    //  return r;
    //};
#endif

    inline complex operator - (void) 
    {
        return complex(-r,-i,f);
    };
    inline complex operator ~ (void) 
    {
        return complex(r,-i,f);
    };

    /* reflexive math operations */
    inline complex &operator += (double x) 
    {
        r += x;
        return *this;
    };
    inline complex &operator -= (double x) 
    {
        r -= x;
        return *this;
    };
    inline complex &operator *= (double x) 
    {
        r *= x;
        i *= x;
        return *this;
    };
    inline complex &operator /= (double x) 
    {
        r /= x;
        i /= x;
        return *this;
    };
    inline complex &operator ^= (double x) 
    {
        double lm = log(Mag()), a = Arg(), b = exp(x*lm), c = x*a;
        r = (b*cos(c));
        i = (b*sin(c));
        return *this;
    };
    inline complex &operator += (complex x) 
    {
        r += x.r;
        i += x.i;
        return *this;
    };
    inline complex &operator -= (complex x)  
    {
        r -= x.r;
        i -= x.i;
        return *this;
    };
    inline complex &operator *= (complex x)  
    {
        double pr=r;
        r = pr * x.r - i * x.i;
        i = pr * x.i + i * x.r;
        return *this;
    };
    inline complex &operator /= (complex y)  
    {
        double xr=r;
        double a = y.r*y.r+y.i*y.i;
        r = (xr*y.r+i*y.i)/a;
        i = (i*y.r-xr*y.i)/a;
        return *this;
    };
    inline complex &operator ^= (complex x) 
    {
        double lm = log(Mag()), a = Arg(), b = exp(x.r*lm-x.i*a), c = x.r*a+x.i*lm;
        r = (b*cos(c));
        i = (b*sin(c));
        return *this;
    };

    /* binary math operations */
    inline complex operator + (double y) 
    {
        complex x(*this);
        return x+=y;
    };
    inline complex operator - (double y) 
    {
        complex x(*this);
        return x-=y;
    };
    inline complex operator * (double y) 
    {
        complex x(*this);
        return x*=y;
    };
    inline complex operator / (double y) 
    {
        complex x(*this);
        return x/=y;
    };
    inline complex operator ^ (double y) 
    {
        complex x(*this);
        return x^=y;
    };
    inline complex operator + (complex y) 
    {
        complex x(*this);
        return x+=y;
    };
    inline complex operator - (complex y) 
    {
        complex x(*this);
        return x-=y;
    };
    inline complex operator * (complex y) 
    {
        complex x(*this);
        return x*=y;
    };
    inline complex operator / (complex y) 
    {
        complex x(*this);
        return x/=y;
    };
    inline complex operator ^ (complex y) 
    {
        complex x(*this);
        return x^=y;
    };

    inline complex SetPowerFactor(double mag, 
        double pf, 
        CNOTATION n=J) 
    {
        SetPolar(mag/pf, acos(pf),n);
        return *this;
    }


    /* comparison */
    inline bool IsZero(double err=0.0) 
    {
        return Mag()<=err;
    }

    /* magnitude comparisons */
    inline bool operator == (double m)  { return Mag()==m; };
    inline bool operator != (double m)  { return Mag()!=m; };
    inline bool operator < (double m)   { return Mag()<m; };
    inline bool operator <= (double m)  { return Mag()<=m; };
    inline bool operator > (double m)   { return Mag()>m; };
    inline bool operator >= (double m)  { return Mag()>=m; };

    /* angle comparisons */
    inline complex operator == (complex y)  { return fmod(y.Arg()-Arg(),2*PI)==0.0;};
    inline complex operator != (complex y)  { return fmod(y.Arg()-Arg(),2*PI)!=0.0;};
    inline complex operator < (complex y)   { return fmod(y.Arg()-Arg(),2*PI)<PI;};
    inline complex operator <= (complex y)  { return fmod(y.Arg()-Arg(),2*PI)<=PI;};
    inline complex operator > (complex y)   { return fmod(y.Arg()-Arg(),2*PI)>PI;};
    inline complex operator >= (complex y)  { return fmod(y.Arg()-Arg(),2*PI)>=PI;};
    inline bool IsFinite(void) { return isfinite(r) && isfinite(i); };
};

#ifdef REAL4
typedef float real;
#else
typedef double real;
#endif

typedef int64 TIMESTAMP;
#define TS_TPS ((int64)1)   /* ticks per second time resolution - this needs to be compatible with TS_SECOND is timestamp.h */
#define TS_REALNOW ((TIMESTAMP)(time(NULL))*TS_TPS)
#define TS_SIMNOW (*(callback->global_clock))
#define TS_ZERO ((int64)0)
#define Ts_INIT ((int64)3600*12) /* 12 hours after time zero to avoid negative timezone values */
#define TS_MAX (32482080000LL) /* roughly 3000 CE, any date beyond this should be interpreted as TS_NEVER */
#define TS_INVALID ((int64)-1)
#define TS_NEVER ((int64)(((unsigned int64)-1)>>1))
#define MINYEAR 1970
#define MAXYEAR 2969

inline TIMESTAMP gl_timestamp(double t) { return (TIMESTAMP)(t*TS_TPS);}
inline double gl_seconds(TIMESTAMP t) { return (double)t/(double)TS_TPS;}
inline double gl_minutes(TIMESTAMP t) { return (double)t/(double)(TS_TPS*60);}
inline double gl_hours(TIMESTAMP t) { return (double)t/(double)(TS_TPS*60*60);}
inline double gl_days(TIMESTAMP t) { return (double)t/(double)(TS_TPS*60*60*24);}
inline double gl_weeks(TIMESTAMP t) { return (double)t/(double)(TS_TPS*60*60*24*7);}

typedef union {
    struct {
        unsigned int calendar:4;
        unsigned int minute:20;
    };
    unsigned int index;
} SCHEDULEINDEX;

typedef char char1024[1025]; 
typedef char char256[257]; 
typedef char char32[33]; 
typedef char char8[9]; 
typedef char int8; 
typedef short int16; 
typedef int int32; /* 32-bit integers */
typedef long enumeration; /* enumerations (any one of a list of values) */
typedef TIMESTAMP timestamp;
typedef struct s_object_list* object; /* GridLAB objects */
typedef unsigned int64 set; /* sets (each of up to 64 values may be defined) */
typedef double triplet[3];
typedef complex triplex[3];

/* int64 is already defined in platform.h */
typedef enum {_PT_FIRST=-1,
    PT_void, 
    PT_double, 
    PT_complex, 
    PT_enumeration, 
    PT_set, 
    PT_int16, 
    PT_int32, 
    PT_int64, 
    PT_char8, 
    PT_char32, 
    PT_char256, 
    PT_char1024, 
    PT_object, 
    PT_delegated, 
    PT_bool, 
    PT_timestamp, 
    PT_double_array, 
    PT_complex_array, 
/*  PT_object_array, */ 
    PT_float,   
    PT_real,    
    PT_loadshape,   
    PT_enduse,      
#ifdef USE_TRIPLETS
    PT_triple, 
    PT_triplex, 
#endif
    _PT_LAST,
    /* never put these before _PT_LAST they have special uses */
    PT_AGGREGATE, /* internal use only */
    PT_KEYWORD, /* used to add an enum/set keyword definition */
    PT_ACCESS, /* used to specify property access rights */
    PT_SIZE, /* used to setup arrayed properties */
    PT_FLAGS, /* used to indicate property flags next */
    PT_INHERIT, /* used to indicate that properties from a parent class are to be published */
    PT_UNITS, /* used to indicate that property has certain units (which following immediately as a string) */
    PT_DESCRIPTION, /* used to provide helpful description of property */
    PT_EXTEND, /* used to enlarge class size by the size of the current property being mapped */
    PT_EXTENDBY, /* used to enlarge class size by the size provided in the next argument */
} PROPERTYTYPE; 
typedef char CLASSNAME[64]; 
typedef unsigned int OBJECTRANK; 
typedef unsigned short OBJECTSIZE; 
typedef unsigned int OBJECTNUM; 
typedef char * OBJECTNAME; 
typedef char FUNCTIONNAME[64]; 
typedef void* PROPERTYADDR; 
typedef char PROPERTYNAME[64]; 
typedef enum {
    PA_PUBLIC, 
    PA_REFERENCE, 
    PA_PROTECTED, 
    PA_PRIVATE, 
} PROPERTYACCESS; 
typedef int64 (*FUNCTIONADDR)(void*,...); 
typedef struct s_unit UNIT;
typedef struct s_delegatedtype DELEGATEDTYPE;
typedef struct s_delegatedvalue DELEGATEDVALUE;
typedef DELEGATEDVALUE* delegated; /* delegated data type */
typedef struct s_object_list OBJECT;
typedef struct s_module_list MODULE;
typedef struct s_class_list CLASS;
typedef struct s_property_map PROPERTY;
typedef struct s_function_map FUNCTION;
typedef struct s_schedule SCHEDULE;
typedef struct s_loadshape_core loadshape;
typedef struct s_enduse enduse;

#define MAXBLOCKS 4
#define MAXVALUES 64

/* pass configuration */
typedef unsigned char PASSCONFIG; 
#define PC_NOSYNC 0x00                  
#define PC_PRETOPDOWN 0x01              
#define PC_BOTTOMUP 0x02                
#define PC_POSTTOPDOWN 0x04             
#define PC_FORCE_NAME 0x20              
#define PC_PARENT_OVERRIDE_OMIT 0x40    
#define PC_UNSAFE_OVERRIDE_OMIT 0x80    
#ifndef FALSE
#define FALSE (0)
#define TRUE (!FALSE)
#endif

typedef enum {FAILED=FALSE, SUCCESS=TRUE} STATUS;

typedef struct s_globalvar {
    char name[256];
    PROPERTY *prop;
    struct s_globalvar *next;
    unsigned long flags;
} GLOBALVAR;

typedef enum {
    NM_PREUPDATE = 0, 
    NM_POSTUPDATE = 1, 
    NM_RESET = 2,
} NOTIFYMODULE; 
#include "setjmp.h"
typedef struct s_exception_handler {
    int id; 
    jmp_buf buf; 
    char msg[1024]; 
    struct s_exception_handler *next; 
} EXCEPTIONHANDLER; 
typedef struct s_keyword KEYWORD;

typedef unsigned long PROPERTYFLAGS;
#define PF_RECALC   0x0001 
#define PF_CHARSET  0x0002 
struct s_property_map {
    CLASS *oclass; 
    PROPERTYNAME name; 
    PROPERTYTYPE ptype; 
    unsigned long size; 
    PROPERTYACCESS access; 
    UNIT *unit; 
    PROPERTYADDR addr; 
    DELEGATEDTYPE *delegation; 
    KEYWORD *keywords; 
    char *description; 
    PROPERTY *next; 
    PROPERTYFLAGS flags; 
}; 
struct s_unit {
    char name[64];      
    double c,e,h,k,m,s,a,b; 
    int prec; 
    UNIT *next; 
}; 
struct s_delegatedtype {
    char32 type; 
    CLASS *oclass; 
    int (*from_string)(void *addr, char *value); 
    int (*to_string)(void *addr, char *value, int size); 
}; 
struct s_delegatedvalue {
    char *data; 
    DELEGATEDTYPE *type; 
}; 
struct s_keyword {
    char name[32];
    unsigned long value;
    struct s_keyword *next;
};
struct s_module_list {
    void *hLib;
    char name[1024];
    CLASS *oclass;
    unsigned short major;
    unsigned short minor;
    void* (*getvar)(char *varname,char *value,unsigned int size);
    int (*setvar)(char *varname,char *value);
    int (*import_file)(char *file);
    int (*export_file)(char *file);
    int (*check)();
#ifndef _NO_CPPUNIT
    int (*module_test)(void *callbacks,int argc,char* argv[]);
#endif
    int (*cmdargs)(int,char**);
    int (*kmldump)(FILE*fp,OBJECT*);
    void (*test)(int argc, char *argv[]);
    MODULE *(*subload)(char *, MODULE **, CLASS **, int, char **);
    PROPERTY *globals;
    MODULE *next;
};

typedef enum {CLASSVALID=0xc44d822e} CLASSMAGIC; 

struct s_class_list {
    CLASSMAGIC magic;
    CLASSNAME name;
    unsigned int size;
    MODULE *module;
    PROPERTY *pmap;
    FUNCTION *fmap;
    FUNCTIONADDR create;
    FUNCTIONADDR init;
    FUNCTIONADDR sync;
    FUNCTIONADDR commit;
    FUNCTIONADDR notify;
    FUNCTIONADDR isa;
    FUNCTIONADDR plc;
    PASSCONFIG passconfig;
    FUNCTIONADDR recalc;
    CLASS *parent;          
    struct {
        int32 numobjs;
        int64 clocks;
        int32 count;
    } profiler;
    CLASS *next;
};

typedef char FULLNAME[1024]; 
typedef struct s_namespace {
    FULLNAME name;
    struct s_namespace *next;
} NAMESPACE; 

struct s_object_list {
    OBJECTNUM id; 
    char32 groupid;
    CLASS *oclass; 
    OBJECT *next; 
    OBJECT *parent; 
    OBJECTRANK rank; 
    TIMESTAMP clock; 
    TIMESTAMP valid_to; 
    double latitude, longitude; 
    TIMESTAMP in_svc, 
        out_svc; 
    OBJECTNAME name;
    int tp_affinity; 
    NAMESPACE *space; 
    unsigned long flags; 
    /* IMPORTANT: flags must be last */
}; 
struct s_function_map {
    CLASS *oclass; 
    FUNCTIONNAME name; 
    FUNCTIONADDR addr; 
    FUNCTION *next; 
}; 

typedef struct s_datetime { 
    unsigned short year; 
    unsigned short month; 
    unsigned short day; 
    unsigned short hour; 
    unsigned short minute; 
    unsigned short second; 
    unsigned int microsecond; 
    unsigned short is_dst; 
    char tz[5]; 
    unsigned short weekday; 
    unsigned short yearday; 
    TIMESTAMP timestamp; 
} DATETIME; 

struct s_schedule {
    char name[64];                      
    char definition[65536];             
    char blockname[MAXBLOCKS][64];      
    unsigned char block;                
    unsigned char index[14][366*24*60]; 
    unsigned long dtnext[14][366*24*60];
    double data[MAXBLOCKS*MAXVALUES];   
    unsigned int weight[MAXBLOCKS*MAXVALUES];   
    double sum[MAXBLOCKS];              
    double abs[MAXBLOCKS];              
    unsigned int count[MAXBLOCKS];      
    unsigned int minutes[MAXBLOCKS];    
    TIMESTAMP next_t;                   
    double value;                       
    double duration;                    
    int flags;                          
    SCHEDULE *next; /* next schedule in list */
};

typedef enum {
    MT_UNKNOWN=0,
    MT_ANALOG,      
    MT_PULSED,      
    MT_MODULATED,   
    MT_QUEUED,      
} MACHINETYPE; 
typedef enum {
    MPT_UNKNOWN=0,
    MPT_TIME,       
    MPT_POWER,      
} MACHINEPULSETYPE; 
struct s_loadshape_core {
    double load;        
    /* machine specification */
    SCHEDULE *schedule; 
    MACHINETYPE type;   
    union {
        struct {
            double energy;      
        } analog;
        struct {
            double energy;      
            double scalar;      
            MACHINEPULSETYPE pulsetype; 
            double pulsevalue;  
        } pulsed;
        struct {
            double energy;      
            double scalar;      
            MACHINEPULSETYPE pulsetype; 
            double pulsevalue;  
        } modulated;
        struct {
            double energy;      
            double scalar;      
            MACHINEPULSETYPE pulsetype; 
            double pulsevalue;  
            double q_on, q_off; 
        } queued;
    } params;   
    /* internal machine parameters */
    double r;           
    double re[2];       
    double d[2];        
    double de[2];       
    double dPdV;        
    /* state variables */
    double q;           
    unsigned int s;     
    TIMESTAMP t0;   
    TIMESTAMP t2;   
    loadshape *next;    /* next loadshape in list */
};

struct s_enduse {
    loadshape *shape;
    complex power;              /* power in kW */
    complex energy;             /* total energy in kWh */
    complex demand;             /* maximum power in kW (can be reset) */
    double impedance_fraction;  /* constant impedance fraction (pu load) */
    double current_fraction;    /* constant current fraction (pu load) */
    double power_fraction;      /* constant power fraction (pu load)*/
    double power_factor;        /* power factor */
    double voltage_factor;      /* voltage factor (pu nominal) */
    double heatgain;            /* internal heat from load (Btu/h) */
    double heatgain_fraction;   /* fraction of power that goes to internal heat (pu Btu/h) */

    enduse *next;
};

typedef enum {
    RT_INVALID=-1,  
    RT_DEGENERATE,  
    RT_UNIFORM,     
    RT_NORMAL,      
    RT_LOGNORMAL,   
    RT_BERNOULLI,   
    RT_PARETO,      
    RT_EXPONENTIAL, 
    RT_SAMPLED,     
    RT_RAYLEIGH,    
    RT_WEIBULL,     
} RANDOMTYPE; 

typedef struct s_callbacks {
    TIMESTAMP *global_clock;
    int (*output_verbose)(char *format, ...);
    int (*output_message)(char *format, ...);
    int (*output_warning)(char *format, ...);
    int (*output_error)(char *format, ...);
    int (*output_debug)(char *format, ...);
    int (*output_test)(char *format, ...);
    CLASS *(*register_class)(MODULE *,CLASSNAME,unsigned int,PASSCONFIG);
    struct {
        OBJECT *(*single)(CLASS*);
        OBJECT *(*array)(CLASS*,unsigned int);
        OBJECT *(*foreign)(OBJECT *obj);
    } create;
    int (*define_map)(CLASS*,...);
    CLASS *(*class_getname)(char*);
    struct {
        FUNCTION *(*define)(CLASS*,FUNCTIONNAME,FUNCTIONADDR);
        FUNCTIONADDR (*get)(char*,char*);
    } function;
    int (*define_enumeration_member)(CLASS*,char*,char*,enumeration);
    int (*define_set_member)(CLASS*,char*,char*,unsigned long);
    int (*set_dependent)(OBJECT*,OBJECT*);
    int (*set_parent)(OBJECT*,OBJECT*);
    int (*set_rank)(OBJECT*,unsigned int);
    struct {
        PROPERTY *(*get_property)(OBJECT*,PROPERTYNAME);
        int (*set_value_by_addr)(OBJECT *, void*, char*,PROPERTY*);
        int (*get_value_by_addr)(OBJECT *, void*, char*, int size,PROPERTY*);
        int (*set_value_by_name)(OBJECT *, char*, char*);
        int (*get_value_by_name)(OBJECT *, char*, char*, int size);
        OBJECT *(*get_reference)(OBJECT *, char*);
        char *(*get_unit)(OBJECT *, char *);
        void *(*get_addr)(OBJECT *, char *);
        int (*set_value_by_type)(PROPERTYTYPE,void *data,char *);
    } properties;
    struct {
        struct s_findlist *(*objects)(struct s_findlist *,...);
        OBJECT *(*next)(struct s_findlist *,OBJECT *obj);
        struct s_findlist *(*copy)(struct s_findlist *);
        void (*add)(struct s_findlist*, OBJECT*);
        void (*del)(struct s_findlist*, OBJECT*);
        void (*clear)(struct s_findlist*);
    } find;
    PROPERTY *(*find_property)(CLASS *, PROPERTYNAME);
    void *(*malloc)(size_t);
    void (*free)(void*);
    struct s_aggregate *(*create_aggregate)(char *aggregator, char *group_expression);
    double (*run_aggregate)(struct s_aggregate *aggregate);
    double *(*get_module_var)(MODULE *module, char *varname);
    int (*depends)(char *name, unsigned char major, unsigned char minor, unsigned short build);
    struct {
        double (*uniform)(double a, double b);
        double (*normal)(double m, double s);
        double (*bernoulli)(double p);
        double (*pareto)(double m, double a);
        double (*lognormal)(double m, double s);
        double (*sampled)(unsigned int n, double *x);
        double (*exponential)(double l);
        RANDOMTYPE (*type)(char *name);
        double (*value)(RANDOMTYPE type, ...);
        double (*pseudo)(RANDOMTYPE type, unsigned int *state, ...);
        double (*triangle)(double a, double b);
        double (*beta)(double a, double b);
        double (*gamma)(double a);
        double (*weibull)(double a, double b);
        double (*rayleigh)(double a);
    } random;
    int (*object_isa)(OBJECT *obj, char *type);
    DELEGATEDTYPE* (*register_type)(CLASS *oclass, char *type,int (*from_string)(void*,char*),int (*to_string)(void*,char*,int));
    int (*define_type)(CLASS*,DELEGATEDTYPE*,...);
    struct {
        TIMESTAMP (*mkdatetime)(DATETIME *dt);
        int (*strdatetime)(DATETIME *t, char *buffer, int size);
        double (*timestamp_to_days)(TIMESTAMP t);
        double (*timestamp_to_hours)(TIMESTAMP t);
        double (*timestamp_to_minutes)(TIMESTAMP t);
        double (*timestamp_to_seconds)(TIMESTAMP t);
        int (*local_datetime)(TIMESTAMP ts, DATETIME *dt);
        TIMESTAMP (*convert_to_timestamp)(char *value);
        int (*convert_from_timestamp)(TIMESTAMP ts, char *buffer, int size);
    } time;
    int (*unit_convert)(char *from, char *to, double *value);
    int (*unit_convert_ex)(UNIT *pFrom, UNIT *pTo, double *pValue);
    UNIT *(*unit_find)(char *unit_name);
    struct {
        EXCEPTIONHANDLER *(*create_exception_handler)();
        void (*delete_exception_handler)(EXCEPTIONHANDLER *ptr);
        void (*throw_exception)(char *msg, ...);
        char *(*exception_msg)(void);
    } exception;
    struct {
        GLOBALVAR *(*create)(char *name, ...);
        STATUS (*setvar)(char *def,...);
        char *(*getvar)(char *name, char *buffer, int size);
        GLOBALVAR *(*find)(char *name);
    } global;
#ifndef NOLOCKS
    int64 *lock_count, *lock_spin;
#endif
    struct {
        char *(*find_file)(char *name, char *path, int mode);
    } file;
    struct s_objvar_struct {
        complex *(*complex_var)(OBJECT *obj, PROPERTY *prop);
        enumeration *(*enum_var)(OBJECT *obj, PROPERTY *prop);
        int16 *(*int16_var)(OBJECT *obj, PROPERTY *prop);
        int32 *(*int32_var)(OBJECT *obj, PROPERTY *prop);
        int64 *(*int64_var)(OBJECT *obj, PROPERTY *prop);
        double *(*double_var)(OBJECT *obj, PROPERTY *prop);
        char *(*string_var)(OBJECT *obj, PROPERTY *prop);
        OBJECT *(*object_var)(OBJECT *obj, PROPERTY *prop);
    } objvar;
    struct s_objvar_name_struct {
        complex *(*complex_var)(OBJECT *obj, char *name);
        enumeration *(*enum_var)(OBJECT *obj, char *name);
        int16 *(*int16_var)(OBJECT *obj, char *name);
        int32 *(*int32_var)(OBJECT *obj, char *name);
        int64 *(*int64_var)(OBJECT *obj, char *name);
        double *(*double_var)(OBJECT *obj, char *name);
        char *(*string_var)(OBJECT *obj, char *name);
    } objvarname;
    struct {
        int (*string_to_property)(PROPERTY *prop, void *addr, char *value);
        int (*property_to_string)(PROPERTY *prop, void *addr, char *value, int size);
    } convert;
    MODULE *(*module_find)(char *name);
    OBJECT *(*get_object)(char *name);
    int (*name_object)(OBJECT *obj, char *buffer, int len);
    int (*get_oflags)(KEYWORD **extflags);
    unsigned int (*object_count)(void);
    struct {
        SCHEDULE *(*create)(char *name, char *definition);
        SCHEDULEINDEX (*index)(SCHEDULE *sch, TIMESTAMP ts);
        double (*value)(SCHEDULE *sch, SCHEDULEINDEX index);
        long (*dtnext)(SCHEDULE *sch, SCHEDULEINDEX index);
        SCHEDULE *(*find)(char *name);
    } schedule;
    struct {
        int (*create)(loadshape *s);
        int (*init)(loadshape *s);
    } loadshape;
    struct {
        int (*create)(struct s_enduse *e);
        TIMESTAMP (*sync)(enduse *e, PASSCONFIG pass, TIMESTAMP t0, TIMESTAMP t1);
    } enduse;
    struct {
        double (*linear)(double t, double x0, double y0, double x1, double y1);
        double (*quadratic)(double t, double x0, double y0, double x1, double y1, double x2, double y2);
    } interpolate;
} CALLBACKS; 
extern CALLBACKS *callback;

typedef FUNCTIONADDR function;

#define gl_verbose (*callback->output_verbose) 
#define gl_output (*callback->output_message) 
#define gl_warning (*callback->output_warning) 
#define gl_error (*callback->output_error) 
#ifdef _DEBUG
#define gl_debug (*callback->output_debug) 
#else
#define gl_debug
#endif
#define gl_testmsg (*callback->output_test) 

#define gl_globalclock (*(callback->global_clock)) 

inline char* gl_name(OBJECT *my) 
{
    static char buffer[1024];
    if (my->name==NULL)
        sprintf(buffer,"%s:%d", my->oclass->name, my->id);
    else
        sprintf(buffer,"%s", my->name);
    return buffer;
}

inline void gl_throw(char *msg, ...) 
{
    va_list ptr;
    va_start(ptr,msg);
    static char buffer[1024];
    vsprintf(buffer,msg,ptr);
    throw buffer;
    va_end(ptr);
}

inline char *gl_global_getvar(char *name) 
{
    return callback->global.getvar(name,NULL,0);
}

inline OBJECT *gl_create_object(CLASS *oclass) 
{
    return (*callback->create.single)(oclass);
}

inline OBJECT *gl_create_foreign(OBJECT *obj) {return (*callback->create.foreign)(obj);};

inline int gl_set_parent(OBJECT *obj, 
                         OBJECT *parent) 
{
    return (*callback->set_parent)(obj,parent);
}

inline int gl_set_rank(OBJECT* obj, 
                       unsigned int rank) 
{
    return (*callback->set_rank)(obj,rank);
}

inline void *gl_get_addr(OBJECT *obj, 
                         char *name) 
{
    return callback->properties.get_addr(obj,name);
}

template <class T> inline void gl_get_value(OBJECT *obj, 
                                            char *propname, 
                                            T &value) 
{
    T *ptr = (T*)gl_get_addr(obj,propname);
    // @todo it would be a good idea to check the property type here
    if (ptr==NULL)
        gl_throw("property %s not found in object %s", propname, gl_name(obj));
    value = *ptr;
}

template <class T> inline void gl_set_value(OBJECT *obj, 
                                            char *propname, 
                                            T &value) 
{
    T *ptr = (T*)gl_get_addr(obj,propname);
    // @todo it would be a good idea to check the property type here
    if (ptr==NULL)
        gl_throw("property %s not found in object %s", propname, gl_name(obj));
    *ptr = value;
}

inline FUNCTIONADDR gl_get_function(OBJECT *obj, char *fname) { return callback->function.get(obj->oclass->name,fname);};
inline FUNCTIONADDR gl_get_function(CLASS *oclass, char *fname) { return callback->function.get(oclass->name,fname);};
inline FUNCTIONADDR gl_get_function(char *classname, char *fname) { return callback->function.get(classname,fname);};

inline double gl_random_uniform(const double lo, const double hi) { return callback->random.uniform(lo,hi);};
inline double gl_random_normal(const double mu, const double sigma) { return callback->random.normal(mu,sigma);};
inline double gl_random_lognormal(const double gmu, const double gsigma) { return callback->random.lognormal(gmu,gsigma);};
inline double gl_random_exponential(const double lambda) { return callback->random.exponential(lambda);};
inline double gl_random_pareto(const double m, const double k) { return callback->random.pareto(m,k);};
inline double gl_random_bernoulli(double p) { return callback->random.bernoulli(p);};
inline double gl_random_sampled(unsigned int n, double *x) { return callback->random.sampled(n,x);};
inline double gl_random_triangle(double a, double b) { return callback->random.triangle(a,b);};
inline double gl_random_beta(double a, double b) { return callback->random.beta(a,b);};
inline double gl_random_gamma(double a) { return callback->random.gamma(a);};
inline double gl_random_weibull(double a, double b) { return callback->random.weibull(a,b);};
inline double gl_random_rayleigh(double a) { return callback->random.rayleigh(a);};

inline bool gl_object_isa(OBJECT *obj, char *type) { return callback->object_isa(obj,type)==1;};
inline DATETIME *gl_localtime(TIMESTAMP ts,DATETIME *dt) { return callback->time.local_datetime(ts,dt)?dt:NULL;};
inline TIMESTAMP gl_mkdatetime(DATETIME *dt) { return callback->time.mkdatetime(dt);};
inline TIMESTAMP gl_mkdatetime(short year, short month, short day, short hour=0, short minute=0, short second=0, char *tz=NULL, short usec=0)
{
    DATETIME dt;
    dt.year = year;
    dt.month = month;
    dt.day = day;
    dt.hour = hour;
    dt.minute = minute;
    dt.second = second;
    dt.microsecond = usec;
    strncpy(dt.tz,tz,sizeof(dt.tz));
    return callback->time.mkdatetime(&dt);
};

inline int gl_unit_convert(char *from, char *to, double &value) { return callback->unit_convert(from, to, &value);};
inline int gl_unit_convert(UNIT *from, UNIT *to, double &value) { return callback->unit_convert_ex(from, to, &value);};
inline UNIT *gl_unit_find(char *name) { return callback->unit_find(name);};
inline char *gl_find_file(char *name, char *path, int mode) { return callback->file.find_file(name,path,mode); };

#define gl_printtime (*callback->time.convert_from_timestamp)

inline char *gl_strftime(DATETIME *dt, char *buffer, int size) { return callback->time.strdatetime(dt,buffer,size)?buffer:NULL;};
inline char *gl_strftime(TIMESTAMP ts)
{
    static char buffer[64];
    strcpy(buffer,"(invalid time)");
    DATETIME dt;
    gl_localtime(ts,&dt);
    gl_strftime(&dt,buffer,sizeof(buffer));
    return buffer;
}

inline void trace(char *fn, OBJECT *obj)
{
    callback->output_message("TRACE: %s(%s[%s:%d])", fn, obj->name?obj->name:"<unnamed>", obj->oclass->name,obj->id);
}

inline void *gl_malloc(size_t size) { return callback->malloc(size);};
inline void gl_free(void *ptr) { return callback->free(ptr);};

#define gl_find_objects (*callback->find.object)
inline OBJECT *gl_find_next(struct s_findlist *list,OBJECT *obj) { return callback->find.next(list,obj);};
inline struct s_findlist *gl_find_copy(struct s_findlist *list) { return callback->find.copy(list);};
inline void gl_find_add(struct s_findlist *list, OBJECT *obj) { callback->find.add(list,obj);};
inline void gl_find_del(struct s_findlist *list, OBJECT *obj) { callback->find.del(list,obj);};
inline void gl_find_clear(struct s_findlist *list) { callback->find.clear(list);};

inline SCHEDULE *gl_schedule_create(char *name, char *definition)
{
    return callback->schedule.create(name,definition);
}

inline SCHEDULEINDEX gl_schedule_index(SCHEDULE *sch, TIMESTAMP ts)
{
    return callback->schedule.index(sch,ts);
}

inline double gl_schedule_value(SCHEDULE *sch, SCHEDULEINDEX index)
{
    return callback->schedule.value(sch,index);
}

inline long gl_schedule_dtnext(SCHEDULE *sch, SCHEDULEINDEX index)
{
    return callback->schedule.dtnext(sch,index);
}

inline TIMESTAMP gl_enduse_sync(enduse *e, TIMESTAMP t1)
{
    return callback->enduse.sync(e,PC_BOTTOMUP,*(callback->global_clock),t1);
}

---

GridLAB-D^TM Version 2.0

An open-source project initiated by the US Department of Energy