static void gfs_refine_read (GtsObject ** o, GtsFile * fp) { GfsRefine * refine = GFS_REFINE (*o); GtsObjectClass * klass; gboolean class_changed = FALSE; if (fp->type != GTS_STRING) { gts_file_error (fp, "expecting a string (GfsRefineClass)"); return; } klass = gfs_object_class_from_name (fp->token->str); if (klass == NULL) { gts_file_error (fp, "unknown class `%s'", fp->token->str); return; } if (!gts_object_class_is_from_class (klass, gfs_refine_class ())) { gts_file_error (fp, "`%s' is not a GfsRefine", fp->token->str); return; } if (klass != (*o)->klass) { *o = gts_object_new (klass); gts_object_destroy (GTS_OBJECT (refine)); refine = GFS_REFINE (*o); class_changed = TRUE; } gts_file_next_token (fp); gfs_function_read (refine->maxlevel, gfs_object_simulation (refine), fp); if (fp->type == GTS_ERROR) return; if (class_changed && fp->type != '\n' && klass->read) (* klass->read) (o, fp); }
static void refine_height_read (GtsObject ** o, GtsFile * fp) { GfsDerivedVariableInfo v = { "Height", "vertical distance to the surface", cell_height }; v.data = *o; if (!gfs_domain_add_derived_variable (GFS_DOMAIN (gfs_object_simulation (*o)), v)) { gts_file_error (fp, "derived variable `Height' already defined"); return; } (* GTS_OBJECT_CLASS (gfs_refine_height_class ())->parent_class->read) (o, fp); if (fp->type == GTS_ERROR) return; if (!GFS_SURFACE (GFS_REFINE_SURFACE (*o)->surface)->s) { gts_file_error (fp, "RefineHeight only works with GTS surfaces"); return; } }
static void refine_solid_read (GtsObject ** o, GtsFile * fp) { GfsRefineSolid * refine = GFS_REFINE_SOLID (*o); GfsDerivedVariableInfo v = { "SolidCurvature", "curvature of the solid boundary", solid_curvature }; refine->v = gfs_domain_add_derived_variable (GFS_DOMAIN (gfs_object_simulation (*o)), v); if (!refine->v) { gts_file_error (fp, "derived variable `SolidCurvature' already defined"); return; } (* GTS_OBJECT_CLASS (gfs_refine_solid_class ())->parent_class->read) (o, fp); }
static void refine_distance_read (GtsObject ** o, GtsFile * fp) { GfsDerivedVariableInfo v = { "Distance", "distance to the surface", cell_distance }; v.data = *o; if (!gfs_domain_add_derived_variable (GFS_DOMAIN (gfs_object_simulation (*o)), v)) { gts_file_error (fp, "derived variable `Distance' already defined"); return; } (* GTS_OBJECT_CLASS (gfs_refine_distance_class ())->parent_class->read) (o, fp); if (fp->type == GTS_ERROR) return; GtsSurface * s = GFS_SURFACE (GFS_REFINE_SURFACE (*o)->surface)->s; if (!s) { gts_file_error (fp, "RefineDistance only works with GTS surfaces"); return; } GFS_REFINE_DISTANCE (*o)->stree = gts_bb_tree_surface (s); }
static void gfs_source_darcy_read (GtsObject ** o, GtsFile * fp) { (* GTS_OBJECT_CLASS (gfs_source_darcy_class ())->parent_class->read) (o, fp); if (fp->type == GTS_ERROR) return; printf("\ntesting1\n"); /*Check if source darcy has already been added or not*/ FttComponent c; for (c = 0; c < FTT_DIMENSION; c++) { GfsVariable * v = GFS_SOURCE_VELOCITY (*o)->v[c]; if (v->sources) { GSList * i = GTS_SLIST_CONTAINER (v->sources)->items; while (i) { if (i->data != *o && GFS_IS_SOURCE_DARCY (i->data)) { gts_file_error (fp, "variable '%s' cannot have multiple Darcy source terms", v->name); return; } i = i->next; } } } printf("\ntesting2\n"); GfsDomain * domain = GFS_DOMAIN (gfs_object_simulation (*o)); GfsSourceDarcy * s = GFS_SOURCE_DARCY (*o); printf("\ntesting3\n"); s->darcycoeff = gfs_function_new (gfs_function_class (), 0.); gfs_function_read (s->darcycoeff, gfs_object_simulation (s), fp); printf("\ntesting4\n"); if (fp->type != '\n') { s->forchhicoeff = gfs_function_new (gfs_function_class (), 0.); gfs_function_read (s->forchhicoeff, gfs_object_simulation (s), fp); } if (s->beta < 1.) for (c = 0; c < FTT_DIMENSION; c++) s->u[c] = gfs_temporary_variable (domain); else { GFS_SOURCE_GENERIC (s)->centered_value = NULL; GFS_SOURCE_GENERIC (s)->mac_value = NULL; } printf("\ntesting5\n"); }
static void gfs_init_wave_read (GtsObject ** o, GtsFile * fp) { (* GTS_OBJECT_CLASS (gfs_init_wave_class ())->parent_class->read) (o, fp); if (fp->type == GTS_ERROR) return; GfsDomain * domain = GFS_DOMAIN (gfs_object_simulation (*o)); if (!GFS_IS_WAVE (domain)) { gts_file_error (fp, "GfsInitWave can only be used within a GfsWave simulation"); return; } gfs_function_read (GFS_INIT_WAVE (*o)->d, domain, fp); if (fp->type == GTS_ERROR) return; gfs_function_read (GFS_INIT_WAVE (*o)->hs, domain, fp); }
/** * gts_file_assign_start: * @f: a #GtsFile. * @vars: a %GTS_NONE terminated array of #GtsFileVariable. * * Opens a block delimited by braces to read a list of optional * arguments specified by @vars. * * If an error is encountered the @error field of @f is set. */ void gts_file_assign_start (GtsFile * f, GtsFileVariable * vars) { GtsFileVariable * var; g_return_if_fail (f != NULL); g_return_if_fail (vars != NULL); var = vars; while (var->type != GTS_NONE) (var++)->set = FALSE; if (f->type != '{') { gts_file_error (f, "expecting an opening brace"); return; } f->scope_max++; gts_file_next_token (f); }
/** * gts_file_getc : * @f: a #GtsFile. * * Returns: the next character in @f or EOF if the end of the file is * reached or if an error occured. */ gint gts_file_getc (GtsFile * f) { gint c; g_return_val_if_fail (f != NULL, EOF); if (f->type == GTS_ERROR) return EOF; c = next_char (f); f->curpos++; while (char_in_string (c, f->comments)) { while (c != EOF && c != '\n') c = next_char (f); if (c == '\n') { f->curline++; f->curpos = 1; c = next_char (f); } } switch (c) { case '\n': f->curline++; f->curpos = 1; break; case '{': f->scope++; break; case '}': if (f->scope == 0) { f->line = f->curline; f->pos = f->curpos - 1; gts_file_error (f, "no matching opening brace"); c = EOF; } else f->scope--; } return c; }
static void gfs_map_projection_read (GtsObject ** o, GtsFile * fp) { (* GTS_OBJECT_CLASS (gfs_map_projection_class ())->parent_class->read) (o, fp); if (fp->type == GTS_ERROR) return; GtsFileVariable var[] = { {GTS_DOUBLE, "lon", TRUE}, {GTS_DOUBLE, "lat", TRUE}, {GTS_DOUBLE, "angle", TRUE}, {GTS_NONE} }; GfsMapProjection * map = GFS_MAP_PROJECTION (*o); var[0].data = &map->lon; var[1].data = &map->lat; var[2].data = &map->angle; gts_file_assign_variables (fp, var); if (fp->type == GTS_ERROR) return; map->cosa = cos (map->angle*DEG_TO_RAD); map->sina = sin (map->angle*DEG_TO_RAD); char * parms[] = { "proj=lcc", /* Lambert Conformal Conic */ NULL, NULL, NULL, NULL }; parms[1] = g_strdup_printf ("lon_0=%lf", map->lon); parms[2] = g_strdup_printf ("lat_0=%lf", map->lat); parms[3] = g_strdup_printf ("lat_1=%lf", map->lat); parms[4] = g_strdup_printf ("lat_2=%lf", map->lat); map->pj = pj_init (sizeof(parms)/sizeof(char *), parms); if (!map->pj) gts_file_error (fp, "cannot initialise projection"); g_free (parms[1]); g_free (parms[2]); g_free (parms[3]); g_free (parms[4]); }
/** * gts_file_assign_next: * @f: a #GtsFile. * @vars: a %GTS_NONE terminated array of #GtsFileVariable. * * Assigns the next optional argument of @vars read from @f. * * Returns: the variable of @vars which has been assigned or %NULL if * no variable has been assigned (if an error has been encountered the * @error field of @f is set). */ GtsFileVariable * gts_file_assign_next (GtsFile * f, GtsFileVariable * vars) { GtsFileVariable * var; gboolean found = FALSE; g_return_val_if_fail (f != NULL, NULL); g_return_val_if_fail (vars != NULL, NULL); while (f->type == '\n') gts_file_next_token (f); if (f->type == '}') { f->scope_max--; gts_file_next_token (f); return NULL; } if (f->type == GTS_ERROR) return NULL; var = vars; while (f->type != GTS_ERROR && var->type != GTS_NONE && !found) { if (!strcmp (var->name, f->token->str)) { found = TRUE; if (var->unique && var->set) gts_file_error (f, "variable `%s' was already set at line %d:%d", var->name, var->line, var->pos); else { var->line = f->line; var->pos = f->pos; gts_file_next_token (f); if (f->type != '=') gts_file_error (f, "expecting `='"); else { var->set = TRUE; switch (var->type) { case GTS_FILE: break; case GTS_INT: gts_file_next_token (f); if (f->type != GTS_INT) { gts_file_error (f, "expecting an integer"); var->set = FALSE; } else if (var->data) *((gint *) var->data) = atoi (f->token->str); break; case GTS_UINT: gts_file_next_token (f); if (f->type != GTS_INT) { gts_file_error (f, "expecting an integer"); var->set = FALSE; } else if (var->data) *((guint *) var->data) = atoi (f->token->str); break; case GTS_FLOAT: gts_file_next_token (f); if (f->type != GTS_INT && f->type != GTS_FLOAT) { gts_file_error (f, "expecting a number"); var->set = FALSE; } else if (var->data) *((gfloat *) var->data) = atof (f->token->str); break; case GTS_DOUBLE: gts_file_next_token (f); if (f->type != GTS_INT && f->type != GTS_FLOAT) { gts_file_error (f, "expecting a number"); var->set = FALSE; } else if (var->data) *((gdouble *) var->data) = atof (f->token->str); break; case GTS_OBJ: gts_file_next_token (f); if (var->data) { GtsObject ** object = var->data; g_return_val_if_fail (GTS_IS_OBJECT (*object), NULL); (* (*object)->klass->read) (object, f); } break; case GTS_STRING: gts_file_next_token (f); if (f->type != GTS_INT && f->type != GTS_FLOAT && f->type != GTS_STRING) { gts_file_error (f, "expecting a string"); var->set = FALSE; } else { if (f->token->str[0] != '"') { /* simple string */ if (var->data) *((gchar **) var->data) = g_strdup (f->token->str); } else { /* quoted string */ gint len = strlen (f->token->str); if (f->token->str[len - 1] == '"') { /* simple quoted string */ f->token->str[len - 1] = '\0'; if (var->data) *((gchar **) var->data) = g_strdup (&(f->token->str[1])); f->token->str[len - 1] = '"'; } else { /* multiple parts */ GString * s = g_string_new (&(f->token->str[1])); g_string_append_c (s, ' '); int c = gts_file_getc (f); while (c != '"' && c != EOF) { g_string_append_c (s, c); c = gts_file_getc (f); } if (var->data) *((gchar **) var->data) = g_strdup (s->str); g_string_free (s, TRUE); } } } break; default: g_assert_not_reached (); } } } } else var++; } if (!found) gts_file_error (f, "unknown identifier `%s'", f->token->str); else if (f->type != GTS_ERROR) { g_assert (var->set); if (f->type != '}') gts_file_next_token (f); return var; } return NULL; }
static void gfs_porous_read (GtsObject ** o, GtsFile * fp) { /* call read method of parent */ (* GTS_OBJECT_CLASS (gfs_porous_class ())->parent_class->read) (o, fp); if (fp->type == GTS_ERROR) return; GfsPorous * por = GFS_POROUS (*o); GfsSimulation * sim = GFS_SIMULATION (por); /* do object-specific read here */ if (fp->type != '{') { gts_file_error (fp, "expecting an opening brace"); return; } fp->scope_max++; gts_file_next_token (fp); while (fp->type != GTS_ERROR && fp->type != '}') { if (fp->type == '\n') { gts_file_next_token (fp); continue; } if (fp->type != GTS_STRING) { gts_file_error (fp, "expecting a keyword"); return; } if (!strcmp (fp->token->str, "porosity")) { gts_file_next_token (fp); if (fp->type != '=') gts_file_error (fp, "expecting `='"); else{ gts_file_next_token (fp); gfs_function_read (por->porosity, sim, fp); } } if (!strcmp (fp->token->str, "K")) { gts_file_next_token (fp); if (fp->type != '=') gts_file_error (fp, "expecting `='"); else{ gts_file_next_token (fp); gfs_function_read (por-> K, sim , fp); } } } if (fp->type == GTS_ERROR) return; if (fp->type != '}') { gts_file_error (fp, "expecting a closing brace"); return; fp->scope_max--; gts_file_next_token (fp); /* do not forget to prepare for next read */ } }
static void output_spectra_read (GtsObject ** o, GtsFile * fp) { (* GTS_OBJECT_CLASS (gfs_output_spectra_class ())->parent_class->read) (o, fp); if (fp->type == GTS_ERROR) return; GfsOutputSpectra * v = GFS_OUTPUT_SPECTRA (*o); if (fp->type != GTS_STRING) { gts_file_error (fp, "expecting a string (v)"); return; } GfsDomain * domain = GFS_DOMAIN (gfs_object_simulation (*o)); if (!(v->v = gfs_variable_from_name (domain->variables, fp->token->str))) { gts_file_error (fp, "unknown variable `%s'", fp->token->str); return; } gts_file_next_token (fp); GtsFileVariable var[] = { {GTS_DOUBLE, "x", TRUE, &v->pos.x}, {GTS_DOUBLE, "y", TRUE, &v->pos.y}, {GTS_DOUBLE, "z", TRUE, &v->pos.z}, {GTS_DOUBLE, "Lx", TRUE, &v->L.x}, {GTS_DOUBLE, "Ly", TRUE, &v->L.y}, {GTS_DOUBLE, "Lz", TRUE, &v->L.z}, {GTS_NONE} }; gts_file_assign_variables (fp, var); if (fp->type == GTS_ERROR) return; if (fp->type == GTS_INT) { v->level = atoi (fp->token->str); gts_file_next_token (fp); } else v->level = gfs_domain_depth (domain); guint i, j, k, size = 1; v->cgd = gfs_cartesian_grid_new (gfs_cartesian_grid_class ()); /* number of dims of the fft */ v->cgd->N = 3; v->Ndim = 0; k = 0; for (i = 0; i < 3; i++) { if ((&(v->L.x))[i] != 0) { v->Ndim++; v->dir[k] = i; k++; } } if (v->Ndim == 0) { gts_file_error (fp, "There must be at least one L component larger than 0"); return; } /* number of points in each direction */ v->cgd->n = g_malloc (3*sizeof (guint)); for (i = 0; i < 3; i++) { if ((&(v->L.x))[i] == 0 ) v->cgd->n[i] = 1; else v->cgd->n[i] = pow(2,v->level); size *= v->cgd->n[i]; } /* mesh coordinates */ v->cgd->x = g_malloc0 (3*sizeof (gdouble *)); for (i = 0; i < 3; i++) { v->cgd->x[i] = g_malloc (v->cgd->n[i]*sizeof (gdouble)); if (v->cgd->n[i] != 1) for (j = 0; j < v->cgd->n[i]; j++) v->cgd->x[i][j] = (&(v->pos.x))[i] + (&(v->L.x))[i]*(gdouble)j/((gdouble)(v->cgd->n[i]-1)) - 0.5; else v->cgd->x[i][0] = (&(v->pos.x))[i]; } /* memory data allocation */ v->cgd->v = g_malloc0( sizeof ( gdouble ) * 2*(size/2+1) ); }