read_modsol()

int read_modsol

(

)

Only Representation

                 {

  int i, ifreq, iphfr, nome;
  int ltmp;
  double dtmp;
  DOUBLE impedreal, impedimag;
  DOUBLE radreal, radimag;

  config_setting_t* freq_resp_cnt_cont;
  config_setting_t* freq_resp_mic_cont;
  const char* solvertype = NULL;

  config_setting_t* phystagcont;                                                                                //gp
  struct gmsh_bc *gmshbc;                                                                                               //gp
  const char* phystagname;                                                                                              //gp
  char varname[MAX_PATH];                                                                                               //gp
//  char *multif;                                                                                                               //ui
  char physnamfreq[MAX_PATH];                                                                                   //ui

//  /* INIT MODCOEFAC */
//  CONFIG_GET_INT(config, "modcoefac.active", modcoefacinfo->active);
//
//  /* INIT MODCOEMIC */
//  CONFIG_GET_INT(config, "modcoemic.active", modcoemicinfo->active);

  /* INIT MODSOLINFO */
  CONFIG_GET_INT(config, "modsol.active", modsolinfo->active);


  /* INIT MODSOLINFO */
  CONFIG_GET_INT(config, "modsol.active", modsolinfo->active);

  CONFIG_GET_INT(config, "modsol.nome", modsolinfo->nome);
  nome = modsolinfo->nome;

  if(NULL != CONFIG_LOOKUP(config,"modsol.sources_file")){
    CONFIG_GET_STRING(config, "modsol.sources_file",fileinfo->sources_file);
    if(!file_exists(fileinfo->sources_file)){
     logger(LOG_ERROR,"File %s not present\n",fileinfo->sources_file);
     return -1;
    }
  }

  if(NULL != CONFIG_LOOKUP(config,"modsol.dipoles_file")){
    CONFIG_GET_STRING(config, "modsol.dipoles_file",fileinfo->dipoles_file);
    if(!file_exists(fileinfo->dipoles_file)){
      logger(LOG_ERROR,"File %s not present\n",fileinfo->dipoles_file);
      return -1;
    }
  }

  if(NULL != CONFIG_LOOKUP(config,"modsol.planw_file")){
    CONFIG_GET_STRING(config, "modsol.planw_file", fileinfo->planw_file);
    if(!file_exists(fileinfo->planw_file)){
     logger(LOG_ERROR,"File %s not present\n",fileinfo->planw_file);
     return -1;
    }
  }

  CONFIG_GET_INT(config, "modsol.dirneu", modsolinfo->dirneu);
  if(NULL == CONFIG_LOOKUP(config, "modsol.dirneu")){
          modsolinfo->dirneu = 2;
          logger(LOG_INFO,"dirneu defaults to 2 (Neumann-type conditions) if not present in config file\n");
  }

  CONFIG_GET_INT(config, "modsol.custombc", modsolinfo->custombc);
  if(NULL == CONFIG_LOOKUP(config, "modsol.custombc")){
          modsolinfo->custombc = 0;
          logger(LOG_INFO,"custombc defaults to 0 if not present in config file\n");
  }

  if (2 == modsolinfo->custombc){                                                                                                       // gp
    phystagcont = config_lookup(&config,"modsol.gmshbc");
        phystagname = config_setting_get_string_elem(phystagcont,0);      // ui - reads tagname
    multif = strchr(phystagname, '%');                                                            // ui - looks for frequency dependent boundary properties
    if (NULL != multif) {
        phystags = malloc(sizeof(struct phystag)*config_setting_length(phystagcont)*nome);
        fileinfo->bc_lambda_file = "exported_gmshbc_lambda%d";
        fileinfo->bc_gamma_file = "exported_gmshbc_gamma%d";
        fileinfo->bc_func_file = "exported_gmshbc_func%d";
        CONFIG_GET_STRING(config, "modsol.bc_g_file", fileinfo->bc_g_file);
    }else{
        phystags = malloc(sizeof(struct phystag)*config_setting_length(phystagcont));
        fileinfo->bc_lambda_file = "exported_gmshbc_lambda";
        fileinfo->bc_gamma_file = "exported_gmshbc_gamma";
        fileinfo->bc_func_file = "exported_gmshbc_func";
        CONFIG_GET_STRING(config, "modsol.bc_g_file", fileinfo->bc_g_file);
    }
    nphystags = config_setting_length(phystagcont);
    logger(LOG_INFO,"n physical tags = %d\n",nphystags);
    for (i=0; i<nphystags; i++){
          phystagname = config_setting_get_string_elem(phystagcont,i);      // ui - reads tagname
      if (NULL != multif) {
          for(ifreq=0;ifreq<nome;ifreq++){
                  sprintf(physnamfreq,phystagname,ifreq);                                       // ui - appends frequency index
                  gmshbc = malloc(sizeof(struct gmsh_bc));
                  iphfr = ifreq + i*nome;
                  if(-1 == read_gmshbc(iphfr,physnamfreq,gmshbc)) return -1;
          }
      } else {
          logger(LOG_DEBUG, "reading physical tag [%s]\n", phystagname);
          sprintf(varname, "%s.tag", phystagname);
          if(NULL == CONFIG_LOOKUP(config, varname)){
                  logger(LOG_ERROR,"You must provide a valid physical tag\n");
                  exit(1);
          }
          gmshbc = malloc(sizeof(struct gmsh_bc));
          if(-1 == read_gmshbc(i,phystagname,gmshbc)) return -1;
      }
    }

    CONFIG_GET_STRING(config, "modsol.bc_g_file", fileinfo->bc_g_file);
//    CONFIG_GET_INT(config, "modsol.nimped", modsolinfo->nimped);
//    CONFIG_GET_INT(config, "modsol.nradian", modsolinfo->nradian);
  }else if (1 == modsolinfo->custombc){
    CONFIG_GET_STRING(config, "modsol.bc_lambda_file", fileinfo->bc_lambda_file);
    CONFIG_GET_STRING(config, "modsol.bc_gamma_file", fileinfo->bc_gamma_file);
    CONFIG_GET_STRING(config, "modsol.bc_func_file", fileinfo->bc_func_file);
    CONFIG_GET_STRING(config, "modsol.bc_g_file", fileinfo->bc_g_file);
//    CONFIG_GET_INT(config, "modsol.nimped", modsolinfo->nimped);
//    CONFIG_GET_INT(config, "modsol.nradian", modsolinfo->nradian);
  } else if (0 == modsolinfo->custombc){
        CONFIG_GET_INT(config, "modsol.nimped", modsolinfo->nimped);
        CONFIG_GET_INT(config, "modsol.nradian", modsolinfo->nradian);
    CONFIG_GET_STRING(config, "modsol.imped_file", fileinfo->imped_file);
    CONFIG_GET_STRING(config, "modsol.radiants_file", fileinfo->radiants_file);
    CONFIG_GET_FLOAT(config, "modsol.radiant_real", radreal);
    CONFIG_GET_FLOAT(config, "modsol.radiant_imag", radimag);
    modsolinfo->radiantfield = radreal + I * radimag;
    logger(LOG_DEBUG, "modsolinfo.radiant=%f +I %f\n", CREAL(modsolinfo->radiantfield), CIMAG(modsolinfo->radiantfield));
    CONFIG_GET_FLOAT(config, "modsol.impedance_real", impedreal);
    CONFIG_GET_FLOAT(config, "modsol.impedance_imag", impedimag);
    modsolinfo->impedance = impedreal + I * impedimag;
    logger(LOG_DEBUG, "modsolinfo.impedance=%f +I %f\n", CREAL(modsolinfo->impedance), CIMAG(modsolinfo->impedance));
    //
    // checking if body is uniformly radiant (nradian < 0)
    modsolinfo->radiantbody = 0;
    if (modsolinfo->nradian < 0) {
      modsolinfo->radiantbody = 1;
      modsolinfo->nradian = modgeominfo->ncntr;
      logger(LOG_DEBUG, "Body is uniformly radiant, nradian=%d\n", modsolinfo->nradian);
    }
    // checking if body is uniformly impedent (nimped < 0)
    modsolinfo->impedentbody = 0;
    if (modsolinfo->nimped < 0) {
      modsolinfo->impedentbody = 1;
      modsolinfo->nimped = modgeominfo->ncntr;
      logger(LOG_DEBUG, "Body is uniformly impedent, nimped=%d\n", modsolinfo->nimped);
    }
  }

  CONFIG_GET_INT(config, "modsol.knw", modsolinfo->knw);
  if(NULL == CONFIG_LOOKUP(config, "modsol.knw")){
          modsolinfo->knw = 2;
          logger(LOG_INFO,"knw defaults to 2 if not present in config file\n");
  }
  if(1 == modsolinfo->knw && modgeominfo->nchief > 0){
    logger(LOG_ERROR,"KNW = %d and NCHIEF = %d. CHIEF technique can be used only with KNW=2 \n",modsolinfo->knw,modgeominfo->nchief);
    return -1;
  }

  CONFIG_GET_INT(config, "modsol.nsourc", modsolinfo->nsourc);
  CONFIG_GET_INT(config, "modsol.ndipoles", modsolinfo->ndipoles);
  CONFIG_GET_INT(config, "modsol.nplanw", modsolinfo->nplanw);

  if(1 == modsolinfo->knw && modsolinfo->nplanw > 0){
    logger(LOG_ERROR,"KNW = %d and NPLANW = %d. KNW=1 cannot be used in presence of impinging waves. \n",modsolinfo->knw,modsolinfo->nplanw);
    return -1;
  }

  CONFIG_GET_STRING(config, "modsol.sources_file",fileinfo->sources_file);
  if(0 != modsolinfo->nsourc && NULL != fileinfo->sources_file && !file_exists(fileinfo->sources_file)){
    logger(LOG_ERROR,"File %s not present\n",fileinfo->sources_file);
    return -1;
  }
  CONFIG_GET_STRING(config, "modsol.dipoles_file",fileinfo->dipoles_file);
  if(0 != modsolinfo->ndipoles && NULL != fileinfo->dipoles_file && !file_exists(fileinfo->dipoles_file)){
    logger(LOG_ERROR,"File %s not present\n",fileinfo->dipoles_file);
    return -1;
  }
  CONFIG_GET_STRING(config, "modsol.planw_file", fileinfo->planw_file);
  if(0 != modsolinfo->nplanw && NULL != fileinfo->planw_file && !file_exists(fileinfo->planw_file)){
    logger(LOG_ERROR,"File %s not present\n",fileinfo->planw_file);
    return -1;
  }

  CONFIG_GET_FLOAT(config, "modsol.rho", modsolinfo->rho);
  CONFIG_GET_FLOAT(config, "modsol.maxsig", modsolinfo->maxsig);
  CONFIG_GET_FLOAT(config, "modsol.minsig", modsolinfo->minsig);
  CONFIG_GET_INT(config, "modsol.nsig", modsolinfo->nsig);

  if (NULL == CONFIG_LOOKUP(config,"modsol.maxome") || NULL == CONFIG_LOOKUP(config,"modsol.minome")) {
    if (NULL == CONFIG_LOOKUP(config,"modsol.maxfreq") || NULL == CONFIG_LOOKUP(config,"modsol.minfreq")) {
      logger(LOG_ERROR, MSG_CFG_FREQERROR);
      return -1;
    }

    logger(LOG_DEBUG, "Omega not found, reading fequency\n");

    CONFIG_GET_FLOAT(config, "modsol.maxfreq", modsolinfo->maxfreq);
    CONFIG_GET_FLOAT(config, "modsol.minfreq", modsolinfo->minfreq);
    modsolinfo->maxome = 2.0 * PI * modsolinfo->maxfreq; // Hz->rad/sec conversion
    modsolinfo->minome = 2.0 * PI * modsolinfo->minfreq;
    logger(LOG_DEBUG, "Calculated Omega:[%f, %f]\n", modsolinfo->minome, modsolinfo->maxome);

  } else {
    logger(LOG_DEBUG, "Found Omega\n");
    CONFIG_GET_FLOAT(config, "modsol.maxome", modsolinfo->maxome);
    CONFIG_GET_FLOAT(config, "modsol.minome", modsolinfo->minome);
  }

  CONFIG_GET_INT(config, "modsol.icnmon", modsolinfo->icnmon);
  CONFIG_GET_INT(config, "modsol.iommon", modsolinfo->iommon);
  CONFIG_GET_INT(config, "modsol.imimon", modsolinfo->imimon);
  CONFIG_GET_INT(config, "modsol.printout", modsolinfo->printout);
  CONFIG_GET_INT(config, "modsol.printvtk", modsolinfo->printvtk);
  CONFIG_GET_INT(config, "modsol.printmsh", modsolinfo->printmsh);
  CONFIG_GET_INT(config, "modsol.printwrl", modsolinfo->printwrl);

  if (modsolinfo->nome <= 0) {
    logger(LOG_WARN,
        "Number of frequencies (%d) is not >0, no solution will be evaluated\n",
        modsolinfo->nome);
  }

  freq_resp_cnt_cont = config_lookup(&config, "modsol.freq_resp_cnt");
  freq_resp_mic_cont = config_lookup(&config, "modsol.freq_resp_mic");
  if (freq_resp_cnt_cont != NULL) {
    modsolinfo->n_freqresp_cnt = config_setting_length( freq_resp_cnt_cont);
    logger(LOG_DEBUG, "modsolinfo->n_freqresp_cnt=%d\n", modsolinfo->n_freqresp_cnt);
    solution->i_freqresp_cnt = calloc(modsolinfo->n_freqresp_cnt,sizeof(int));
    for (i = 0; i < modsolinfo->n_freqresp_cnt; i++) {
      solution->i_freqresp_cnt[i] = config_setting_get_int_elem( freq_resp_cnt_cont, i);
      logger(LOG_DEBUG, " solution->i_freqresp_cnt[%d]  = %d\n", i, solution->i_freqresp_cnt[i]);
    }
  }

  if (freq_resp_mic_cont != NULL) {
    modsolinfo->n_freqresp_mic = config_setting_length( freq_resp_mic_cont);
    logger(LOG_DEBUG, "modsolinfo->n_freqresp_mic=%d\n", modsolinfo->n_freqresp_mic);
    solution->i_freqresp_mic = calloc(modsolinfo->n_freqresp_mic,sizeof(int));
    for (i = 0; i < modsolinfo->n_freqresp_mic; i++) {
      solution->i_freqresp_mic[i] = config_setting_get_int_elem( freq_resp_mic_cont, i);
      logger(LOG_DEBUG, " solution->i_freqresp_mic[%d]  = %d\n", i, solution->i_freqresp_mic[i]);
    }
  }

  modsolinfo->pre_calculate_coefs = 1;
  if (config_lookup(&config, "modsol.pre_calculate_coefs") != NULL) {
    CONFIG_GET_INT(config, "modsol.pre_calculate_coefs", modsolinfo->pre_calculate_coefs);

    if (((runinfo->krow < modgeominfo->ncntr) && (runinfo->krow > 0))
        && (modsolinfo->pre_calculate_coefs == 0)) {
      logger(LOG_ERROR, MSG_CFG_KROWPRECO0);
      logger(LOG_ERROR, "ACOUSTO WILL STOP\n");
      return -1;
    }
  }

      // Checking (Imposing) active modules consistency
  if(modsolinfo->pre_calculate_coefs == 1){
                modcoefacinfo->active == 1;
                modcoemicinfo->active == 1;
                logger(LOG_INFO, "If coefficients are precalculated, modcoefac.active and modcoemic.active default to 1 (for v1.6 legacy consistency) \n");
                //if(modsolinfo->active == 1){  // gp commented because nosense
                //      cleanup();
                //return -1;
                //}
  }

  // Getting solver type
  if (NULL != config_lookup(&config, "modsol.solver")) {
    CONFIG_GET_STRING(config, "modsol.solver", solvertype);
    if (NULL != solvertype) {
      if (NULL != strstr("GMRES", solvertype)) {
        logger(LOG_INFO, "GMRES Solver chosen\n");
        modsolinfo->solver = GMRES;
        CONFIG_GET_FLOAT(config, "modsol.tolerance", modsolinfo->tolerance);
        CONFIG_GET_INT(config, "modsol.maxiterations", modsolinfo->maxiterations);
        CONFIG_GET_INT(config, "modsol.restart", modsolinfo->restart);
      } else {
        logger(LOG_INFO, "Pseudoinverse Solver chosen\n");
        modsolinfo->solver = PSEUDOINVERSE;
      }
    }
  } else {
    logger(LOG_INFO, "Pseudoinverse Solver chosen\n");
    modsolinfo->solver = PSEUDOINVERSE;
  }


  modsolinfo->onlyrep = 0;
  if (config_lookup(&config, "modsol.onlyrep") != NULL) {
    CONFIG_GET_INT(config, "modsol.onlyrep", modsolinfo->onlyrep);
  }
  return 0;
}