powerflow/motor.cpp

// $Id: capacitor.cpp 1182 2008-12-22 22:08:36Z dchassin $
//  Copyright (C) 2008 Battelle Memorial Institute

#include <stdlib.h> 
#include <stdio.h>
#include <errno.h>
#include <math.h>

#include "motor.h"

// capacitor CLASS FUNCTIONS
CLASS* motor::oclass = NULL;
CLASS* motor::pclass = NULL;

motor::motor(MODULE *mod):node(mod)
{
    if(oclass == NULL)
    {
        pclass = node::oclass;
        
        oclass = gl_register_class(mod,"motor",sizeof(motor),PC_PRETOPDOWN|PC_BOTTOMUP|PC_POSTTOPDOWN|PC_UNSAFE_OVERRIDE_OMIT);
        if(oclass == NULL)
            GL_THROW("unable to register object class implemented by %s",__FILE__);

        if(gl_publish_variable(oclass,
            PT_INHERIT, "node",
            
            NULL) < 1) GL_THROW("unable to publish properties in %s",__FILE__);
    }
}

int motor::create()
{
    int result = node::create();
    return result;
}

int motor::init(OBJECT *parent)
{
    int result = node::init();

    OBJECT *obj = OBJECTHDR(this);
    return result;
}
TIMESTAMP motor::presync(TIMESTAMP t0)
{
    return TS_NEVER;
}
TIMESTAMP motor::sync(TIMESTAMP t0)
{
    return TS_NEVER;
}
TIMESTAMP motor::postsync(TIMESTAMP t0)
{
    return TS_NEVER;
}
int motor::isa(char *classname)
{
    return strcmp(classname,"motor")==0 || node::isa(classname);
}

// IMPLEMENTATION OF CORE LINKAGE: motor

EXPORT int create_motor(OBJECT **obj, OBJECT *parent)
{
    try
    {
        *obj = gl_create_object(motor::oclass);
        if (*obj!=NULL)
        {
            motor *my = OBJECTDATA(*obj,motor);
            gl_set_parent(*obj,parent);
            return my->create();
        }
    }
    catch (const char *msg)
    {
        gl_error("create_induction_motor: %s", msg);
    }
    return 0;
}



EXPORT int init_motor(OBJECT *obj)
{
    motor *my = OBJECTDATA(obj,motor);
    try {
        return my->init(obj->parent);
    }
    catch (const char *msg)
    {
        GL_THROW("%s (motor:%d): %s", my->get_name(), my->get_id(), msg);
        return 0; 
    }
}

EXPORT TIMESTAMP sync_motor(OBJECT *obj, TIMESTAMP t0, PASSCONFIG pass)
{
    motor *pObj = OBJECTDATA(obj,motor);
    try {
        TIMESTAMP t1 = TS_NEVER;
        switch (pass) {
        case PC_PRETOPDOWN:
            return pObj->presync(t0);
        case PC_BOTTOMUP:
            return pObj->sync(t0);
        case PC_POSTTOPDOWN:
            t1 = pObj->postsync(t0);
            obj->clock = t0;
            return t1;
        default:
            throw "invalid pass request";
        }
    } catch (const char *error) {
        GL_THROW("%s (motor:%d): %s", pObj->get_name(), pObj->get_id(), error);
        return 0; 
    } catch (...) {
        GL_THROW("%s (motor:%d): %s", pObj->get_name(), pObj->get_id(), "unknown exception");
        return 0;
    }
}

EXPORT int isa_motor(OBJECT *obj, char *classname)
{
    return OBJECTDATA(obj,motor)->isa(classname);
}

---

GridLAB-D^TM Version 2.0

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