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) );
}
