int collector::init(OBJECT *parent)
{
// check the connection
if ( get_connection()!=NULL )
db = (database*)(get_connection()+1);
if ( db==NULL )
exception("no database connection available or specified");
if ( !db->isa("database") )
exception("connection is not a mysql database");
gl_verbose("connection to mysql server '%s', schema '%s' ok", db->get_hostname(), db->get_schema());
// check mode
if ( strlen(mode)>0 )
{
options = 0xffffffff;
struct {
char *str;
set bits;
} modes[] = {
{"r", 0xffff},
{"r+", 0xffff},
{"w", MO_DROPTABLES},
{"w+", MO_DROPTABLES},
{"a", 0x0000},
{"a+", 0x0000},
};
int n;
for ( n=0 ; n<sizeof(modes)/sizeof(modes[0]) ; n++ )
{
if ( strcmp(mode,modes[n].str)==0 )
{
options = modes[n].bits;
break;
}
}
if ( options==0xffffffff )
exception("mode '%s' is not recognized",(const char*)mode);
else if ( options==0xffff )
exception("mode '%s' is not valid for a recorder", (const char*)mode);
}
// verify group is defined
if ( strcmp(get_group(),"")==0 )
exception("group must be specified");
// verify property is defined
if ( strcmp(get_property(),"")==0 )
exception("at least one property aggregation must be specified");
// copy property spec into working buffer
char1024 propspecs;
strcpy(propspecs,get_property());
// count properties in specs
char *p = propspecs;
n_aggregates = 0;
do {
n_aggregates++;
p = strchr(p,',');
} while (p++!=NULL);
list = new gld_aggregate[n_aggregates];
names = new char*[n_aggregates];
// load property structs
int n;
for ( p=propspecs,n=0 ; n<n_aggregates ; n++ )
{
char *np = strchr(p,',');
if ( np!=NULL ) *np='\0';
while ( *p!='\0' && isspace(*p) ) p++; // left trim
int len = strlen(p);
while ( len>0 && isspace(p[len-1]) ) p[--len]='\0'; // right trim
if ( !list[n].set_aggregate(p,get_group()) )
exception("unable to aggregate '%s' over group '%s'", p, get_group());
gl_debug("%s: group '%s' aggregate '%s' initial value is '%lf'", get_name(), get_group(), p, list[n].get_value());
names[n] = new char[strlen(p)+1];
strcpy(names[n],p);
p = np+1;
}
gl_debug("%s: %d aggregates ok", get_name(), n_aggregates);
// drop table if exists and drop specified
if ( db->table_exists(get_table()) )
{
if ( get_options()&MO_DROPTABLES && !db->query("DROP TABLE IF EXISTS `%s`", get_table()) )
exception("unable to drop table '%s'", get_table());
}
// create table if not exists
if ( !db->table_exists(get_table()) )
{
if ( !(options&MO_NOCREATE) )
{
char buffer[4096];
size_t eos = sprintf(buffer,"CREATE TABLE IF NOT EXISTS `%s` ("
"id INT AUTO_INCREMENT PRIMARY KEY, "
"t TIMESTAMP, ", get_table());
int n;
for ( n=0 ; n<n_aggregates ; n++ )
eos += sprintf(buffer+eos,"`%s` double, ",names[n]);
eos += sprintf(buffer+eos,"%s","INDEX i_t (t))");
if ( !db->query(buffer) )
exception("unable to create table '%s' in schema '%s'", get_table(), db->get_schema());
else
gl_verbose("table %s created ok", get_table());
}
else
exception("NOCREATE option prevents creation of table '%s'", get_table());
}
// check row count
else
{
if ( db->select("SELECT count(*) FROM `%s`", get_table())==NULL )
exception("unable to get row count of table '%s'", get_table());
gl_verbose("table '%s' ok", get_table());
}
// first event time
TIMESTAMP dt = (TIMESTAMP)get_interval();
if ( dt>0 )
next_t = (TIMESTAMP)(gl_globalclock/dt+1)*dt;
else if ( dt==0 )
next_t = TS_NEVER;
else
exception("%s: interval must be zero or positive");
// @todo use prepared statement instead of insert
// set heartbeat
if ( interval>0 )
set_heartbeat((TIMESTAMP)interval);
return 1;
}
TIMESTAMP house::sync_panel(TIMESTAMP t0, TIMESTAMP t1)
{
TIMESTAMP sync_time = TS_NEVER;
OBJECT *obj = OBJECTHDR(this);
// clear accumulators for panel currents
complex I[3]; I[X12] = I[X23] = I[X13] = complex(0,0);
// clear heatgain accumulator
double heatgain = 0;
// gather load power and compute current for each circuit
CIRCUIT *c;
for (c=panel.circuits; c!=NULL; c=c->next)
{
// get circuit type
int n = (int)c->type;
if (n<0 || n>2)
GL_THROW("%s:%d circuit %d has an invalid circuit type (%d)", obj->oclass->name, obj->id, c->id, (int)c->type);
/* TROUBLESHOOT
Invalid circuit types are an internal error for the house panel. Please report this error. The likely causes
include an object that is not a house is being processed by the house model, or the panel was not correctly
initialized.
*/
// if breaker is open and reclose time has arrived
if (c->status==BRK_OPEN && t1>=c->reclose)
{
c->status = BRK_CLOSED;
c->reclose = TS_NEVER;
sync_time = t1; // must immediately reevaluate devices affected
gl_debug("house:%d panel breaker %d closed", obj->id, c->id);
}
// if breaker is closed
if (c->status==BRK_CLOSED)
{
// compute circuit current
if ((c->pV)->Mag() == 0)
{
gl_debug("house:%d circuit %d (enduse %s) voltage is zero", obj->id, c->id, c->pLoad->name);
break;
}
complex current = ~(c->pLoad->total*1000 / *(c->pV));
// check breaker
if (c->max_amps>0 && current.Mag()>c->max_amps)
{
// probability of breaker failure increases over time
if (c->tripsleft>0 && gl_random_bernoulli(RNGSTATE,1/(c->tripsleft--))==0)
{
// breaker opens
c->status = BRK_OPEN;
// average five minutes before reclosing, exponentially distributed
c->reclose = t1 + (TIMESTAMP)(gl_random_exponential(RNGSTATE,1/300.0)*TS_SECOND);
gl_debug("house:%d circuit breaker %d tripped - enduse %s overload at %.0f A", obj->id, c->id,
c->pLoad->name, current.Mag());
}
// breaker fails from too frequent operation
else
{
c->status = BRK_FAULT;
c->reclose = TS_NEVER;
gl_debug("house:%d circuit breaker %d failed", obj->id, c->id);
}
// must immediately reevaluate everything
sync_time = t1;
}
// add to panel current
else
{
tload.power += c->pLoad->power; // reminder: |a| + |b| != |a+b|
tload.current += c->pLoad->current;
tload.admittance += c->pLoad->admittance; // should this be additive? I don't buy t.a = c->pL->a ... -MH
tload.total += c->pLoad->total;
tload.heatgain += c->pLoad->heatgain;
tload.energy += c->pLoad->power * gl_tohours(t1-t0);
I[n] += current;
c->reclose = TS_NEVER;
}
}
// sync time
if (sync_time > c->reclose)
sync_time = c->reclose;
}
// compute line currents and post to meter
if (obj->parent != NULL)
LOCK_OBJECT(obj->parent);
pLine_I[0] = I[X13];
pLine_I[1] = I[X23];
pLine_I[2] = 0;
*pLine12 = I[X12];
if (obj->parent != NULL)
UNLOCK_OBJECT(obj->parent);
return sync_time;
}
void
gl_ui_cmd_help_about (GtkAction *action,
glWindow *window)
{
static GtkWidget *about = NULL;
gchar *pixbuf_filename;
GdkPixbuf *pixbuf = NULL;
const gchar *authors[] = {
"Jim Evins",
" ",
_("Glabels includes contributions from:"),
"Mario Blättermann",
"Robin Stuart",
"Samuel Lown",
"Frederic Ruaudel",
"Wayne Schuller",
"Emmanuel Pacaud",
"Austin Henry",
" ",
_("See the file AUTHORS for additional credits,"),
_("or visit http://glabels.org/"),
NULL
};
const gchar *documenters[] = {
"Jim Evins",
"Mario Blättermann",
NULL
};
const gchar *artists[] = {
"Jim Evins",
NULL
};
const gchar *copy_text = "Copyright \xc2\xa9 2001-2010 Jim Evins";
const gchar *about_text = _("A label and business card creation program.\n");
const gchar *url = "http://glabels.org";
const gchar *translator_credits = _("translator-credits");
const gchar *license = _(
"gLabels is free software: you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation, either version 3 of the License, or\n"
"(at your option) any later version.\n"
"\n"
"gLabels is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n");
gl_debug (DEBUG_COMMANDS, "START");
g_return_if_fail (action && GTK_IS_ACTION(action));
g_return_if_fail (window && GL_IS_WINDOW(window));
if (about != NULL)
{
gtk_window_present (GTK_WINDOW (about));
gtk_window_set_transient_for (GTK_WINDOW (about),
GTK_WINDOW (window));
} else {
pixbuf_filename = g_build_filename (GLABELS_DATA_DIR, "pixmaps", "glabels-logo.png", NULL);
pixbuf = gdk_pixbuf_new_from_file (pixbuf_filename, NULL);
g_free (pixbuf_filename);
about = gtk_about_dialog_new ();
gtk_window_set_title (GTK_WINDOW(about), _("About glabels"));
gtk_about_dialog_set_program_name (GTK_ABOUT_DIALOG(about), "glabels");
gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about), VERSION);
gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG(about), copy_text);
gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG(about), about_text);
gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), url);
gtk_about_dialog_set_logo (GTK_ABOUT_DIALOG(about), pixbuf);
gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG(about), authors);
gtk_about_dialog_set_documenters (GTK_ABOUT_DIALOG(about), documenters);
gtk_about_dialog_set_artists (GTK_ABOUT_DIALOG(about), artists);
gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG(about), translator_credits);
gtk_about_dialog_set_license (GTK_ABOUT_DIALOG(about), license);
gtk_window_set_destroy_with_parent (GTK_WINDOW (about), TRUE);
g_signal_connect (G_OBJECT (about), "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (G_OBJECT (about), "destroy",
G_CALLBACK (gtk_widget_destroyed), &about);
gtk_window_set_transient_for (GTK_WINDOW (about),
GTK_WINDOW (window));
gtk_window_present (GTK_WINDOW (about));
if (pixbuf != NULL)
g_object_unref (pixbuf);
}
gl_debug (DEBUG_COMMANDS, "END");
}
/*--------------------------------------------------------------------------*/
void
gl_object_editor_prepare_line_page (glObjectEditor *editor)
{
gl_debug (DEBUG_EDITOR, "START");
/* Extract widgets from XML tree. */
gl_builder_util_get_widgets (editor->priv->builder,
"line_page_vbox", &editor->priv->line_page_vbox,
"line_width_spin", &editor->priv->line_width_spin,
"line_color_hbox", &editor->priv->line_color_hbox,
"line_key_hbox", &editor->priv->line_key_hbox,
"line_key_radio", &editor->priv->line_key_radio,
"line_color_radio", &editor->priv->line_color_radio,
NULL);
editor->priv->line_color_combo = gl_color_combo_new (_("No Line"),
GL_COLOR_NO_LINE,
gl_prefs_model_get_default_line_color (gl_prefs));
gtk_box_pack_start (GTK_BOX (editor->priv->line_color_hbox),
editor->priv->line_color_combo,
FALSE, FALSE, 0);
editor->priv->line_key_combo = gl_field_button_new (NULL);
gtk_box_pack_start (GTK_BOX (editor->priv->line_key_hbox),
editor->priv->line_key_combo,
TRUE, TRUE, 0);
/* Modify widgets based on configuration */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->priv->line_color_radio), TRUE);
gtk_widget_set_sensitive (editor->priv->line_color_combo, TRUE);
gtk_widget_set_sensitive (editor->priv->line_key_combo, FALSE);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->priv->line_width_spin),
gl_prefs_model_get_default_line_width (gl_prefs));
gl_color_combo_set_color (GL_COLOR_COMBO(editor->priv->line_color_combo),
gl_prefs_model_get_default_line_color (gl_prefs));
/* Un-hide */
gtk_widget_show_all (editor->priv->line_page_vbox);
/* Connect signals */
g_signal_connect_swapped (G_OBJECT (editor->priv->line_width_spin),
"changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->line_color_combo),
"color_changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->line_key_combo),
"changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->line_color_radio),
"toggled",
G_CALLBACK (line_radio_toggled_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->line_key_radio),
"toggled",
G_CALLBACK (line_radio_toggled_cb),
G_OBJECT (editor));
gl_debug (DEBUG_EDITOR, "END");
}
int ss_model::init(OBJECT *parent)
{
double val[256];
unsigned int n,m;
// determine n by scanning the x vector
n = scan_values(x,val,sizeof(val)/sizeof(val[0]));
if ( n==256 )
exception("no more than 256 states are permitted");
else if ( n==0 )
exception("at least one state must be defined");
else
dim.n = n;
// save the x vector
ss.x = new double[n];
memcpy(ss.x,val,sizeof(double)*n);
// scan the Y vector
tf.Y = new double[n];
if ( scan_values(Y,tf.Y,n)!=n )
exception("Y does not have the same number of values as x");
// scan the U vector
tf.U = new double[n];
if ( scan_values(U,tf.U,n)!=n )
exception("Y does not have the same number of values as x");
// scan the u references
input = new gld_property*[dim.n];
if ( scan_references(u,input,n)!=n )
exception("u does not have the same number of references as x has values");
// determine m by scanning the y vector
output = new gld_property*[n];
if ( (m=scan_references(y,output,n))!=1 )
exception("y may have only one reference");
dim.m = m;
// construct the A matrix
unsigned int i, j;
ss.A = new double*[n-1];
switch ( form ) {
case CF_OCF:
for ( i=0 ; i<n-1 ; i++ )
{
ss.A[i] = new double[n-1];
memset(ss.A[i],0,sizeof(double)*(n-1));
ss.A[i][0] = -tf.U[i+1];
ss.A[i][i+1] = 1;
}
break;
case CF_CCF:
// TODO
break;
}
// construct the B matrix
ss.B = new double*[n-1];
switch ( form ) {
case CF_OCF:
for ( i=0 ; i<n-1 ; i++ )
{
ss.B[i] = new double[m];
memset(ss.B[i],0,sizeof(double)*m);
for ( j=0 ; j<m ; j++ )
// TODO generalize for MIMO
ss.B[i][j] = tf.Y[i+1] - tf.U[i+1]*tf.Y[j];
}
break;
case CF_CCF:
// TODO
break;
}
// construct the C matrix
ss.C = new double*[m];
switch ( form ) {
case CF_OCF:
for ( i=0 ; i<m ; i++ )
{
ss.C[i] = new double[n-1];
memset(ss.C[i],0,sizeof(double)*(n-1));
ss.C[i][0] = 1;
}
break;
case CF_CCF:
// TODO
break;
}
ss.D = new double*[1];
switch ( form ) {
case CF_OCF:
ss.D[0] = new double[1];
// TODO generalize for MIMO
ss.D[0][0] = tf.Y[0];
case CF_CCF:
// TODO
break;
}
// link control vector
ss.u = new double*[n];
for ( i=0 ; i<n ; i++ )
ss.u[i] = (double*)input[i]->get_addr();
// link observation vector
ss.y = new double*[m];
for ( i=0 ; i<m ; i++ )
ss.y[i] = (double*)output[i]->get_addr();
// create xdot
ss.xdot = new double[n];
memset(ss.xdot,0,sizeof(ss.xdot));
// update H string (just descriptive)
int len=1;
H[0]='(';
for ( i=0 ; i<n ; i++ )
{
if ( tf.Y[i]!=0 )
if ( i<n-1 )
len += sprintf(H+len,"%+.3fs^%d",tf.Y[i],n-i-1);
else
len += sprintf(H+len,"%+.3f",tf.Y[i]);
}
len += sprintf(H+len,"%s",") / (");
for ( i=0 ; i<n ; i++ )
{
if ( tf.U[i]!=0 )
if ( i<n-1 )
len += sprintf(H+len,"%+.3fs^%d",tf.U[i],n-i-1);
else
len += sprintf(H+len,"%+.3f",tf.U[i]);
}
len += sprintf(H+len,"%s",")");
gl_debug("%s: H(s) = %s", get_name(), (char*)H);
// update A,B,C,D string (descriptive)
A[0]='['; B[0]='['; C[0]='['; D[0]='[';
for ( len=1,i=0 ; i<n-1 ; i++ )
{
for ( j=0 ; j<n-1 ; j++ )
len += sprintf(A+len," %.3f ", ss.A[i][j]);
if ( i<n-2 )
len += sprintf(A+len," %s",";");
}
strcat(A," ]");
for ( len=1,i=0 ; i<n-1 ; i++ )
{
len += sprintf(B+len," %.3f ", ss.B[i][0]);
}
strcat(B," ]");
for ( len=1,i=0 ; i<n-1 ; i++ )
{
len += sprintf(C+len," %.3f ", ss.C[0][i]);
}
strcat(C," ]");
sprintf(D+1," %.2f ]",ss.D[0]);
gl_debug("%s: A = %s", get_name(), (char*)A);
gl_debug("%s: B = %s", get_name(), (char*)B);
gl_debug("%s: C = %s", get_name(), (char*)C);
gl_debug("%s: D = %s", get_name(), (char*)D);
return 1;
}
void
gl_object_editor_set_bc_style (glObjectEditor *editor,
const glLabelBarcodeStyle *bc_style)
{
const gchar *backend_name;
const gchar *style_name;
gchar *ex_string;
gint format_digits;
gl_debug (DEBUG_EDITOR, "START");
gl_object_editor_load_bc_styles (editor, bc_style->backend_id);
g_signal_handlers_block_by_func (G_OBJECT (editor->priv->bc_backend_combo),
backend_changed_cb, editor);
g_signal_handlers_block_by_func (G_OBJECT (editor->priv->bc_style_combo),
style_changed_cb, editor);
g_signal_handlers_block_by_func (G_OBJECT (editor->priv->bc_text_check),
gl_object_editor_changed_cb, editor);
g_signal_handlers_block_by_func (G_OBJECT (editor->priv->bc_cs_check),
gl_object_editor_changed_cb, editor);
g_signal_handlers_block_by_func (G_OBJECT (editor->priv->data_digits_spin),
data_digits_spin_changed_cb, editor);
backend_name = gl_barcode_backends_backend_id_to_name (bc_style->backend_id);
style_name = gl_barcode_backends_style_id_to_name (bc_style->backend_id, bc_style->id);
gl_combo_util_set_active_text (GTK_COMBO_BOX (editor->priv->bc_backend_combo),
backend_name);
gl_combo_util_set_active_text (GTK_COMBO_BOX (editor->priv->bc_style_combo),
style_name);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->priv->bc_text_check),
bc_style->text_flag);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->priv->bc_cs_check),
bc_style->checksum_flag);
gtk_widget_set_sensitive (editor->priv->bc_text_check,
gl_barcode_backends_style_text_optional (bc_style->backend_id, bc_style->id));
gtk_widget_set_sensitive (editor->priv->bc_cs_check,
gl_barcode_backends_style_csum_optional (bc_style->backend_id, bc_style->id));
editor->priv->data_format_fixed_flag = !gl_barcode_backends_style_can_freeform (bc_style->backend_id, bc_style->id);
format_digits = bc_style->format_digits;
if (editor->priv->data_format_fixed_flag) {
format_digits = gl_barcode_backends_style_get_prefered_n (bc_style->backend_id, bc_style->id);
}
ex_string = gl_barcode_backends_style_default_digits (bc_style->backend_id, bc_style->id, format_digits);
gtk_label_set_text (GTK_LABEL(editor->priv->data_ex_label), ex_string);
g_free (ex_string);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->priv->data_digits_spin), format_digits);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (editor->priv->data_literal_radio))) {
gtk_widget_set_sensitive (editor->priv->data_format_label, FALSE);
gtk_widget_set_sensitive (editor->priv->data_ex_label, FALSE);
gtk_widget_set_sensitive (editor->priv->data_digits_label, FALSE);
gtk_widget_set_sensitive (editor->priv->data_digits_spin, FALSE);
} else {
gtk_widget_set_sensitive (editor->priv->data_format_label, TRUE);
gtk_widget_set_sensitive (editor->priv->data_ex_label, TRUE);
gtk_widget_set_sensitive (editor->priv->data_digits_label,
!editor->priv->data_format_fixed_flag);
gtk_widget_set_sensitive (editor->priv->data_digits_spin,
!editor->priv->data_format_fixed_flag);
}
g_signal_handlers_unblock_by_func (G_OBJECT (editor->priv->bc_backend_combo),
backend_changed_cb, editor);
g_signal_handlers_unblock_by_func (G_OBJECT (editor->priv->bc_style_combo),
style_changed_cb, editor);
g_signal_handlers_unblock_by_func (G_OBJECT (editor->priv->bc_text_check),
gl_object_editor_changed_cb, editor);
g_signal_handlers_unblock_by_func (G_OBJECT (editor->priv->bc_cs_check),
gl_object_editor_changed_cb, editor);
g_signal_handlers_unblock_by_func (G_OBJECT (editor->priv->data_digits_spin),
data_digits_spin_changed_cb, editor);
gl_debug (DEBUG_EDITOR, "END");
}
/*--------------------------------------------------------------------------*/
void
gl_object_editor_prepare_bc_page (glObjectEditor *editor)
{
GList *backends = NULL;
GList *p;
gl_debug (DEBUG_EDITOR, "START");
/* Extract widgets from XML tree. */
gl_builder_util_get_widgets (editor->priv->builder,
"bc_page_vbox", &editor->priv->bc_page_vbox,
"bc_backend_combo_hbox", &editor->priv->bc_backend_combo_hbox,
"bc_style_combo_hbox", &editor->priv->bc_style_combo_hbox,
"bc_text_check", &editor->priv->bc_text_check,
"bc_cs_check", &editor->priv->bc_cs_check,
"bc_color_hbox", &editor->priv->bc_color_hbox,
"bc_key_hbox", &editor->priv->bc_key_hbox,
"bc_key_radio", &editor->priv->bc_key_radio,
"bc_color_radio", &editor->priv->bc_color_radio,
"data_format_label", &editor->priv->data_format_label,
"data_ex_label", &editor->priv->data_ex_label,
"data_digits_label", &editor->priv->data_digits_label,
"data_digits_spin", &editor->priv->data_digits_spin,
NULL);
editor->priv->data_format_fixed_flag = FALSE;
editor->priv->bc_color_combo = gl_color_combo_new (_("Default"),
GL_COLOR_BC_DEFAULT,
gl_prefs_model_get_default_line_color (gl_prefs));
gtk_box_pack_start (GTK_BOX (editor->priv->bc_color_hbox),
editor->priv->bc_color_combo,
FALSE, FALSE, 0);
editor->priv->bc_key_combo = gl_field_button_new (NULL);
gtk_box_pack_start (GTK_BOX (editor->priv->bc_key_hbox),
editor->priv->bc_key_combo,
TRUE, TRUE, 0);
editor->priv->bc_backend_combo = gtk_combo_box_text_new ();
gtk_box_pack_start (GTK_BOX (editor->priv->bc_backend_combo_hbox),
editor->priv->bc_backend_combo,
TRUE, TRUE, 0);
editor->priv->bc_style_combo = gtk_combo_box_text_new ();
gtk_box_pack_start (GTK_BOX (editor->priv->bc_style_combo_hbox),
editor->priv->bc_style_combo,
TRUE, TRUE, 0);
/* Load barcode backends */
backends = gl_barcode_backends_get_backend_list ();
gl_combo_util_set_strings (GTK_COMBO_BOX_TEXT(editor->priv->bc_backend_combo),
backends);
/* Kludge: Load styles for each backend once, so that when they are loaded for real the size of
* of the widget has already been established and does't cause the sidebar to change size. */
for ( p = backends; p != NULL; p=p->next )
{
gl_object_editor_load_bc_styles (editor, gl_barcode_backends_backend_name_to_id ((gchar *)p->data));
}
gl_barcode_backends_free_backend_list (backends);
/* Modify widgets */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->priv->bc_color_radio), TRUE);
gtk_widget_set_sensitive (editor->priv->bc_color_combo, TRUE);
gtk_widget_set_sensitive (editor->priv->bc_key_combo, FALSE);
/* Un-hide */
gtk_widget_show_all (editor->priv->bc_page_vbox);
/* Connect signals */
g_signal_connect_swapped (G_OBJECT (editor->priv->bc_backend_combo),
"changed",
G_CALLBACK (backend_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->bc_style_combo),
"changed",
G_CALLBACK (style_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->bc_text_check),
"toggled",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->bc_cs_check),
"toggled",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->bc_color_combo),
"color_changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->bc_key_combo),
"changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->bc_color_radio),
"toggled",
G_CALLBACK (bc_radio_toggled_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->bc_key_radio),
"toggled",
G_CALLBACK (bc_radio_toggled_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->data_digits_spin),
"value-changed",
G_CALLBACK (data_digits_spin_changed_cb),
G_OBJECT (editor));
gl_debug (DEBUG_EDITOR, "END");
}
lglBarcode *
gl_barcode_zint_new (const gchar *id,
gboolean text_flag,
gboolean checksum_flag,
gdouble w,
gdouble h,
const gchar *digits)
{
lglBarcode *gbc;
struct zint_symbol *symbol;
gint result;
symbol = ZBarcode_Create();
/* Auto set to default size */
if ( (w == 0) && (h == 0) )
{
w = DEFAULT_W;
h = DEFAULT_H;
}
/* Assign type flag. Pre-filter by length for subtypes. */
if (g_ascii_strcasecmp (id, "AUSP") == 0) { symbol->symbology = BARCODE_AUSPOST; }
if (g_ascii_strcasecmp (id, "AUSRP") == 0) { symbol->symbology = BARCODE_AUSREPLY; }
if (g_ascii_strcasecmp (id, "AUSRT") == 0) { symbol->symbology = BARCODE_AUSROUTE; }
if (g_ascii_strcasecmp (id, "AUSRD") == 0) { symbol->symbology = BARCODE_AUSREDIRECT; }
if (g_ascii_strcasecmp (id, "AZTEC") == 0) { symbol->symbology = BARCODE_AZTEC; }
if (g_ascii_strcasecmp (id, "AZRUN") == 0) { symbol->symbology = BARCODE_AZRUNE; }
if (g_ascii_strcasecmp (id, "CBR") == 0) { symbol->symbology = BARCODE_CODABAR; }
if (g_ascii_strcasecmp (id, "Code1") == 0) { symbol->symbology = BARCODE_CODEONE; }
if (g_ascii_strcasecmp (id, "Code11") == 0) { symbol->symbology = BARCODE_CODE11; }
if (g_ascii_strcasecmp (id, "C16K") == 0) { symbol->symbology = BARCODE_CODE16K; }
if (g_ascii_strcasecmp (id, "C25M") == 0) { symbol->symbology = BARCODE_C25MATRIX; }
if (g_ascii_strcasecmp (id, "C25I") == 0) { symbol->symbology = BARCODE_C25IATA; }
if (g_ascii_strcasecmp (id, "C25DL") == 0) { symbol->symbology = BARCODE_C25LOGIC; }
if (g_ascii_strcasecmp (id, "Code32") == 0) { symbol->symbology = BARCODE_CODE32; }
if (g_ascii_strcasecmp (id, "Code39") == 0) { symbol->symbology = BARCODE_CODE39; }
if (g_ascii_strcasecmp (id, "Code39E") == 0) { symbol->symbology = BARCODE_EXCODE39; }
if (g_ascii_strcasecmp (id, "Code49") == 0) { symbol->symbology = BARCODE_CODE49; }
if (g_ascii_strcasecmp (id, "Code93") == 0) { symbol->symbology = BARCODE_CODE93; }
if (g_ascii_strcasecmp (id, "Code128") == 0) { symbol->symbology = BARCODE_CODE128; }
if (g_ascii_strcasecmp (id, "Code128B") == 0) { symbol->symbology = BARCODE_CODE128B; }
if (g_ascii_strcasecmp (id, "DAFT") == 0) { symbol->symbology = BARCODE_DAFT; }
if (g_ascii_strcasecmp (id, "DMTX") == 0) { symbol->symbology = BARCODE_DATAMATRIX; }
if (g_ascii_strcasecmp (id, "DPL") == 0) { symbol->symbology = BARCODE_DPLEIT; }
if (g_ascii_strcasecmp (id, "DPI") == 0) { symbol->symbology = BARCODE_DPIDENT; }
if (g_ascii_strcasecmp (id, "KIX") == 0) { symbol->symbology = BARCODE_KIX; }
if (g_ascii_strcasecmp (id, "EAN") == 0) { symbol->symbology = BARCODE_EANX; }
if (g_ascii_strcasecmp (id, "HIBC128") == 0) { symbol->symbology = BARCODE_HIBC_128; }
if (g_ascii_strcasecmp (id, "HIBC39") == 0) { symbol->symbology = BARCODE_HIBC_39; }
if (g_ascii_strcasecmp (id, "HIBCDM") == 0) { symbol->symbology = BARCODE_HIBC_DM; }
if (g_ascii_strcasecmp (id, "HIBCQR") == 0) { symbol->symbology = BARCODE_HIBC_QR; }
if (g_ascii_strcasecmp (id, "HIBCPDF") == 0) { symbol->symbology = BARCODE_HIBC_MICPDF; }
if (g_ascii_strcasecmp (id, "HIBCMPDF") == 0) { symbol->symbology = BARCODE_HIBC_AZTEC; }
if (g_ascii_strcasecmp (id, "HIBCAZ") == 0) { symbol->symbology = BARCODE_C25INTER; }
if (g_ascii_strcasecmp (id, "I25") == 0) { symbol->symbology = BARCODE_C25INTER; }
if (g_ascii_strcasecmp (id, "ISBN") == 0) { symbol->symbology = BARCODE_ISBNX; }
if (g_ascii_strcasecmp (id, "ITF14") == 0) { symbol->symbology = BARCODE_ITF14; }
if (g_ascii_strcasecmp (id, "GMTX") == 0) { symbol->symbology = BARCODE_GRIDMATRIX; }
if (g_ascii_strcasecmp (id, "GS1-128") == 0) { symbol->symbology = BARCODE_EAN128; }
if (g_ascii_strcasecmp (id, "LOGM") == 0) { symbol->symbology = BARCODE_LOGMARS; }
if (g_ascii_strcasecmp (id, "RSS14") == 0) { symbol->symbology = BARCODE_RSS14; }
if (g_ascii_strcasecmp (id, "RSSLTD") == 0) { symbol->symbology = BARCODE_RSS_LTD; }
if (g_ascii_strcasecmp (id, "RSSEXP") == 0) { symbol->symbology = BARCODE_RSS_EXP; }
if (g_ascii_strcasecmp (id, "RSSS") == 0) { symbol->symbology = BARCODE_RSS14STACK; }
if (g_ascii_strcasecmp (id, "RSSSO") == 0) { symbol->symbology = BARCODE_RSS14STACK_OMNI; }
if (g_ascii_strcasecmp (id, "RSSSE") == 0) { symbol->symbology = BARCODE_RSS_EXPSTACK; }
if (g_ascii_strcasecmp (id, "PHARMA") == 0) { symbol->symbology = BARCODE_PHARMA; }
if (g_ascii_strcasecmp (id, "PHARMA2") == 0) { symbol->symbology = BARCODE_PHARMA_TWO; }
if (g_ascii_strcasecmp (id, "PZN") == 0) { symbol->symbology = BARCODE_PZN; }
if (g_ascii_strcasecmp (id, "TELE") == 0) { symbol->symbology = BARCODE_TELEPEN; }
if (g_ascii_strcasecmp (id, "TELEX") == 0) { symbol->symbology = BARCODE_TELEPEN_NUM; }
if (g_ascii_strcasecmp (id, "JAPAN") == 0) { symbol->symbology = BARCODE_JAPANPOST; }
if (g_ascii_strcasecmp (id, "KOREA") == 0) { symbol->symbology = BARCODE_KOREAPOST; }
if (g_ascii_strcasecmp (id, "MAXI") == 0) { symbol->symbology = BARCODE_MAXICODE; }
if (g_ascii_strcasecmp (id, "MPDF") == 0) { symbol->symbology = BARCODE_MICROPDF417; }
if (g_ascii_strcasecmp (id, "MSI") == 0) { symbol->symbology = BARCODE_MSI_PLESSEY; }
if (g_ascii_strcasecmp (id, "MQR") == 0) { symbol->symbology = BARCODE_MICROQR; }
if (g_ascii_strcasecmp (id, "NVE") == 0) { symbol->symbology = BARCODE_NVE18; }
if (g_ascii_strcasecmp (id, "PLAN") == 0) { symbol->symbology = BARCODE_PLANET; }
if (g_ascii_strcasecmp (id, "POSTNET") == 0) { symbol->symbology = BARCODE_POSTNET; }
if (g_ascii_strcasecmp (id, "PDF") == 0) { symbol->symbology = BARCODE_PDF417; }
if (g_ascii_strcasecmp (id, "PDFT") == 0) { symbol->symbology = BARCODE_PDF417TRUNC; }
if (g_ascii_strcasecmp (id, "QR") == 0) { symbol->symbology = BARCODE_QRCODE; }
if (g_ascii_strcasecmp (id, "RM4") == 0) { symbol->symbology = BARCODE_RM4SCC; }
if (g_ascii_strcasecmp (id, "UPC-A") == 0) { symbol->symbology = BARCODE_UPCA; }
if (g_ascii_strcasecmp (id, "UPC-E") == 0) { symbol->symbology = BARCODE_UPCE; }
if (g_ascii_strcasecmp (id, "USPS") == 0) { symbol->symbology = BARCODE_ONECODE; }
if (g_ascii_strcasecmp (id, "PLS") == 0) { symbol->symbology = BARCODE_PLESSEY; }
result = ZBarcode_Encode(symbol, (unsigned char *)digits, 0);
if (result)
{
gl_debug (DEBUG_BARCODE, "Zint Error: %s", symbol->errtxt);
ZBarcode_Delete (symbol);
return NULL;
}
if(!text_flag)
{
symbol->show_hrt = 0;
}
if (!ZBarcode_Render(symbol, (float) w, (float) h))
{
g_message("Zint Rendering Error: %s", symbol->errtxt);
ZBarcode_Delete(symbol);
return NULL;
}
/* Convert Sums provided by zint encode */
gbc = render_zint(symbol, text_flag);
ZBarcode_Delete(symbol);
return gbc;
}
GtkUIManager *
gl_ui_new (glWindow *window)
{
GtkUIManager *ui;
GtkActionGroup *actions;
GError *error = NULL;
GtkWidget *recent_menu;
gl_debug (DEBUG_UI, "START");
g_return_val_if_fail (window && GL_IS_WINDOW (window), NULL);
gl_debug (DEBUG_UI, "window = %p", window);
ui = gtk_ui_manager_new ();
g_signal_connect (ui, "connect_proxy",
G_CALLBACK (connect_proxy_cb), window);
g_signal_connect (ui, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), window);
actions = gtk_action_group_new ("Actions");
gtk_action_group_set_translation_domain (actions, NULL);
gtk_action_group_add_actions (actions, entries, n_entries, GTK_WINDOW (window));
gtk_action_group_add_toggle_actions (actions,
toggle_entries, n_toggle_entries,
window);
gtk_action_group_add_toggle_actions (actions,
ui_toggle_entries, n_ui_toggle_entries,
ui);
gtk_ui_manager_insert_action_group (ui, actions, 0);
gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui));
gl_debug (DEBUG_UI, "Creating ui from string");
if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, strlen (ui_info), &error)) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
/* Set the toolbar styles according to prefs */
set_app_main_toolbar_style (ui);
set_app_drawing_toolbar_style (ui);
/* Set view grid and markup visibility according to prefs */
set_view_style (ui);
/* add an Open Recents Submenu */
recent_menu = gl_recent_create_menu ();
g_signal_connect (G_OBJECT (recent_menu), "item-activated",
G_CALLBACK (gl_ui_cmd_file_open_recent), window);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_ui_manager_get_widget (ui, "/MenuBar/FileMenu/FileRecentsMenu")),
recent_menu);
set_additional_properties (ui);
gl_ui_util_set_verb_list_sensitive (ui, doc_verbs, FALSE);
gl_ui_util_set_verb_list_sensitive (ui, paste_verbs, FALSE);
gl_debug (DEBUG_UI, "END");
return ui;
}
TIMESTAMP windturb_dg::sync(TIMESTAMP t0, TIMESTAMP t1)
{
TIMESTAMP t2 = TS_NEVER;
//if ( *NR_mode == false )
//{
double Pwind, Pmech, detCp, F, G, gearbox_eff;
double matCp[2][3];
store_last_current = current_A.Mag() + current_B.Mag() + current_C.Mag();
// convert press to Pascals and temp to Kelvins
// TODO: convert this to using gl_convert
air_dens = (*pPress*100) * Molar / (Ridealgas * ( (*pTemp - 32)*5/9 + 273.15));
//wind speed at height of hub - uses European Wind Atlas method
WSadj = *pWS * log(turbine_height/roughness_l)/log(ref_height/roughness_l);
double test = *pPress;
/* TODO: import previous and future wind data
and then pseudo-randomize the wind speed values beween 1st and 2nd
WSadj = gl_pseudorandomvalue(RT_RAYLEIGH,&c,(WS1/sqrt(PI/2)));*/
Pwind = 0.5 * (air_dens) * PI * pow(blade_diam/2,2) * pow(WSadj,3);
if (CP_Data == GENERAL_LARGE || CP_Data == GENERAL_MID || CP_Data == GENERAL_SMALL)
{
if (WSadj <= cut_in_ws)
{
Cp = 0;
}
else if (WSadj > cut_out_ws)
{
Cp = 0;
}
else if(WSadj > ws_rated)
{
Cp = Cp_rated * pow(ws_rated,3) / pow(WSadj,3);
}
else
{
if (WSadj == 0 || WSadj <= cut_in_ws || WSadj >= cut_out_ws)
{
Cp = 0;
}
else {
matCp[0][0] = pow((ws_maxcp/cut_in_ws - 1),2); //Coeff of Performance found
matCp[0][1] = pow((ws_maxcp/cut_in_ws - 1),3); //by using method described in [1]
matCp[0][2] = 1;
matCp[1][0] = pow((ws_maxcp/ws_rated - 1),2);
matCp[1][1] = pow((ws_maxcp/ws_rated - 1),3);
matCp[1][2] = 1 - Cp_rated/Cp_max;
detCp = matCp[0][0]*matCp[1][1] - matCp[0][1]*matCp[1][0];
F = (matCp[0][2]*matCp[1][1] - matCp[0][1]*matCp[1][2])/detCp;
G = (matCp[0][0]*matCp[1][2] - matCp[0][2]*matCp[1][0])/detCp;
Cp = Cp_max*(1 - F*pow((ws_maxcp/WSadj - 1),2) - G*pow((ws_maxcp/WSadj - 1),3));
}
}
}
else if (CP_Data == MANUF_TABLE) //Coefficient of Perfomance generated from Manufacturer's table
{
switch (Turbine_Model) {
case VESTAS_V82:
if (WSadj <= cut_in_ws || WSadj >= cut_out_ws)
{
Cp = 0;
}
else //TO DO: possibly replace polynomial with spline library function interpolation
{
//Uses a centered, 10th-degree polynomial Matlab interpolation of original Manuf. data
double z = (WSadj - 10.5)/5.9161;
//Original data [0 0 0 0 0.135 0.356 0.442 0.461 .458 .431 .397 .349 .293 .232 .186 .151 .125 .104 .087 .074 .064] from 4-20 m/s
Cp = -0.08609*pow(z,10) + 0.078599*pow(z,9) + 0.50509*pow(z,8) - 0.45466*pow(z,7) - 0.94154*pow(z,6) + 0.77922*pow(z,5) + 0.59082*pow(z,4) - 0.23196*pow(z,3) - 0.25009*pow(z,2) - 0.24282*z + 0.37502;
}
break;
default:
GL_THROW("Coefficient of Performance model not determined.");
}
}
else if (CP_Data == CALCULATED)
{
matCp[0][0] = pow((ws_maxcp/cut_in_ws - 1),2); //Coeff of Performance found
matCp[0][1] = pow((ws_maxcp/cut_in_ws - 1),3); //by using method described in [1]
matCp[0][2] = 1;
matCp[1][0] = pow((ws_maxcp/ws_rated - 1),2);
matCp[1][1] = pow((ws_maxcp/ws_rated - 1),3);
matCp[1][2] = 1 - Cp_rated/Cp_max;
detCp = matCp[0][0]*matCp[1][1] - matCp[0][1]*matCp[1][0];
F = (matCp[0][2]*matCp[1][1] - matCp[0][1]*matCp[1][2])/detCp;
G = (matCp[0][0]*matCp[1][2] - matCp[0][2]*matCp[1][0])/detCp;
Cp = Cp_max*(1 - F*pow((ws_maxcp/WSadj - 1),2) - G*pow((ws_maxcp/WSadj - 1),3));
}
else
{
GL_THROW("CP_Data not defined.");
}
/// define user defined data , also catch for future cases
Pmech = Pwind * Cp;
if (Pmech != 0)
{
gearbox_eff = 1 - (q*.01*Rated_VA / Pmech); //Method described in [2].
if (gearbox_eff < .1)
{
gearbox_eff = .1; //Prevents efficiency from becoming negative at low power.
}
Pmech = Pwind * Cp * gearbox_eff;
}
Pconv = 1 * Pmech; //TODO: Assuming 0% losses due to friction and miscellaneous losses
if (Gen_status==ONLINE)
{
int k;
voltage_A = pCircuit_V[0]; //Syncs the meter parent to the generator.
voltage_B = pCircuit_V[1];
voltage_C = pCircuit_V[2];
double Pconva = (voltage_A.Mag() / (voltage_A.Mag() + voltage_B.Mag() + voltage_C.Mag()))*Pconv;
double Pconvb = (voltage_B.Mag() / (voltage_A.Mag() + voltage_B.Mag() + voltage_C.Mag()))*Pconv;
double Pconvc = (voltage_C.Mag() / (voltage_A.Mag() + voltage_B.Mag() + voltage_C.Mag()))*Pconv;
if (Gen_type == INDUCTION) //TO DO: Induction gen. Ef not working correctly yet.
{
Pconva = Pconva/Rated_VA; //induction generator solved in pu
Pconvb = Pconvb/Rated_VA;
Pconvc = Pconvc/Rated_VA;
Vapu = voltage_A/(Rated_V/sqrt(3.0));
Vbpu = voltage_B/(Rated_V/sqrt(3.0));
Vcpu = voltage_C/(Rated_V/sqrt(3.0));
Vrotor_A = Vapu;
Vrotor_B = Vbpu;
Vrotor_C = Vcpu;
complex detTPMat = IndTPMat[1][1]*IndTPMat[0][0] - IndTPMat[1][0]*IndTPMat[0][1];
if (Pconv > 0)
{
switch (Gen_mode)
{
case CONSTANTE:
for(k = 0; k < 6; k++) //TODO: convert to a convergence
{
Irotor_A = (~((complex(Pconva,0)/Vrotor_A)));
Irotor_B = (~((complex(Pconvb,0)/Vrotor_B)));
Irotor_C = (~((complex(Pconvc,0)/Vrotor_C)));
Iapu = IndTPMat[1][0]*Vrotor_A + IndTPMat[1][1]*Irotor_A;
Ibpu = IndTPMat[1][0]*Vrotor_B + IndTPMat[1][1]*Irotor_B;
Icpu = IndTPMat[1][0]*Vrotor_C + IndTPMat[1][1]*Irotor_C;
Vrotor_A = complex(1,0)/detTPMat * (IndTPMat[1][1]*Vapu - IndTPMat[0][1]*Iapu);
Vrotor_B = complex(1,0)/detTPMat * (IndTPMat[1][1]*Vbpu - IndTPMat[0][1]*Ibpu);
Vrotor_C = complex(1,0)/detTPMat * (IndTPMat[1][1]*Vcpu - IndTPMat[0][1]*Icpu);
Vrotor_A = Vrotor_A * Max_Vrotor / Vrotor_A.Mag();
Vrotor_B = Vrotor_B * Max_Vrotor / Vrotor_B.Mag();
Vrotor_C = Vrotor_C * Max_Vrotor / Vrotor_C.Mag();
}
break;
case CONSTANTPQ:
double last_Ipu = 0;
double current_Ipu = 1;
unsigned int temp_ind = 1;
while ( fabs( (last_Ipu-current_Ipu)/current_Ipu) > 0.005 )
{
last_Ipu = current_Ipu;
Irotor_A = -(~complex(-Pconva/Vrotor_A.Mag()*cos(Vrotor_A.Arg()),Pconva/Vrotor_A.Mag()*sin(Vrotor_A.Arg())));
Irotor_B = -(~complex(-Pconvb/Vrotor_B.Mag()*cos(Vrotor_B.Arg()),Pconvb/Vrotor_B.Mag()*sin(Vrotor_B.Arg())));
Irotor_C = -(~complex(-Pconvc/Vrotor_C.Mag()*cos(Vrotor_C.Arg()),Pconvc/Vrotor_C.Mag()*sin(Vrotor_C.Arg())));
Iapu = IndTPMat[1][0]*Vrotor_A - IndTPMat[1][1]*Irotor_A;
Ibpu = IndTPMat[1][0]*Vrotor_B - IndTPMat[1][1]*Irotor_B;
Icpu = IndTPMat[1][0]*Vrotor_C - IndTPMat[1][1]*Irotor_C;
Vrotor_A = complex(1,0)/detTPMat * (IndTPMat[1][1]*Vapu - IndTPMat[0][1]*Iapu);
Vrotor_B = complex(1,0)/detTPMat * (IndTPMat[1][1]*Vbpu - IndTPMat[0][1]*Ibpu);
Vrotor_C = complex(1,0)/detTPMat * (IndTPMat[1][1]*Vcpu - IndTPMat[0][1]*Icpu);
current_Ipu = Iapu.Mag() + Ibpu.Mag() + Icpu.Mag();
temp_ind += 1;
if (temp_ind > 100)
{
OBJECT *obj = OBJECTHDR(this);
gl_warning("windturb_dg (id:%d,name:%s): internal iteration limit reached, breaking out of loop. Injected current may not be solved sufficiently.",obj->id,obj->name);
/* TROUBLESHOOT
This may need some work. The generator models are solved iteratively by using the system voltage
as the boundary condition. The current model iterates on solving the current injection, but then
breaks out if not solved within 100 iterations. May indicate some issues with the model (i.e.,
voltage is incorrectly set on the connection node) or it may indicate poor programming. Please report
if you see this message.
*/
break;
}
}
break;
}
// convert current back out of p.u.
current_A = Iapu * Rated_VA/(Rated_V/sqrt(3.0));
current_B = Ibpu * Rated_VA/(Rated_V/sqrt(3.0));
current_C = Icpu * Rated_VA/(Rated_V/sqrt(3.0));
}
else // Generator is offline
{
current_A = 0;
current_B = 0;
current_C = 0;
}
}
else if (Gen_type == SYNCHRONOUS) //synch gen is NOT solved in pu
{ //sg ef mode is not working yet
double Mxef, Mnef, PoutA, PoutB, PoutC, QoutA, QoutB, QoutC;
complex SoutA, SoutB, SoutC;
complex lossesA, lossesB, lossesC;
Mxef = Max_Ef * Rated_V/sqrt(3.0);
Mnef = Min_Ef * Rated_V/sqrt(3.0);
//TODO: convert to a convergence
if (Gen_mode == CONSTANTE) //Ef is controllable to give a needed power output.
{
current_A = invAMx[0][0]*(voltage_A - EfA) + invAMx[0][1]*(voltage_B - EfB) + invAMx[0][2]*(voltage_C - EfC);
current_B = invAMx[1][0]*(voltage_A - EfA) + invAMx[1][1]*(voltage_B - EfB) + invAMx[1][2]*(voltage_C - EfC);
current_C = invAMx[2][0]*(voltage_A - EfA) + invAMx[2][1]*(voltage_B - EfB) + invAMx[2][2]*(voltage_C - EfC);
SoutA = -voltage_A * (~(current_A)); //TO DO: unbalanced
SoutB = -voltage_B * (~(current_B));
SoutC = -voltage_C * (~(current_C));
}
//Gives a constant output power of real power converted Pout,then Qout is found through a controllable power factor.
else if (Gen_mode == CONSTANTP)
{
//If air density increases, power extracted can be much greater than the default specifications - cap it.
if (Pconva > 1.025*Max_P/3) {
Pconva = 1.025*Max_P/3;
}
if (Pconvb > 1.025*Max_P/3) {
Pconvb = 1.025*Max_P/3;
}
if (Pconvc > 1.025*Max_P/3) {
Pconvc = 1.025*Max_P/3;
}
current_A = -(~(complex(Pconva,Pconva*tan(acos(pf)))/voltage_A));
current_B = -(~(complex(Pconvb,Pconvb*tan(acos(pf)))/voltage_B));
current_C = -(~(complex(Pconvc,Pconvc*tan(acos(pf)))/voltage_C));
if (Pconv > 0)
{
double last_current = 0;
double current_current = current_A.Mag() + current_B.Mag() + current_C.Mag();
unsigned int temp_count = 1;
while ( fabs( (last_current-current_current)/current_current) > 0.005 )
{
last_current = current_current;
PoutA = Pconva - current_A.Mag()*current_A.Mag()*(AMx[0][0] - AMx[0][1]).Re();
PoutB = Pconvb - current_B.Mag()*current_B.Mag()*(AMx[1][1] - AMx[0][1]).Re();
PoutC = Pconvc - current_C.Mag()*current_C.Mag()*(AMx[2][2] - AMx[0][1]).Re();
QoutA = pf/fabs(pf)*PoutA*sin(acos(pf));
QoutB = pf/fabs(pf)*PoutB*sin(acos(pf));
QoutC = pf/fabs(pf)*PoutC*sin(acos(pf));
current_A = -(~(complex(PoutA,QoutA)/voltage_A));
current_B = -(~(complex(PoutB,QoutB)/voltage_B));
current_C = -(~(complex(PoutC,QoutC)/voltage_C));
current_current = current_A.Mag() + current_B.Mag() + current_C.Mag();
temp_count += 1;
if ( temp_count > 100 )
{
OBJECT *obj = OBJECTHDR(this);
gl_warning("windturb_dg (id:%d,name:%s): internal iteration limit reached, breaking out of loop. Injected current may not be solved sufficiently.",obj->id,obj->name);
/* TROUBLESHOOT
This may need some work. The generator models are solved iteratively by using the system voltage
as the boundary condition. The current model iterates on solving the current injection, but then
breaks out if not solved within 100 iterations. May indicate some issues with the model (i.e.,
voltage is incorrectly set on the connection node) or it may indicate poor programming. Please report
if you see this message.
*/
break;
}
}
gl_debug("windturb_dg iteration count = %d",temp_count);
}
else
{
current_A = 0;
current_B = 0;
current_C = 0;
}
EfA = voltage_A - (AMx[0][0] - AMx[0][1])*current_A - AMx[0][2]*(current_A + current_B + current_C);
EfB = voltage_B - (AMx[1][1] - AMx[1][0])*current_A - AMx[1][2]*(current_A + current_B + current_C);
EfC = voltage_C - (AMx[2][2] - AMx[2][0])*current_A - AMx[2][1]*(current_A + current_B + current_C);
}
else
GL_THROW("Unknown generator mode");
}
//sum up and finalize everything for output
double PowerA, PowerB, PowerC, QA, QB, QC;
PowerA = -voltage_A.Mag()*current_A.Mag()*cos(voltage_A.Arg() - current_A.Arg());
PowerB = -voltage_B.Mag()*current_B.Mag()*cos(voltage_B.Arg() - current_B.Arg());
PowerC = -voltage_C.Mag()*current_C.Mag()*cos(voltage_C.Arg() - current_C.Arg());
QA = -voltage_A.Mag()*current_A.Mag()*sin(voltage_A.Arg() - current_A.Arg());
QB = -voltage_B.Mag()*current_B.Mag()*sin(voltage_B.Arg() - current_B.Arg());
QC = -voltage_C.Mag()*current_C.Mag()*sin(voltage_C.Arg() - current_C.Arg());
power_A = complex(PowerA,QA);
power_B = complex(PowerB,QB);
power_C = complex(PowerC,QC);
TotalRealPow = PowerA + PowerB + PowerC;
TotalReacPow = QA + QB + QC;
GenElecEff = TotalRealPow/Pconv * 100;
Wind_Speed = WSadj;
complex testCurrent;
testCurrent = pLine_I[0];
complex *testCurrentPointer;
testCurrentPointer = pLine_I;
pLine_I[0] += current_A;
pLine_I[1] += current_B;
pLine_I[2] += current_C;
}
// Generator is offline
else
{
current_A = 0;
current_B = 0;
current_C = 0;
power_A = complex(0,0);
power_B = complex(0,0);
power_C = complex(0,0);
}
//}
// Double check to make sure it is actually converged to a steady answer
// Mostly applies to NR mode to make sure terminal voltage has converged enough
// in NR to give a good boundary condition for solving the generator circuit
double store_current_current = current_A.Mag() + current_B.Mag() + current_C.Mag();
if ( fabs((store_current_current - store_last_current) / store_last_current) > 0.005 )
t2 = t1;
return t2; /* return t2>t1 on success, t2=t1 for retry, t2<t1 on failure */
}
/*--------------------------------------------------------------------------*/
void
gl_object_editor_prepare_text_page (glObjectEditor *editor)
{
gl_debug (DEBUG_EDITOR, "START");
/* Extract widgets from XML tree. */
gl_builder_util_get_widgets (editor->priv->builder,
"text_page_vbox", &editor->priv->text_page_vbox,
"text_family_hbox", &editor->priv->text_family_hbox,
"text_size_spin", &editor->priv->text_size_spin,
"text_bold_toggle", &editor->priv->text_bold_toggle,
"text_italic_toggle", &editor->priv->text_italic_toggle,
"text_color_hbox", &editor->priv->text_color_hbox,
"text_color_radio", &editor->priv->text_color_radio,
"text_color_key_radio", &editor->priv->text_color_key_radio,
"text_color_key_hbox", &editor->priv->text_color_key_hbox,
"text_left_toggle", &editor->priv->text_left_toggle,
"text_center_toggle", &editor->priv->text_center_toggle,
"text_right_toggle", &editor->priv->text_right_toggle,
"text_top_toggle", &editor->priv->text_top_toggle,
"text_vcenter_toggle", &editor->priv->text_vcenter_toggle,
"text_bottom_toggle", &editor->priv->text_bottom_toggle,
"text_line_spacing_spin", &editor->priv->text_line_spacing_spin,
"text_auto_shrink_check", &editor->priv->text_auto_shrink_check,
NULL);
editor->priv->text_family_combo = gl_font_combo_new ("Sans");
gtk_box_pack_start (GTK_BOX (editor->priv->text_family_hbox),
editor->priv->text_family_combo,
TRUE, TRUE, 0);
editor->priv->text_color_combo = gl_color_combo_new (_("Default"),
GL_COLOR_TEXT_DEFAULT,
gl_prefs_model_get_default_text_color (gl_prefs));
gtk_box_pack_start (GTK_BOX (editor->priv->text_color_hbox),
editor->priv->text_color_combo,
FALSE, FALSE, 0);
editor->priv->text_color_key_combo = gl_field_button_new (NULL);
gtk_box_pack_start (GTK_BOX (editor->priv->text_color_key_hbox),
editor->priv->text_color_key_combo,
TRUE, TRUE, 0);
/* Modify widgets */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->priv->text_color_radio), TRUE);
gtk_widget_set_sensitive (editor->priv->text_color_combo, TRUE);
gtk_widget_set_sensitive (editor->priv->text_color_key_combo, FALSE);
/* Un-hide */
gtk_widget_show_all (editor->priv->text_page_vbox);
/* Connect signals */
g_signal_connect_swapped (G_OBJECT (editor->priv->text_family_combo),
"changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->text_size_spin),
"value-changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->text_bold_toggle),
"toggled",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->text_italic_toggle),
"toggled",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->text_color_combo),
"color_changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->text_color_key_combo),
"changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->text_color_radio),
"toggled",
G_CALLBACK (text_radio_toggled_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->text_color_key_radio),
"toggled",
G_CALLBACK (text_radio_toggled_cb),
G_OBJECT (editor));
g_signal_connect (G_OBJECT (editor->priv->text_left_toggle),
"toggled",
G_CALLBACK (align_toggle_cb),
G_OBJECT (editor));
g_signal_connect (G_OBJECT (editor->priv->text_center_toggle),
"toggled",
G_CALLBACK (align_toggle_cb),
G_OBJECT (editor));
g_signal_connect (G_OBJECT (editor->priv->text_right_toggle),
"toggled",
G_CALLBACK (align_toggle_cb),
G_OBJECT (editor));
g_signal_connect (G_OBJECT (editor->priv->text_top_toggle),
"toggled",
G_CALLBACK (valign_toggle_cb),
G_OBJECT (editor));
g_signal_connect (G_OBJECT (editor->priv->text_vcenter_toggle),
"toggled",
G_CALLBACK (valign_toggle_cb),
G_OBJECT (editor));
g_signal_connect (G_OBJECT (editor->priv->text_bottom_toggle),
"toggled",
G_CALLBACK (valign_toggle_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->text_line_spacing_spin),
"value-changed",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
g_signal_connect_swapped (G_OBJECT (editor->priv->text_auto_shrink_check),
"toggled",
G_CALLBACK (gl_object_editor_changed_cb),
G_OBJECT (editor));
gl_debug (DEBUG_EDITOR, "END");
}
void
gl_object_editor_set_text_color (glObjectEditor *editor,
gboolean merge_flag,
glColorNode *text_color_node)
{
gl_debug (DEBUG_EDITOR, "START");
if (text_color_node == NULL)
{
return;
}
g_signal_handlers_block_by_func (G_OBJECT (editor->priv->text_color_combo),
gl_object_editor_changed_cb, editor);
g_signal_handlers_block_by_func (G_OBJECT (editor->priv->text_color_radio),
text_radio_toggled_cb, editor);
g_signal_handlers_block_by_func (G_OBJECT (editor->priv->text_color_key_radio),
text_radio_toggled_cb, editor);
g_signal_handlers_block_by_func (G_OBJECT (editor->priv->text_color_key_combo),
gl_object_editor_changed_cb, editor);
gl_debug (DEBUG_EDITOR, "color field %s(%d) / %X",
text_color_node->key, text_color_node->field_flag, text_color_node->color);
gtk_widget_set_sensitive (editor->priv->text_color_key_radio, merge_flag);
if ( text_color_node->color == GL_COLOR_NONE ) {
gl_color_combo_set_to_default (GL_COLOR_COMBO(editor->priv->text_color_combo));
} else {
gl_color_combo_set_color (GL_COLOR_COMBO(editor->priv->text_color_combo),
text_color_node->color);
}
if (!text_color_node->field_flag || !merge_flag)
{
gl_debug (DEBUG_EDITOR, "color field false");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->priv->text_color_radio), TRUE);
gtk_widget_set_sensitive (editor->priv->text_color_combo, TRUE);
gtk_widget_set_sensitive (editor->priv->text_color_key_combo, FALSE);
}
else
{
gl_debug (DEBUG_EDITOR, "color field true");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (editor->priv->text_color_key_radio), TRUE);
gtk_widget_set_sensitive (editor->priv->text_color_combo, FALSE);
gtk_widget_set_sensitive (editor->priv->text_color_key_combo, TRUE);
gl_field_button_set_key (GL_FIELD_BUTTON (editor->priv->text_color_key_combo), "");
}
g_signal_handlers_unblock_by_func (G_OBJECT (editor->priv->text_color_combo),
gl_object_editor_changed_cb, editor);
g_signal_handlers_unblock_by_func (G_OBJECT (editor->priv->text_color_radio),
text_radio_toggled_cb, editor);
g_signal_handlers_unblock_by_func (G_OBJECT (editor->priv->text_color_key_radio),
text_radio_toggled_cb, editor);
g_signal_handlers_unblock_by_func (G_OBJECT (editor->priv->text_color_key_combo),
gl_object_editor_changed_cb, editor);
gl_debug (DEBUG_EDITOR, "END");
}
glLabel *gl_xml_label_04_parse (xmlNodePtr root,
glXMLLabelStatus *status)
{
glLabel *label;
xmlNodePtr node;
GObject *object;
gboolean rotate_flag;
gl_debug (DEBUG_XML, "START");
*status = XML_LABEL_OK;
if (!xmlStrEqual (root->name, (xmlChar *)"Label")) {
g_message (_("Bad root node = \"%s\""), root->name);
*status = XML_LABEL_ERROR_OPEN_PARSE;
return NULL;
}
label = GL_LABEL (gl_label_new ());
rotate_flag = lgl_xml_get_prop_boolean (root, "rotate", FALSE);
gl_label_set_rotate_flag (label, rotate_flag, FALSE);
for (node = root->xmlChildrenNode; node != NULL; node = node->next) {
gl_debug (DEBUG_XML, "node name = \"%s\"", node->name);
if (!xmlNodeIsText (node)) {
if (xmlStrEqual (node->name, (xmlChar *)"Media_Type")) {
if (!xml04_parse_media_description (node, label)) {
*status = XML_LABEL_UNKNOWN_MEDIA;
}
} else if (xmlStrEqual (node->name, (xmlChar *)"Text")) {
object = gl_label_text_new (label, FALSE);
xml04_parse_object (node, GL_LABEL_OBJECT(object));
xml04_parse_text_props (node, GL_LABEL_TEXT(object));
} else if (xmlStrEqual (node->name, (xmlChar *)"Box")) {
object = gl_label_box_new (label, FALSE);
xml04_parse_object (node, GL_LABEL_OBJECT(object));
xml04_parse_box_props (node, GL_LABEL_BOX(object));
} else if (xmlStrEqual (node->name, (xmlChar *)"Line")) {
object = gl_label_line_new (label, FALSE);
xml04_parse_object (node, GL_LABEL_OBJECT(object));
xml04_parse_line_props (node, GL_LABEL_LINE(object));
} else if (xmlStrEqual (node->name, (xmlChar *)"Ellipse")) {
object = gl_label_ellipse_new (label, FALSE);
xml04_parse_object (node, GL_LABEL_OBJECT(object));
xml04_parse_ellipse_props (node,
GL_LABEL_ELLIPSE(object));
} else if (xmlStrEqual (node->name, (xmlChar *)"Image")) {
object = gl_label_image_new (label, FALSE);
xml04_parse_object (node, GL_LABEL_OBJECT(object));
xml04_parse_image_props (node, GL_LABEL_IMAGE(object));
} else if (xmlStrEqual (node->name, (xmlChar *)"Barcode")) {
object = gl_label_barcode_new (label, FALSE);
xml04_parse_object (node, GL_LABEL_OBJECT(object));
xml04_parse_barcode_props (node,
GL_LABEL_BARCODE(object));
} else if (xmlStrEqual (node->name, (xmlChar *)"Merge_Properties")) {
xml04_parse_merge_properties (node, label);
} else {
g_message (_("bad node = \"%s\""), node->name);
}
}
}
gl_debug (DEBUG_XML, "END");
return label;
}
EXPORT bool glx_init(glxlink *mod)
{
gl_verbose("initializing matlab link");
gl_verbose("PATH=%s", getenv("PATH"));
// initialize matlab engine
MATLABLINK *matlab = (MATLABLINK*)mod->get_data();
matlab->status = 0;
#ifdef WIN32
if ( matlab->command )
matlab->engine = engOpen(matlab->command);
else
matlab->engine = engOpenSingleUse(NULL,NULL,&matlab->status);
if ( matlab->engine==NULL )
{
gl_error("matlab engine start failed, status code is '%d'", matlab->status);
return false;
}
#else
matlab->engine = engOpen(matlab->command);
if ( matlab->engine==NULL )
{
gl_error("matlab engine start failed");
return false;
}
#endif
// set the output buffer
if ( matlab->output_buffer!=NULL )
engOutputBuffer(matlab->engine,matlab->output_buffer,(int)matlab->output_size);
// setup matlab engine
engSetVisible(matlab->engine,window_show(matlab));
gl_debug("matlab link is open");
// special values needed by matlab
mxArray *ts_never = mxCreateDoubleScalar((double)(TIMESTAMP)TS_NEVER);
engPutVariable(matlab->engine,"TS_NEVER",ts_never);
mxArray *ts_error = mxCreateDoubleScalar((double)(TIMESTAMP)TS_INVALID);
engPutVariable(matlab->engine,"TS_ERROR",ts_error);
mxArray *gld_ok = mxCreateDoubleScalar((double)(bool)true);
engPutVariable(matlab->engine,"GLD_OK",gld_ok);
mxArray *gld_err = mxCreateDoubleScalar((double)(bool)false);
engPutVariable(matlab->engine,"GLD_ERROR",gld_err);
// set the workdir
if ( strcmp(matlab->workdir,"")!=0 )
{
#ifdef WIN32
_mkdir(matlab->workdir);
#else
mkdir(matlab->workdir,0750);
#endif
if ( matlab->workdir[0]=='/' )
matlab_exec(matlab,"cd '%s'", matlab->workdir);
else
matlab_exec(matlab,"cd '%s/%s'", getcwd(NULL,0),matlab->workdir);
}
// run the initialization command(s)
if ( matlab->init )
{
mxArray *ans = matlab_exec(matlab,"%s",matlab->init);
if ( ans && mxIsDouble(ans) && (bool)*mxGetPr(ans)==false )
{
gl_error("matlab init failed");
return false;
}
else if ( ans && mxIsChar(ans) )
{
int buflen = (mxGetM(ans) * mxGetN(ans)) + 1;
char *string =(char*)malloc(buflen);
int status_error = mxGetString(ans, string, buflen);
if (status_error == 0)
{
gl_error("'%s'",string);
return false;
}
else
{
gl_error("Did not catch Matlab error");
return false;
}
}
}
if ( matlab->rootname!=NULL )
{
// build gridlabd data
mwSize dims[] = {1,1};
mxArray *gridlabd_struct = mxCreateStructArray(2,dims,0,NULL);
///////////////////////////////////////////////////////////////////////////
// build global data
LINKLIST *item;
mxArray *global_struct = mxCreateStructArray(2,dims,0,NULL);
for ( item=mod->get_globals() ; item!=NULL ; item=mod->get_next(item) )
{
char *name = mod->get_name(item);
GLOBALVAR *var = mod->get_globalvar(item);
mxArray *var_struct = NULL;
mwIndex var_index;
if ( var==NULL ) continue;
// do not map module or structured globals
if ( strchr(var->prop->name,':')!=NULL )
{
// ignore module globals here
}
else if ( strchr(var->prop->name,'.')!=NULL )
{
char struct_name[256];
if ( sscanf(var->prop->name,"%[^.]",struct_name)==0 )
{
gld_property prop(var);
var_index = mxAddField(global_struct,prop.get_name());
var_struct = matlab_create_value(&prop);
if ( var_struct!=NULL )
{
//mod->add_copyto(var->prop->addr,mxGetData(var_struct));
mxSetFieldByNumber(global_struct,0,var_index,var_struct);
}
}
}
else // simple data
{
gld_property prop(var);
var_index = mxAddField(global_struct,prop.get_name());
var_struct = matlab_create_value(&prop);
if ( var_struct!=NULL )
{
//mod->add_copyto(var->prop->addr,mxGetData(var_struct));
mxSetFieldByNumber(global_struct,0,var_index,var_struct);
}
}
// update export list
if ( var_struct!=NULL )
{
mod->set_addr(item,(void*)var_struct);
mod->set_index(item,(size_t)var_index);
}
}
// add globals structure to gridlabd structure
mwIndex gridlabd_index = mxAddField(gridlabd_struct,"global");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,global_struct);
///////////////////////////////////////////////////////////////////////////
// build module data
dims[0] = dims[1] = 1;
mxArray *module_struct = mxCreateStructArray(2,dims,0,NULL);
// add modules
for ( MODULE *module = callback->module.getfirst() ; module!=NULL ; module=module->next )
{
// create module info struct
mwIndex dims[] = {1,1};
mxArray *module_data = mxCreateStructArray(2,dims,0,NULL);
mwIndex module_index = mxAddField(module_struct,module->name);
mxSetFieldByNumber(module_struct,0,module_index,module_data);
// create version info struct
const char *version_fields[] = {"major","minor"};
mxArray *version_data = mxCreateStructArray(2,dims,sizeof(version_fields)/sizeof(version_fields[0]),version_fields);
mxArray *major_data = mxCreateDoubleScalar((double)module->major);
mxArray *minor_data = mxCreateDoubleScalar((double)module->minor);
mxSetFieldByNumber(version_data,0,0,major_data);
mxSetFieldByNumber(version_data,0,1,minor_data);
// attach version info to module info
mwIndex version_index = mxAddField(module_data,"version");
mxSetFieldByNumber(module_data,0,version_index,version_data);
}
gridlabd_index = mxAddField(gridlabd_struct,"module");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,module_struct);
///////////////////////////////////////////////////////////////////////////
// build class data
dims[0] = dims[1] = 1;
mxArray *class_struct = mxCreateStructArray(2,dims,0,NULL);
gridlabd_index = mxAddField(gridlabd_struct,"class");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,class_struct);
mwIndex class_id[1024]; // index into class struct
memset(class_id,0,sizeof(class_id));
// add classes
for ( CLASS *oclass = callback->class_getfirst() ; oclass!=NULL ; oclass=oclass->next )
{
// count objects in this class
mwIndex dims[] = {0,1};
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECT *obj = mod->get_object(item);
if ( obj==NULL || obj->oclass!=oclass ) continue;
dims[0]++;
}
if ( dims[0]==0 ) continue;
mxArray *runtime_struct = mxCreateStructArray(2,dims,0,NULL);
// add class
mwIndex class_index = mxAddField(class_struct,oclass->name);
mxSetFieldByNumber(class_struct,0,class_index,runtime_struct);
// add properties to class
for ( PROPERTY *prop=oclass->pmap ; prop!=NULL && prop->oclass==oclass ; prop=prop->next )
{
mwIndex dims[] = {1,1};
mxArray *property_struct = mxCreateStructArray(2,dims,0,NULL);
mwIndex runtime_index = mxAddField(runtime_struct,prop->name);
mxSetFieldByNumber(runtime_struct,0,runtime_index,property_struct);
}
// add objects to class
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECT *obj = mod->get_object(item);
if ( obj==NULL || obj->oclass!=oclass ) continue;
mwIndex index = class_id[obj->oclass->id]++;
// add properties to class
for ( PROPERTY *prop=oclass->pmap ; prop!=NULL && prop->oclass==oclass ; prop=prop->next )
{
gld_property p(obj,prop);
mxArray *data = matlab_create_value(&p);
mxSetField(runtime_struct,index,prop->name,data);
}
// update export list
mod->set_addr(item,(void*)runtime_struct);
mod->set_index(item,(size_t)index);
}
}
///////////////////////////////////////////////////////////////////////////
// build the object data
dims[0] = 0;
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
if ( mod->get_object(item)!=NULL ) dims[0]++;
}
dims[1] = 1;
memset(class_id,0,sizeof(class_id));
const char *objfields[] = {"name","class","id","parent","rank","clock","valid_to","schedule_skew",
"latitude","longitude","in","out","rng_state","heartbeat","lock","flags"};
mxArray *object_struct = mxCreateStructArray(2,dims,sizeof(objfields)/sizeof(objfields[0]),objfields);
mwIndex n=0;
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECT *obj = mod->get_object(item);
if ( obj==NULL ) continue;
class_id[obj->oclass->id]++; // index into class struct
const char *objname[] = {obj->name&&isdigit(obj->name[0])?NULL:obj->name};
const char *oclassname[] = {obj->oclass->name};
if (obj->name) mxSetFieldByNumber(object_struct,n,0,mxCreateCharMatrixFromStrings(mwSize(1),objname));
mxSetFieldByNumber(object_struct,n,1,mxCreateCharMatrixFromStrings(mwSize(1),oclassname));
mxSetFieldByNumber(object_struct,n,2,mxCreateDoubleScalar((double)class_id[obj->oclass->id]));
if (obj->parent) mxSetFieldByNumber(object_struct,n,3,mxCreateDoubleScalar((double)obj->parent->id+1));
mxSetFieldByNumber(object_struct,n,4,mxCreateDoubleScalar((double)obj->rank));
mxSetFieldByNumber(object_struct,n,5,mxCreateDoubleScalar((double)obj->clock));
mxSetFieldByNumber(object_struct,n,6,mxCreateDoubleScalar((double)obj->valid_to));
mxSetFieldByNumber(object_struct,n,7,mxCreateDoubleScalar((double)obj->schedule_skew));
if ( isfinite(obj->latitude) ) mxSetFieldByNumber(object_struct,n,8,mxCreateDoubleScalar((double)obj->latitude));
if ( isfinite(obj->longitude) ) mxSetFieldByNumber(object_struct,n,9,mxCreateDoubleScalar((double)obj->longitude));
mxSetFieldByNumber(object_struct,n,10,mxCreateDoubleScalar((double)obj->in_svc));
mxSetFieldByNumber(object_struct,n,11,mxCreateDoubleScalar((double)obj->out_svc));
mxSetFieldByNumber(object_struct,n,12,mxCreateDoubleScalar((double)obj->rng_state));
mxSetFieldByNumber(object_struct,n,13,mxCreateDoubleScalar((double)obj->heartbeat));
mxSetFieldByNumber(object_struct,n,14,mxCreateDoubleScalar((double)obj->lock));
mxSetFieldByNumber(object_struct,n,15,mxCreateDoubleScalar((double)obj->flags));
n++;
}
gridlabd_index = mxAddField(gridlabd_struct,"object");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,object_struct);
///////////////////////////////////////////////////////////////////////////
// post the gridlabd structure
matlab->root = gridlabd_struct;
engPutVariable(matlab->engine,matlab->rootname,matlab->root);
}
///////////////////////////////////////////////////////////////////////////
// build the import/export data
for ( LINKLIST *item=mod->get_exports() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECTPROPERTY *objprop = mod->get_export(item);
if ( objprop==NULL ) continue;
// add to published items
gld_property prop(objprop->obj,objprop->prop);
item->addr = (mxArray*)matlab_create_value(&prop);
engPutVariable(matlab->engine,item->name,(mxArray*)item->addr);
}
for ( LINKLIST *item=mod->get_imports() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECTPROPERTY *objprop = mod->get_import(item);
if ( objprop==NULL ) continue;
// check that not already in export list
LINKLIST *export_item;
bool found=false;
for ( export_item=mod->get_exports() ; export_item!=NULL ; export_item=mod->get_next(export_item) )
{
OBJECTPROPERTY *other = mod->get_export(item);
if ( memcmp(objprop,other,sizeof(OBJECTPROPERTY)) )
found=true;
}
if ( !found )
{
gld_property prop(objprop->obj,objprop->prop);
item->addr = (mxArray*)matlab_create_value(&prop);
engPutVariable(matlab->engine,item->name,(mxArray*)item->addr);
}
}
static int32 matlab_flag = 1;
gl_global_create("MATLAB",PT_int32,&matlab_flag,PT_ACCESS,PA_REFERENCE,PT_DESCRIPTION,"indicates that MATLAB is available",NULL);
mod->last_t = gl_globalclock;
return true;
}
