tape/shaper.c

Go to the documentation of this file.

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include "gridlabd.h"
#include "object.h"
#include "aggregate.h"

#include "tape.h"
#include "file.h"
#include "odbc.h"


CLASS *shaper_class = NULL;
static OBJECT *last_shaper = NULL;

EXPORT int create_shaper(OBJECT **obj, OBJECT *parent)
{
    *obj = gl_create_object(shaper_class,sizeof(struct shaper));
    if (*obj!=NULL)
    {
        struct shaper *my = OBJECTDATA(*obj,struct shaper);
        last_shaper = *obj;
        gl_set_parent(*obj,parent);
        strcpy(my->file,"");
        strcpy(my->filetype,"txt");
        strcpy(my->property,"");
        strcpy(my->group,"");
        my->loopnum = 0;
        my->status = TS_INIT;
        my->targets = NULL;
        memset(my->shape,0,sizeof(my->shape));
        my->scale = 0.0;    /* scale of shape values */
        my->magnitude = 1.0;    /* magnitude of 1 event (only used when QUEUE is enabled) */
        my->step = 3600;    /* one hour shape steps */
        my->interval = 24; /* one day unit integral of shape */
        my->events = 0;     /* no events by default (disables QUEUE) */
        return 1;
    }
    return 0;
}

static int shaper_open(OBJECT *obj)
{
    char32 type="file";
    char1024 fname="";
    char32 flags="r";
    struct shaper *my = OBJECTDATA(obj,struct shaper);
    
    /* if prefix is omitted (no colons found) */
    if (sscanf(my->file,"%32[^:]:%1024[^:]:%[^:]",type,fname,flags)==1)
    {
        /* filename is file by default */
        strcpy(fname,my->file);
        strcpy(type,"file");
    }

    /* if no filename given */
    if (strcmp(fname,"")==0)

        /* use object name-id as default file name */
        sprintf(fname,"%s-%d.%s",obj->parent->oclass->name,obj->parent->id, my->filetype);

    /* if type is file or file is stdin */
    my->ops = get_ftable(type)->shaper;
    if(my->ops == NULL)
        return 0;
    return my->ops->open(my, fname, flags);
}

static void rewind_shaper(struct shaper *my)
{
    my->ops->rewind(my);
}

static void close_shaper(struct shaper *my)
{
    my->ops->close(my);
}

static TIMESTAMP shaper_read(OBJECT *obj, TIMESTAMP t0, unsigned int n)
{
    struct shaper *my = OBJECTDATA(obj,struct shaper);
    TIMESTAMP t1 = TS_NEVER;

    /* determine shape time */
    time_t t = (time_t)(t0/TS_SECOND);
    struct tm *tval = localtime(&t); /* TODO: this should use machine local time, but sim local time */

    /* set the value at that time */
    if (my->events<=0) /* direct shape */
    {
        /* value is directly injected */
        my->targets[n].value = my->magnitude * my->shape[tval->tm_mon][tval->tm_mday][tval->tm_wday][tval->tm_hour] * my->scale;

        /* determine time of next change in shape */
        t1 = my->targets[n].ts = ((t0 / my->step) + 1)*my->step;
    }
    else /* shape queue */
    {
        /* value is added to queue */ 
        my->targets[n].value += my->shape[tval->tm_mon][tval->tm_mday][tval->tm_wday][tval->tm_hour] * my->scale * my->events;

        /* compute time to the start of the event */
        my->targets[n].ts = t0 + (TIMESTAMP)gl_random_uniform(0,my->step);
    }

    return my->targets[n].ts;
}

static TIMESTAMP shaper_update(OBJECT *obj, TIMESTAMP t0, unsigned int n)
{
    struct shaper *my = OBJECTDATA(obj,struct shaper);
    TIMESTAMP t1 = TS_NEVER;
    if (my->events<=0) /* direct shaper */
    {
        /* value is directly injected */
        *(my->targets[n].addr) = my->targets[n].value;
    }
    else if (*(my->targets[n].addr)==0 && gl_random_bernoulli(my->targets[n].value)==1) /* shape queue event starts */
    {   
        double event_size = gl_random_uniform(0,1);

        /* magnitude is fixed */
        *(my->targets[n].addr) = my->magnitude;

        /* integral determines time to end of 1 event */
        t1 = my->targets[n].ts = t0 + (TIMESTAMP)(event_size*my->step*my->interval/my->magnitude);
        my->targets[n].value-=event_size; /* remove event from queue */
    }
    else if (*(my->targets[n].addr)!=0 && t0==my->targets[n].ts) /* shape queue event ends */ 
    {   /* event ends */
        /* read next shape event */
        t1 = shaper_read(obj,t0,n);

        /* clear target value */
        *(my->targets[n].addr) = 0;
    }
    return t1;
}

EXPORT TIMESTAMP sync_shaper(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    struct shaper *my = OBJECTDATA(obj,struct shaper);
    TIMESTAMP t1 = TS_NEVER;
    if (my->status==TS_INIT)
        shaper_open(obj);
    if (my->status==TS_OPEN)
    {   
        /* build target list */
        if (my->targets==NULL && my->group[0]!='\0')
        {
            FINDLIST *object_list = gl_find_objects(FL_GROUP,my->group);
            OBJECT *item=NULL;
            int n=0;
            if (object_list==NULL || object_list->hit_count<=0)
            {
                gl_warning("shaper group '%s' is empty", my->group);
                my->status=TS_DONE;
                return TS_NEVER;
            }
            my->n_targets = object_list->hit_count;
            my->targets = (SHAPERTARGET*)gl_malloc(sizeof(SHAPERTARGET*)*my->n_targets);
            memset(my->targets,0,sizeof(SHAPERTARGET*)*my->n_targets);
            if (my->targets==NULL)
            {
                gl_error("shaper memory allocation failed!");
                my->status=TS_DONE;
                return TS_NEVER;
            }
            for ( ;(item=gl_find_next(object_list,item))!=NULL; n++)
            {
                PROPERTY *prop=gl_get_property(item,my->property);
                if (prop!=NULL)
                {
                    if (prop->ptype==PT_double)
                    {
                        TIMESTAMP tn;

                        /* get the address of the property */
                        my->targets[n].addr = (double*)(GETADDR(item,prop)); /* pointer => int64 */

                        /* get the next event */
                        tn = shaper_read(obj,t0,n);
                        if (tn<t1) t1=tn;
                    }
                    else
                        gl_warning("object %s:%d property %s is not a double", item->oclass->name,item->id, prop->name);
                }
            }
        }

        /* write to targets */
        if (my->targets!=NULL)
        {
            unsigned int n;
            for (n=0; n<my->n_targets; n++)
            {
                TIMESTAMP tn = TS_NEVER;

                /* get shape event/data */
                if (my->targets[n].ts==t0) 
                {
                    /* post the new value */
                    tn = shaper_update(obj,t0,n);

                    /* read the next value */
                    if (tn==TS_NEVER)
                        tn = shaper_read(obj,t0,n);
                }

                /* make sure caller knows next event time */
                else if (my->targets[n].ts<t1)
                    tn = my->targets[n].ts;

                /* keep track of "nextest" event */
                if (tn<t1) t1=tn;
            }
        }
    }
    obj->clock = t0;
    return t1!=TS_NEVER?-t1:TS_NEVER; /* negative indicates a "soft" event which is only considered for stepping, not for stopping */
}

---

GridLAB-D^TM Version 1.0

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