alloc_save_load_field_thread.cpp

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

void *Thread_Save_Field_yz(void *Dat)
{
	Data_Save_Slice *data = (Data_Save_Slice *)Dat;

	save_3D_yz(data->F_comp,data->n_3_slice,data->n_1_a,data->n_1_b,data->n_2_a,
		       data->n_2_b,data->iter,data->path_file_name);

	pthread_exit(NULL);
	
	return(NULL);//to disable the worning
}

///////////////////////////////////////////////////////////////////////////////////////
//Save xz slice from 3D data in ascii file
///////////////////////////////////////////////////////////////////////////////////////
void *Thread_Save_Field_xz(void *Dat)
{
	Data_Save_Slice *data = (Data_Save_Slice *)Dat;

	save_3D_xz(data->F_comp,data->n_1_a,data->n_1_b,data->n_3_slice,data->n_2_a,
		       data->n_2_b,data->iter,data->path_file_name);

	pthread_exit(NULL);
	
	return(NULL);//to disable the worning
}

///////////////////////////////////////////////////////////////////////////////////////
//Save F G E in binary file
///////////////////////////////////////////////////////////////////////////////////////
void *Thread_Save_FGE(void *Dat)
{
	Allocate_E_comp *data = (Allocate_E_comp *)Dat;
	
	char *file_name = NULL;
	file_name =(char *) calloc(256,sizeof(char));
	if (!file_name)
	{
		data->er = 1; //Memory allocation problem
		pthread_exit(NULL);
	}
	
	//make directory to save F G E
	mode_t Mode = S_IRWXU;
	mkdir(data->path,Mode);//for UNIX-AIX
	
	long i;

	//save in binary file
	for (i = 0; i<42; i++)
	{
		strcpy(file_name,data->path);
		strcat(file_name,"/");
		strcat(file_name,data->name[i]);
		save_3D_binary(*data->A[i],data->size[i][0],data->size[i][1],data->size[i][2],
			           0,file_name);
	}
	
	//the split of E (- 42) in two
	double ***E = NULL;
	E = *data->A[42];

	long lh_x, nx, ny, nz;
	nx = data->size[42][0];
	ny = data->size[42][1];
	nz = data->size[42][2];
	if (nx == 2*(nx/2))
	{
		lh_x = nx/2*ny*nz;
	}
	else
	{
		lh_x = (nx/2+1)*ny*nz;
	}
	
	//cout << data->name[42] << "nx = " << nx << " ny = " << ny << " nz = " << nz << " lh_x = " << lh_x << endl;

	strcpy(file_name,data->path);
	strcat(file_name,"/");
	strcat(file_name,data->name[42]);
	strcat(file_name,"_fst");
	if (save_1D_binary(E[0][0],nx/2*ny*nz,0,file_name))
	{
		cout << "error" << endl;
	}
	strcpy(file_name,data->path);
	strcat(file_name,"/");
	strcat(file_name,data->name[42]);
	strcat(file_name,"_sc");
	if (save_1D_binary(E[nx/2][0],lh_x,0,file_name))
	{
		cout << "error" << endl;
	}
	
	free(file_name);
	pthread_exit(NULL);
	
	return(NULL);//to disable the worning
}

///////////////////////////////////////////////////////////////////////////////////////
//Save B H in binary file
///////////////////////////////////////////////////////////////////////////////////////
void *Thread_Save_BH(void *Dat)
{
	Allocate_H_comp *data = (Allocate_H_comp *)Dat;
	
	char *file_name = NULL;
	file_name =(char *) calloc(256,sizeof(char));
	if (!file_name)
	{
		data->er = 1; //Memory allocation problem
		free(file_name);
		pthread_exit(NULL);
	}
	
	//make directory to save F G E
	mode_t Mode = S_IRWXU;
	mkdir(data->path,Mode);//for UNIX-AIX
	
	long i;

	//save in binary file
	for (i = 0; i<22; i++)
	{
		strcpy(file_name,data->path);
		strcat(file_name,"/");
		strcat(file_name,data->name[i]);
		save_3D_binary(*data->A[i],data->size[i][0],data->size[i][1],data->size[i][2],
			           0,file_name);
	}
	
	//the split of H ( 22 ) in two
	double ***H = NULL;
	H = *data->A[22];

	long lh_x, nx, ny, nz;
	nx = data->size[22][0];
	ny = data->size[22][1];
	nz = data->size[22][2];
	if (nx == 2*(nx/2))
	{
		lh_x = nx/2*ny*nz;
	}
	else
	{
		lh_x = (nx/2+1)*ny*nz;
	}
	//cout << data->name[22] << "nx = " << nx << " ny = " << ny << " nz = " << nz << " lh_x = " << lh_x << endl;

	strcpy(file_name,data->path);
	strcat(file_name,"/");
	strcat(file_name,data->name[22]);
	strcat(file_name,"_fst");
	
	if (save_1D_binary(H[0][0],nx/2*ny*nz,0,file_name))
	{
		cout << "error" << endl;
	}

	strcpy(file_name,data->path);
	strcat(file_name,"/");
	strcat(file_name,data->name[22]);
	strcat(file_name,"_sc");
	if (save_1D_binary(H[nx/2][0],lh_x,0,file_name))
	{
		cout << "error" << endl;
	}
	
	free(file_name);
	pthread_exit(NULL);
	
	return(NULL);//to disable the worning
}
	

///////////////////////////////////////////////////////////////////////////////////////
//Load F G E from binary file
///////////////////////////////////////////////////////////////////////////////////////
void *Thread_Load_FGE(void *Dat)
{
	Allocate_E_comp *data = (Allocate_E_comp *)Dat;

	char *file_name = NULL;
	file_name =(char *) calloc(256,sizeof(char));
	if (!file_name)
	{
		data->er = 1; //Memory allocation problem
		free(file_name);
		pthread_exit(NULL);
	}
	
	char buffer[256];
	long i;

	//load binary data
	for (i = 0; i < 42; i++)
	{
		strcpy(file_name,data->path);
		sprintf(buffer,"/%s_%isz%isz%i_0.dat",data->name[i],data->size[i][0],data->size[i][1],
			   data->size[i][2]);
		strcat(file_name,buffer);
		if (load_3D_binary(*data->A[i],data->size[i][0],data->size[i][1],data->size[i][2],
			               file_name))
		{
			data->er = 2; //error loading the file
			free(file_name);
			pthread_exit(NULL);
		}
	}
	
	
	//load the two splited E (- 42) field
	double ***E = NULL;
	E = *data->A[42];

	long lh_x, nx, ny, nz;
	nx = data->size[42][0];
	ny = data->size[42][1];
	nz = data->size[42][2];
	if (nx == 2*(nx/2))
	{
		lh_x = nx/2*ny*nz;
	}
	else
	{
		lh_x = (nx/2+1)*ny*nz;
	}
	
	//cout << data->name[42] << "nx = " << nx << " ny = " << ny << " nz = " << nz << " lh_x = " << lh_x << endl;

	strcpy(file_name,data->path);
	strcat(file_name,"/");
	strcat(file_name,data->name[42]);
	strcat(file_name,"_fst_0.dat");
	if (load_1D_binary(E[0][0],nx/2*ny*nz,file_name))
	{
		cout << "error" << endl;
	}
	strcpy(file_name,data->path);
	strcat(file_name,"/");
	strcat(file_name,data->name[42]);
	strcat(file_name,"_sc_0.dat");
	if (load_1D_binary(E[nx/2][0],lh_x,file_name))
	{
		cout << "error" << endl;
	}
	
	data->er = 0; //success
	free(file_name);
	pthread_exit(NULL);
	
	return(NULL);//to disable the worning
}

///////////////////////////////////////////////////////////////////////////////////////
//Load B H from binary file
///////////////////////////////////////////////////////////////////////////////////////
void *Thread_Load_BH(void *Dat)
{
	Allocate_H_comp *data = (Allocate_H_comp *)Dat;

	char *file_name = NULL;
	file_name =(char *) calloc(256,sizeof(char));
	if (!file_name)
	{
		data->er = 1; //Memory allocation problem
		free(file_name);
		pthread_exit(NULL);
	}
	
	char buffer[256];
	long i;

	//load binary data
	for (i = 0; i < 22; i++)
	{
		strcpy(file_name,data->path);
		sprintf(buffer,"/%s_%isz%isz%i_0.dat",data->name[i],data->size[i][0],data->size[i][1],
			    data->size[i][2]);
		strcat(file_name,buffer);
		if (load_3D_binary(*data->A[i],data->size[i][0],data->size[i][1],data->size[i][2],
			               file_name))
		{
			data->er = 2; //error loading the file
			free(file_name);
			pthread_exit(NULL);
		}
	}
	
	//load the two splited H ( 22 ) field
	double ***H = NULL;
	H = *data->A[22];

	long lh_x, nx, ny, nz;
	nx = data->size[22][0];
	ny = data->size[22][1];
	nz = data->size[22][2];
	if (nx == 2*(nx/2))
	{
		lh_x = nx/2*ny*nz;
	}
	else
	{
		lh_x = (nx/2+1)*ny*nz;
	}
	//cout << data->name[22] << "nx = " << nx << " ny = " << ny << " nz = " << nz << " lh_x = " << lh_x << endl;

	strcpy(file_name,data->path);
	strcat(file_name,"/");
	strcat(file_name,data->name[22]);
	strcat(file_name,"_fst_0.dat");
	
	if (load_1D_binary(H[0][0],nx/2*ny*nz,file_name))
	{
		cout << "error" << endl;
	}

	strcpy(file_name,data->path);
	strcat(file_name,"/");
	strcat(file_name,data->name[22]);
	strcat(file_name,"_sc_0.dat");
	if (load_1D_binary(H[nx/2][0],lh_x,file_name))
	{
		cout << "error" << endl;
	}
	
	data->er = 0; //success
	free(file_name);
	pthread_exit(NULL);
	
	return(NULL);//to disable the worning
}