read_modgeom()

int read_modgeom

(

)

                  {
  char varname[MAX_PATH]; // temp var to read dynamic geometry &configuration
  int ltmp;
  double dtmp;  /* INIT MODGEOM */
  int i;
  const char* geoname; // name of geometry
  const char* geotype; // type of geometry

  config_setting_t* geomcont;

  /* pointers to known geometryarrays */
  struct sphere_geom *sphere;
  struct cylinder_geom *cylinder;
  struct nodes_geom *nodesgeom;
  struct plate_geom *plategeom;
  struct gmsh_geom *gmshgeom;


  CONFIG_GET_INT(config, "modgeom.active", modgeominfo->active);
  CONFIG_GET_STRING(config, "modgeom.nodes_file", fileinfo->nodes_file);
  CONFIG_GET_STRING(config, "modgeom.mics_file", fileinfo->mics_file);
  CONFIG_GET_INT(config, "modgeom.nelmb", modgeominfo->nelmb);
  CONFIG_GET_INT(config, "modgeom.ncntr", modgeominfo->ncntr);

  CONFIG_GET_INT(config, "modgeom.nchief", modgeominfo->nchief);
  if(modgeominfo->nchief > 0 ){
    CONFIG_GET_STRING(config, "modgeom.chief_file", fileinfo->chief_file);
  }

  read_mics();

  CONFIG_GET_FLOAT(config, "modgeom.translation.x", modgeominfo->translation.x);
  CONFIG_GET_FLOAT(config, "modgeom.translation.y", modgeominfo->translation.y);
  CONFIG_GET_FLOAT(config, "modgeom.translation.z", modgeominfo->translation.z);

  CONFIG_GET_FLOAT(config, "modgeom.rotation.phi", modgeominfo->rotation.x);
  CONFIG_GET_FLOAT(config, "modgeom.rotation.theta", modgeominfo->rotation.y);
  CONFIG_GET_FLOAT(config, "modgeom.rotation.psi", modgeominfo->rotation.z);

  CONFIG_GET_FLOAT(config, "modgeom.scale.x", modgeominfo->scale.x);
  CONFIG_GET_FLOAT(config, "modgeom.scale.y", modgeominfo->scale.y);
  CONFIG_GET_FLOAT(config, "modgeom.scale.z", modgeominfo->scale.z);

  // Reading geometries
  geomcont = config_lookup(&config, "modgeom.geoms");
  geometries = malloc(sizeof(struct geometry)*config_setting_length(geomcont)); // allocating space

  ngeometries = config_setting_length(geomcont); // number of geometries
  logger(LOG_INFO, "n geometries=%d\n", ngeometries);

  // for each geometry, read type and parse the proper structure
  for (i = 0; i < config_setting_length(geomcont); i++) {
    sprintf(varname, "modgeom.%s", config_setting_get_string_elem(geomcont, i));
    geoname = config_setting_get_string_elem(geomcont, i); //config_lookup_string(&config,varname);
    logger(LOG_DEBUG, " reading geometry[%s]\n", geoname);
    sprintf(varname, "%s.type", geoname);

//    if (NULL == geotype) {
    if (NULL == CONFIG_LOOKUP(config,varname)) {
      logger(LOG_ERROR, "you must provide a valid geometry type");
      exit(1);
    }
    CONFIG_GET_STRING(config, varname, geotype);
    if (0 == strcmp(geotype, "sphere")) { // SPHERE
      sphere = malloc(sizeof(struct sphere_geom));
      if(-1 == read_sphere(i,geoname,sphere)) return -1;
    } else if (0 == strcmp(geotype, "cylinder")) { // CYLINDER
      cylinder = malloc(sizeof(struct cylinder_geom));
      if(-1 == read_cylinder(i,geoname,cylinder)) return -1;
    } else if (0 == strcmp(geotype, "nodes")) { // EXTERNAL NODES FILE
      logger(LOG_DEBUG, "Nodes\n");
      nodesgeom = malloc(sizeof(struct nodes_geom));
      if(-1 == read_nodes(i,geoname,nodesgeom)) return -1;
    } else if (0 == strcmp(geotype, "gmsh")) { // EXTERNAL GMSH FILE
      logger(LOG_DEBUG, "Gmsh\n");
      gmshgeom = malloc(sizeof(struct gmsh_geom));
      if(-1 == read_gmsh(i,geoname,gmshgeom)) return -1;
    } else if (0 == strcmp(geotype, "plate")) { // PLATE
      logger(LOG_DEBUG, "Plate\n");
      plategeom = malloc(sizeof(struct plate_geom));
      if(-1 == read_plate(i,geoname,plategeom)) return -1;
    }

    // translation and rotation are valid for each geometry (if they exist)
    sprintf(varname, "%s.translation.x", geoname); CONFIG_GET_FLOAT(config, varname, geometries[i].translation.x);
    sprintf(varname, "%s.translation.y", geoname); CONFIG_GET_FLOAT(config, varname, geometries[i].translation.y);
    sprintf(varname, "%s.translation.z", geoname); CONFIG_GET_FLOAT(config, varname, geometries[i].translation.z);
    sprintf(varname, "%s.rotation.x", geoname); CONFIG_GET_FLOAT(config, varname, geometries[i].rotation.x);
    sprintf(varname, "%s.rotation.y", geoname); CONFIG_GET_FLOAT(config, varname, geometries[i].rotation.y);
    sprintf(varname, "%s.rotation.z", geoname); CONFIG_GET_FLOAT(config, varname, geometries[i].rotation.z);
    sprintf(varname, "%s.scale.x", geoname); CONFIG_GET_FLOAT(config, varname, geometries[i].scale.x);
    sprintf(varname, "%s.scale.y", geoname); CONFIG_GET_FLOAT(config, varname, geometries[i].scale.y);
    sprintf(varname, "%s.scale.z", geoname); CONFIG_GET_FLOAT(config, varname, geometries[i].scale.z);
    logger(LOG_DEBUG, "  - nodes       = %d\n", geometries[i].nnodb);
    logger(LOG_DEBUG, "  - elements    = %d\n", geometries[i].nelmb);
    logger(LOG_DEBUG, "  - ctr.points  = %d\n", geometries[i].ncntr);
    logger(LOG_DEBUG, "  - translation = (%f,%f,%f)\n", geometries[i].translation.x, geometries[i].translation.y, geometries[i].translation.z);
    logger(LOG_DEBUG, "  - rotation    = (%f,%f,%f)\n", geometries[i].rotation.x, geometries[i].rotation.y, geometries[i].rotation.z);
    logger(LOG_DEBUG, "  - scale       = (%f,%f,%f)\n", geometries[i].scale.x, geometries[i].scale.y, geometries[i].scale.z);
  }

  // calculating number of nodes and elements
  modgeominfo->nnodb = 0;
  modgeominfo->nelmb = 0;
  modgeominfo->ncntr = 0;
  for (i = 0; i < config_setting_length(geomcont); i++) {
    if (geometries[i].type == SPHERE) {
      sphere = (struct sphere_geom*) geometries[i].ptrgeom;
    } else if (geometries[i].type == CYLINDER) {
      cylinder = (struct cylinder_geom*) geometries[i].ptrgeom;
    } else if (geometries[i].type == NODES) {
      nodesgeom = (struct nodes_geom*) geometries[i].ptrgeom;
    } else if (geometries[i].type == GMSH) {
      gmshgeom = (struct gmsh_geom*) geometries[i].ptrgeom;
    } else if (geometries[i].type == PLATE) {
      plategeom = (struct plate_geom*) geometries[i].ptrgeom;
    }
    modgeominfo->nnodb += geometries[i].nnodb;
    modgeominfo->ncntr += geometries[i].ncntr;
    modgeominfo->nelmb += geometries[i].nelmb;
    logger(LOG_DEBUG, "modgeominfo.nnodb=%d\n", modgeominfo->nnodb);
    logger(LOG_DEBUG, "modgeominfo.ncntr=%d\n", modgeominfo->ncntr);
    logger(LOG_DEBUG, "modgeominfo.nelmb=%d\n", modgeominfo->nelmb);
  }

  // Checks row/column-blocks dimensions against number of equations
  // and modifies if neeeded
  if (runinfo->row_block_size > modgeominfo->ncntr) {
    logger(LOG_WARN, "Row-block size (%d) greater than ncntr(%d) \n",
        runinfo->row_block_size, modgeominfo->ncntr);
    if (modgeominfo->ncntr > (2 * size)) {
      runinfo->row_block_size =
          (int) (modgeominfo->ncntr / (2 * size));
    } else {
      runinfo->row_block_size = 1;
    }
    logger(LOG_WARN, "Row-block size changed to -> %d \n",
        runinfo->row_block_size);
  }
  if (runinfo->col_block_size > modgeominfo->ncntr) {
    logger(LOG_WARN, "Columns-block size (%d) greater than ncntr(%d) \n", runinfo->col_block_size, modgeominfo->ncntr);
    if (modgeominfo->ncntr > (2 * size)) {
      runinfo->col_block_size = (int) (modgeominfo->ncntr / (2 * size));
    } else {
      runinfo->col_block_size = 1;
    }
    logger(LOG_WARN, "Columns-block size changed to -> %d \n", runinfo->col_block_size);
  }
  if (runinfo->mics_block_size > modgeominfo->nmics) {
    logger(LOG_WARN, "Mics-block size (%d) greater than nmics(%d)\n", runinfo->mics_block_size, modgeominfo->nmics);
    if (modgeominfo->nmics > (2 * size)) {
      runinfo->mics_block_size = (int) (modgeominfo->nmics / (2 * size));
    } else {
      runinfo->mics_block_size = 1;
    }
    logger(LOG_WARN, "Mics-block size  changed to -> %d\n", runinfo->mics_block_size);
  }


 return 0;
}