read_boundary_conditions()

int read_boundary_conditions	(	COMPLEX	cfreq,
		int	ifreq
	)

Reads boundary conditions files.

                                                      {

  FILE*  file_imped    = NULL;
  FILE*  file_radiants = NULL;

  FILE* file_lambda = NULL;
  FILE* file_gamma  = NULL;
  FILE* file_func   = NULL;
  FILE* file_g      = NULL;


  char line[200];
  int i=0,j=0;
  long double d1,d2,d3;
  COMPLEX imped;
  COMPLEX radian;
  int i1;

  int nfreq;
//  int isig=0,iome=0;

  char flambda[MAX_PATH];
  char fgamma[MAX_PATH];
  char ffunc[MAX_PATH];
  char fg[MAX_PATH];

  int nlambda = 0;
  int ngamma = 0;
  int nfunc = 0;
  int ng    = 0;
  int mpi_ncntr;
  int nphiu;

  COMPLEX rhos;

  nfreq = modsolinfo->nsig * modsolinfo->nome;
  mpi_ncntr  = modgeominfo->ncntr + modgeominfo->nchief;
  nphiu = modgeominfo->ncntr;

  /* open files */

  if(!modsolinfo->impedentbody){
   if(NULL != fileinfo->imped_file){
    logger(LOG_DEBUG," reading file %s\n",fileinfo->imped_file);
    file_imped = fopen(fileinfo->imped_file,"r");
    if(NULL == file_imped && modsolinfo->nimped > 0){
      perror("Coudln't find IMPEDANCE file ");
       return 0;
    }
   }
  }

  if(!modsolinfo->radiantbody){
   if(NULL != fileinfo->radiants_file){
    logger(LOG_DEBUG," reading file %s\n",fileinfo->radiants_file);
    file_radiants = fopen(fileinfo->radiants_file,"r");
    if(NULL == file_radiants && modsolinfo->nradian > 0){
      perror("Coudln't find RADIATING PANELS file ");
       return 0;
    }
   }
  }

 /* Reading */

 if(0 != modsolinfo->custombc){
     //READING BOUNDARY CONDITIONS
     if(NULL != fileinfo->bc_lambda_file){
         sprintf(flambda,fileinfo->bc_lambda_file,ifreq);
           }
           if(NULL != fileinfo->bc_gamma_file){
         sprintf(fgamma ,fileinfo->bc_gamma_file ,ifreq);
           }
           if(NULL != fileinfo->bc_func_file){
         sprintf(ffunc  ,fileinfo->bc_func_file  ,ifreq);
           }
           if(NULL != fileinfo->bc_g_file){
         sprintf(fg     ,fileinfo->bc_g_file     ,ifreq);
           }
     logger(LOG_DEBUG,"Lambda file: %s\n",flambda);
     logger(LOG_DEBUG,"Gamma  file: %s\n",fgamma);
     logger(LOG_DEBUG,"Func   file: %s\n",ffunc);
     logger(LOG_DEBUG,"g vec  file: %s\n",fg);

     // opening files
     file_lambda = NULL;
     file_gamma  = NULL;
     file_func   = NULL;
     file_g      = NULL;

     nlambda = 0;
     ngamma  = 0;
     nfunc   = 0;
     ng      = 0;

     file_lambda = fopen(flambda,"r");
     file_gamma  = fopen(fgamma ,"r");
     file_func   = fopen(ffunc  ,"r");
     file_g      = fopen(fg     ,"r");

     nlambda = getlines(file_lambda); logger(LOG_DEBUG,"Read %d lines from file %s\n",nlambda,flambda);
     ngamma  = getlines(file_gamma ); logger(LOG_DEBUG,"Read %d lines from file %s\n",ngamma ,fgamma);
     nfunc   = getlines(file_func  ); logger(LOG_DEBUG,"Read %d lines from file %s\n",nfunc  ,ffunc);
     ng      = getlines(file_g     ); logger(LOG_DEBUG,"Read %d lines from file %s\n",ng     ,fg   );

     bc.nlambda = nlambda;
     bc.ngamma  = ngamma;
     bc.nfunc   = nfunc ;
     bc.ng      = ng ;

     if(bc.nlambda > nphiu){
       logger(LOG_WARN,"Number of lines in file %s > number of unsymmetrized panels: %d > %d, only %d lines will be read\n",flambda,bc.nlambda,mpi_ncntr,mpi_ncntr);
       bc.nlambda = nphiu;
       nlambda = nphiu;
     }
     if(bc.ngamma > nphiu){
       logger(LOG_WARN,"Number of lines in file %s > number of unsymmetrized panels: %d > %d, only %d lines will be read\n",fgamma,bc.ngamma,mpi_ncntr,mpi_ncntr);
       bc.ngamma = nphiu;
       ngamma = nphiu;
     }
     if(bc.nfunc > nphiu){
       logger(LOG_WARN,"Number of lines in file %s > number of unsymmetrized panels: %d > %d, only %d lines will be read\n",ffunc,bc.nfunc,mpi_ncntr,mpi_ncntr);
       bc.nfunc = nphiu;
       nfunc = nphiu;
     }
     if(bc.ng > 1){
       logger(LOG_WARN,"Number of lines in file %s > 1, only 1 lines will be read (g is constant in space) \n",fg);
       bc.ng = 1;
       ng = 1;
     }

     logger(LOG_DEBUG,"N.Lambda[%d] = %d\n",i,nlambda);
     logger(LOG_DEBUG,"N.Gamma [%d] = %d\n",i,ngamma);
     logger(LOG_DEBUG,"N.Func  [%d] = %d\n",i,nfunc);
     logger(LOG_DEBUG,"N.g     [%d] = %d\n",i,ng);

     // Initialize B.C. - Defaults is Sound-Hard
     for(j =0;j<nlambda;j++){
      bc.lambda[j]  = 1.0 + I*0.0;
     }
     for(j =0;j<ngamma;j++){
      bc.gamma[j]  = 0.0 + I*0.0;
     }
     for(j =0;j<nfunc;j++){
      bc.func[j]  = 0.0 + I*0.0;
     }
     bc.g.x  = 0.0;
     bc.g.y  = 0.0;
     bc.g.z  = 0.0;

     // Reading lambda
     if(file_lambda){
       for(j =0;j<nlambda;j++){
        fgets(line,100,file_lambda);
        sscanf(line,IMPED_SCANF,&i1,&d1,&d2);
        bc.lambda[i1-1]  = d1 + I*d2;
        logger(LOG_DEBUG,"LAMBDA[%d]: %d - (%f,%f)\n",j,i1,CREAL(bc.lambda[i1-1]),CIMAG(bc.lambda[i1-1]));
       }
       fclose(file_lambda);
     }

     // Reading gamma
     if(file_gamma){
       for(j =0;j<ngamma;j++){
        fgets(line,100,file_gamma);
        sscanf(line,IMPED_SCANF,&i1,&d1,&d2);
        bc.gamma[i1-1]  = d1 + I*d2;
        logger(LOG_DEBUG,"GAMMA[%d]: %d - (%f,%f)\n",j,i1,CREAL(bc.gamma[i1-1]),CIMAG(bc.gamma[i1-1]));
       }
       fclose(file_gamma);
     }

     // Reading func
     if(file_func){
       for(j =0;j<nfunc;j++){
        fgets(line,100,file_func);
        sscanf(line,IMPED_SCANF,&i1,&d1,&d2);
        bc.func[i1-1]  = d1 + I*d2;
        logger(LOG_DEBUG,"FUNC[%d]: %d - (%f,%f)\n",j,i1,CREAL(bc.func[i1-1]),CIMAG(bc.func[i1-1]));
       }
       fclose(file_func);
     }

     // Reading g STILL VALID ONLY FOR CONSTANT g
     if(file_g){
       for(j =0;j<ng;j++){
        fgets(line,100,file_g);
        sscanf(line,VECTOR_SCANF,&d1,&d2,&d3);
        bc.g.x  = d1;
        bc.g.y  = d2;
        bc.g.z  = d3;
        logger(LOG_DEBUG,"G[%d]: (%f,%f,%f)\n",j,bc.g.x,bc.g.y,bc.g.z);
       }
       fclose(file_g);
     }

 }else if (0 == modsolinfo->custombc) {         // NO custom bc declared... must reconstruct matrices from radiant panels and impedent panels

   /* IMPEDANCES */
   for(i=0;i<modsolinfo->nimped;i++){
     if(!modsolinfo->impedentbody){
       fgets(line,100,file_imped);
       sscanf(line,IMPED_SCANF,&i1,&d1,&d2);
       imped = d1+I*d2;
     }else{
       i1 = i+1;
       imped = modsolinfo->impedance;
     }
// Evaluating BC Matrices
//     cfreq = solution->sig[isig] + I*solution->ome[iome];
     rhos = modsolinfo->rho * cfreq;
     if(imped != 0.0){
       bc.gamma[i1-1]  =  - rhos/imped;
     }
     logger(LOG_DEBUG,"Read IMPED[%d]: %d - (%f,%f)\n",i,i1,CREAL(imped),CIMAG(imped));
     logger(LOG_DEBUG,"Calculated GAMMA[%d]: %d - (%f,%f)\n",i,i1,CREAL(bc.gamma[i1-1]),CIMAG(bc.gamma[i1-1]));
   }
   /* RADIATING PANELS */
   for(i=0;i<modsolinfo->nradian;i++){
     if(!modsolinfo->radiantbody){
      fgets(line,100,file_radiants);
      sscanf(line,IMPED_SCANF,&i1,&d1,&d2);
      radian = d1 + I*d2;
     }else{
       i1 = i+1;
       radian = modsolinfo->radiantfield;
     }
     // Evaluating BC Matrices
       bc.func[i1-1] = radian;
       logger(LOG_DEBUG,"FUNC[%d]: %d - (%f,%f)\n",i,i1,CREAL(bc.func[i1-1]),CIMAG(bc.func[i1-1]));
   }
   if(!modsolinfo->impedentbody && NULL != file_imped)    logger(LOG_DEBUG,"file %s read\n",fileinfo->imped_file);
   if(!modsolinfo->radiantbody  && NULL != file_radiants) logger(LOG_DEBUG,"file %s read\n",fileinfo->radiants_file);
 }

 if(modsolinfo->nradian > 0 && NULL != file_radiants && !modsolinfo->radiantbody) fclose(file_radiants);
 if(modsolinfo->nimped  > 0 && NULL != file_imped    && !modsolinfo->impedentbody) fclose(file_imped);

 return 1;
}