read_input_file.cpp

利用c++语言写的三维FDTD

#include "stdafx.h"
#include "read_input_file.h"

int readFile_fdtd_data(Input_Data *Inp_D, char *ut_nev)
{
	//ifstream declaration
	ifstream *inClientFile = NULL;
	inClientFile = new ifstream[1];
	//open the file
	inClientFile->open(ut_nev,ios::in);
	if (!*inClientFile)//return if ifstream could not open the specified file
	{
		cerr << "File: " << ut_nev << " - cannot be open" << endl;
		return 1;
	}
	
	try
	{
		//the number of threads (decomposition in shared memory space with OpenMP)
		#ifdef _OPENMP
			ReadFileVar<int>(inClientFile, "num_threads", &Inp_D->num_threads);
		#endif

		ReadFileVar<long>(inClientFile, "nx", &Inp_D->nx);
		ReadFileVar<long>(inClientFile, "ny", &Inp_D->ny);
		ReadFileVar<long>(inClientFile, "nz", &Inp_D->nz);

		ReadFileVar<long>(inClientFile, "n_PML", &Inp_D->n_PML);
		
		ReadFileVar<double>(inClientFile, "dx", &Inp_D->dx);
		ReadFileVar<double>(inClientFile, "dy", &Inp_D->dy);
		ReadFileVar<double>(inClientFile, "dz", &Inp_D->dz);

		ReadFileVar<long>(inClientFile, "num_iter", &Inp_D->num_iter);
		
		ReadFileVar<double>(inClientFile, "limit_time", &Inp_D->limit_time);

		ReadFileVar<int>(inClientFile, "load_workspace_data", &Inp_D->load_workspace_data);
		if(Inp_D->load_workspace_data)
		{
			ReadFileVarString(inClientFile, "Path_Load_Workspace_Data", &Inp_D->Path_Load_Workspace_Data);
		}
	    
		ReadFileVar<int>(inClientFile, "save_field", &Inp_D->save_field);
		if(Inp_D->save_field)
		{
			ReadFileVar<long>(inClientFile, "nr_Save", &Inp_D->nr_Save);
			ReadFileVar<long>(inClientFile, "saveFROMinst", &Inp_D->saveFROMinst);
			ReadFileVar<long>(inClientFile, "saveTOinst", &Inp_D->saveTOinst);
			ReadFileVar<long>(inClientFile, "n_x_a", &Inp_D->n_x_a);
			if (Inp_D->n_x_a < 0)
			{
				cerr << "wrong n_x_a:  " << Inp_D->n_x_a << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "n_x_b", &Inp_D->n_x_b);
			if (Inp_D->n_x_b >= Inp_D->nx)
			{
				cerr << "wrong n_x_b:  " << Inp_D->n_x_b << " >= " << Inp_D->nx  << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "n_y_a", &Inp_D->n_y_a);
			if (Inp_D->n_y_a < 0)
			{
				cerr << "wrong n_y_a:  " << Inp_D->n_y_a << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "n_y_b", &Inp_D->n_y_b);
			if (Inp_D->n_y_b >= Inp_D->ny)
			{
				cerr << "wrong n_y_b:  " << Inp_D->n_y_b << " >= " << Inp_D->ny  << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "n_z_a", &Inp_D->n_z_a);
			if (Inp_D->n_z_a < 0)
			{
				cerr << "wrong n_z_a:  " << Inp_D->n_z_a << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "n_z_b", &Inp_D->n_z_b);
			if (Inp_D->n_z_b >= Inp_D->nz)
			{
				cerr << "wrong n_z_b:  " << Inp_D->n_z_b << " >= " << Inp_D->nz  << endl;
				return 1;
			}
		}

		//average in a volume
		ReadFileVar<int>(inClientFile, "aver_field_volume", &Inp_D->aver_field_volume);
		if (Inp_D->aver_field_volume == 1)
		{
			ReadFileVar<long>(inClientFile, "nx_a_av", &Inp_D->nx_a_av);
			if (Inp_D->nx_a_av < 0)
			{
				cerr << "wrong nx_a_av:  " << Inp_D->nx_a_av << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "nx_b_av", &Inp_D->nx_b_av);
			if (Inp_D->nx_b_av >= Inp_D->nx)
			{
				cerr << "wrong nx_b_av:  " << Inp_D->nx_b_av << " >= " << Inp_D->nx  << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "ny_a_av", &Inp_D->ny_a_av);
			if (Inp_D->ny_a_av < 0)
			{
				cerr << "wrong ny_a_av:  " << Inp_D->ny_a_av << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "ny_b_av", &Inp_D->ny_b_av);
			if (Inp_D->ny_b_av >= Inp_D->ny)
			{
				cerr << "wrong ny_b_av:  " << Inp_D->ny_b_av << " >= " << Inp_D->ny  << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "nz_a_av", &Inp_D->nz_a_av);
			if (Inp_D->nz_a_av < 0)
			{
				cerr << "wrong nz_a_av:  " << Inp_D->nz_a_av << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "nz_b_av", &Inp_D->nz_b_av);
			if (Inp_D->nz_b_av >= Inp_D->nz)
			{
				cerr << "wrong nz_b_av:  " << Inp_D->nz_b_av << " >= " << Inp_D->nz  << endl;
				return 1;
			}
		}

		//Bragg diffraction
		ReadFileVar<int>(inClientFile, "jel_aver_Bragg_WignerUC", &Inp_D->jel_aver_Bragg_WignerUC);
		if (Inp_D->jel_aver_Bragg_WignerUC == 1)
		{
			ReadFileVar<long>(inClientFile, "nz_Bragg", &Inp_D->nz_Bragg);
			if (Inp_D->nz_Bragg < 0 || Inp_D->nz_Bragg > Inp_D->nz)
			{
				cerr << "wrong nz_Bragg:  " << Inp_D->nz_Bragg << endl;
				return 1;
			}
			
			ReadFileVarString(inClientFile, "path_name_Gxy", &Inp_D->path_name_Gxy);
			ReadFileVar<long>(inClientFile, "n_Gxy", &Inp_D->n_Gxy);
			
		}

		if (Inp_D->jel_aver_Bragg_WignerUC == 1 || Inp_D->aver_field_volume == 1)
		{
			ReadFileVarString(inClientFile, "path_name_Wigner_Cell", &Inp_D->path_name_Wigner_Cell);
		}

		//Fourier transform
		ReadFileVar<int>(inClientFile, "fourier_transf_vol", &Inp_D->fourier_transf_vol);
		if (Inp_D->fourier_transf_vol == 1)
		{
			ReadFileVar<long>(inClientFile, "nx_a_f", &Inp_D->nx_a_f);
			if (Inp_D->nx_a_f < 0)
			{
				cerr << "wrong nx_a_f:  " << Inp_D->nx_a_f << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "nx_b_f", &Inp_D->nx_b_f);
			if (Inp_D->nx_b_f >= Inp_D->nx)
			{
				cerr << "wrong nx_b_f:  " << Inp_D->nx_b_f << " >= " << Inp_D->nx  << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "ny_a_f", &Inp_D->ny_a_f);
			if (Inp_D->ny_a_f < 0)
			{
				cerr << "wrong ny_a_f:  " << Inp_D->ny_a_f << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "ny_b_f", &Inp_D->ny_b_f);
			if (Inp_D->ny_b_f >= Inp_D->ny)
			{
				cerr << "wrong ny_b_f:  " << Inp_D->ny_b_f << " >= " << Inp_D->ny  << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "nz_a_f", &Inp_D->nz_a_f);
			if (Inp_D->nz_a_f < 0)
			{
				cerr << "wrong nz_a_f:  " << Inp_D->nz_a_f << endl;
				return 1;
			}
			ReadFileVar<long>(inClientFile, "nz_b_f", &Inp_D->nz_b_f);
			if (Inp_D->nz_b_f >= Inp_D->nz)
			{
				cerr << "wrong nz_b_f:  " << Inp_D->nz_b_f << " >= " << Inp_D->nz  << endl;
				return 1;
			}

			ReadFileVar<double>(inClientFile, "frec_1", &Inp_D->frec_1);
			ReadFileVar<double>(inClientFile, "frec_2", &Inp_D->frec_2);
			ReadFileVar<long>(inClientFile, "n_frec", &Inp_D->n_frec);
			ReadFileVar<long>(inClientFile, "start_fourier", &Inp_D->start_fourier);
		}
		

		#ifdef eval_W
			ReadFileVar<long>(inClientFile, "nr_W_DIV_x", &Inp_D->nr_W_DIV_x);
			ReadFileVar<long>(inClientFile, "nr_W_DIV_y", &Inp_D->nr_W_DIV_y);
			ReadFileVar<long>(inClientFile, "nr_W_DIV_z", &Inp_D->nr_W_DIV_z);

			ReadFileVar<long>(inClientFile, "nx_W_a", &Inp_D->nx_W_a);
			ReadFileVar<long>(inClientFile, "nx_W_b", &Inp_D->nx_W_b);
			ReadFileVar<long>(inClientFile, "ny_W_a", &Inp_D->ny_W_a);
			ReadFileVar<long>(inClientFile, "ny_W_b", &Inp_D->ny_W_b);
			ReadFileVar<long>(inClientFile, "nz_W_a", &Inp_D->nz_W_a);
			ReadFileVar<long>(inClientFile, "nz_W_b", &Inp_D->nz_W_b);

			ReadFileVar<long>(inClientFile, "eval_W_FROMinst", &Inp_D->eval_W_FROMinst);
			ReadFileVar<long>(inClientFile, "eval_W_TOinst", &Inp_D->eval_W_TOinst);

			ReadFileVar<int>(inClientFile, "save_W", &Inp_D->save_W);
			if(Inp_D->save_W)
			{
				ReadFileVar<long>(inClientFile, "nr_W_Save", &Inp_D->nr_W_Save);
				ReadFileVar<long>(inClientFile, "save_W_FROMinst", &Inp_D->save_W_FROMinst);
				ReadFileVar<long>(inClientFile, "save_W_TOinst", &Inp_D->save_W_TOinst);
			}
			
			ReadFileVar<long>(inClientFile, "n_x_W_a", &Inp_D->n_x_W_a);
			ReadFileVar<long>(inClientFile, "n_x_W_b", &Inp_D->n_x_W_b);
			ReadFileVar<long>(inClientFile, "n_y_W_a", &Inp_D->n_y_W_a);
			ReadFileVar<long>(inClientFile, "n_y_W_b", &Inp_D->n_y_W_b);
			ReadFileVar<long>(inClientFile, "n_z_W_a", &Inp_D->n_z_W_a);
			ReadFileVar<long>(inClientFile, "n_z_W_b", &Inp_D->n_z_W_b);

			ReadFileVar<long>(inClientFile, "Save_nr_W_DIV_x", &Inp_D->Save_nr_W_DIV_x);
			ReadFileVar<long>(inClientFile, "Save_nr_W_DIV_y", &Inp_D->Save_nr_W_DIV_y);
			ReadFileVar<long>(inClientFile, "Save_nr_W_DIV_z", &Inp_D->Save_nr_W_DIV_z);
			
		#endif

		ReadFileVar<long>(inClientFile, "source_type", &Inp_D->source_type);
		ReadFileVar<long>(inClientFile, "jel_plane_wave", &Inp_D->jel_plane_wave);

		if ( Inp_D->jel_plane_wave) //plane wave
		{
			ReadFileVar<long>(inClientFile, "n_TS", &Inp_D->n_TS);
				
			ReadFileVar<double>(inClientFile, "X0", &Inp_D->X0);
			switch ( Inp_D->source_type)
			{
				case 1: //Gaussian source
					ReadFileVar<double>(inClientFile, "t0", &Inp_D->t0);
					ReadFileVar<double>(inClientFile, "tw", &Inp_D->tw);
					break;
				case 2: //Sin source
					ReadFileVar<double>(inClientFile, "omega", &Inp_D->omega);
					ReadFileVar<double>(inClientFile, "phase", &Inp_D->phase);
					ReadFileVar<double>(inClientFile, "const_alfa", &Inp_D->const_alfa);
					break;
				case 3://Gaussian-Sin source
					ReadFileVar<double>(inClientFile, "t0", &Inp_D->t0);
					ReadFileVar<double>(inClientFile, "tw", &Inp_D->tw);
					ReadFileVar<double>(inClientFile, "omega", &Inp_D->omega);
					ReadFileVar<double>(inClientFile, "phase", &Inp_D->phase);
					break;
			}
		}
		else
		{
			ReadFileVar<long>(inClientFile, "n_Coord", &Inp_D->n_Coord);
			ReadFileVarString(inClientFile, "path_name_CoordPointSource", &Inp_D->path_name_CoordPointSource);
			ReadFileVar<int>(inClientFile, "readFile_Param_Pt_Source", &Inp_D->readFile_Param_Pt_Source);
			if (Inp_D->readFile_Param_Pt_Source)
			{
				ReadFileVarString(inClientFile, "path_name_ParamPointSource", &Inp_D->path_name_ParamPointSource);
			}
			else
			{
				ReadFileVar<double>(inClientFile, "X0", &Inp_D->X0);
				switch ( Inp_D->source_type)
				{
					case 1: //Gaussian source
						ReadFileVar<double>(inClientFile, "t0", &Inp_D->t0);
						ReadFileVar<double>(inClientFile, "tw", &Inp_D->tw);
						break;
					case 2: //Sin source
						ReadFileVar<double>(inClientFile, "omega", &Inp_D->omega);
						ReadFileVar<double>(inClientFile, "phase", &Inp_D->phase);
						ReadFileVar<double>(inClientFile, "const_alfa", &Inp_D->const_alfa);
						break;
					case 3://Gaussian-Sin source
						ReadFileVar<double>(inClientFile, "t0", &Inp_D->t0);
						ReadFileVar<double>(inClientFile, "tw", &Inp_D->tw);
						ReadFileVar<double>(inClientFile, "omega", &Inp_D->omega);
						ReadFileVar<double>(inClientFile, "phase", &Inp_D->phase);
						break;
				}
			}
			ReadFileVar<int>(inClientFile, "pt_source_Ez", &Inp_D->pt_source_Ez);
			ReadFileVar<int>(inClientFile, "pt_source_Hz", &Inp_D->pt_source_Hz);

		}

		ReadFileVarString(inClientFile, "path_name_Index", &Inp_D->path_name_Index);

		ReadFileVar<long>(inClientFile, "n_Mat", &Inp_D->n_Mat);
		ReadFileVarString(inClientFile, "path_name_Mat", &Inp_D->path_name_MatParam);

		//the followed points
		ReadFileVar<int>(inClientFile, "load_foll_field_points", &Inp_D->load_foll_field_points);
		if (Inp_D->load_foll_field_points > 0)
		{
			ReadFileVar<long>(inClientFile, "n_Ind_F", &Inp_D->n_Ind_F);
			ReadFileVarString(inClientFile, "path_name_foll_field_points", &Inp_D->path_name_foll_field_points);
		}

		//the PML parameters in x,y and z direction
		ReadFileVar<double>(inClientFile, "PML_eps_r_z_1", &Inp_D->PML_eps_r_z_1);
		ReadFileVar<double>(inClientFile, "PML_mu_r_z_1", &Inp_D->PML_mu_r_z_1);
		ReadFileVar<double>(inClientFile, "PML_eps_r_z_2", &Inp_D->PML_eps_r_z_2);
		ReadFileVar<double>(inClientFile, "PML_mu_r_z_2", &Inp_D->PML_mu_r_z_2);

		//save the data
		ReadFileVarString(inClientFile, "path_save_data", &Inp_D->path_save_data);
	}
	catch( char * str )
    {
        cout << "Exception raised - " << str << ut_nev << '\n';
		return 1;
    }

	if (inClientFile)
	{
		delete [] inClientFile;
		inClientFile = NULL;
	}
	
	return 0;	

	
}

///////////////////////////////////////////////////////////////////////////////////////
//Reads from a previously opened file the value of a variable
///////////////////////////////////////////////////////////////////////////////////////
template <class T>int ReadFileVar(ifstream *inClientFile, char var_name[], T *var)
{
	//inClientFile - pointer to the previously opened File stream
	//var_name - contains the name of the variable
	//var - pointer to a long, the function will return the value of the variable in this
	
	int length_var_name = (int) strlen(var_name);
	char line[512];
	int i, j;
		
	while (inClientFile->getline(line,512))
	{
		if (line[0] != '/' && line[1] != '/')
		{
			i = 0;
			while (line[i] != '\0')
			{
				if (!strncmp(&line[i],var_name,length_var_name))
				{
					j = i + length_var_name;
					while (line[j] != '\0')
					{
						if ( line[j] >= '0' && line[j] <= '9')
						{
							*var = (T) atof(&line[j]);
							inClientFile->seekg( 0, ios_base::beg ); //back to the beginning of the file
							return 0;
						}
						j++;
					}
				}
				i++;
			}
		}
	}

	*var = NULL;
	cerr << var_name << " - cannot be found" << endl;
	throw "error reading input data from: ";

	return 1; //the specified variable was not found in the file
}

///////////////////////////////////////////////////////////////////////////////////////
//Reads from a previously opened file the value of a variable
///////////////////////////////////////////////////////////////////////////////////////
int ReadFileVarString(ifstream *inClientFile, char var_name[], char **var)
{
	//inClientFile - pointer to the previously opened File stream
	//var_name - contains the name of the variable
	//var - pointer to a long, the function will return the value of the variable in this
	int length_var_name = (int) strlen(var_name);
	char line[512];
	int i, j, k;
	
	while (inClientFile->getline(line,512))
	{
		if (line[0] != '/' && line[1] != '/')
		{
			i = 0;
			while (line[i] != '\0')
			{
				if (!strncmp(&line[i],var_name,length_var_name))
				{
					j = i + length_var_name;
					while (line[j] != '\0')
					{
						if ( ( (line[j] >= 48 && line[j] <= 59 ) || // "1-9"
							   (line[j] >= 65 && line[j] <= 90 ) || // "A-Z"
							   (line[j] >= 97 && line[j] <= 122) || // "a-z"
							    line[j] == 47 || line[j] == 92 ) )    // "/" and "\"
						{  
							k = j+1;
							while (line[k] != ' ' && line[k] != '\0' && line[k] != ';') //find the end
							{
								k++;
							}
							long n_array = k-j;
							*var = new char[n_array+1];
							strncpy(*var,&line[j],n_array);//does not copy null character
							var[0][n_array] = '\0';
							inClientFile->seekg( 0, ios_base::beg ); //back to the beginning of the file
							return 0;
						}
						j++;
					}
				}
				i++;
			}
		}
	}
	
	*var = NULL;
	cerr << var_name << " - cannot be found" << endl;
	throw "error reading input data from: ";
	return 1; //the specified variable was not found in the file
}