#include"output.h"



void make_directory_for_result()
{
	string newfolder = "result";

#if defined(_WIN32)
	//一个简单的宏定义判断，如果是win系统 则运行以下代码
	if (_mkdir(newfolder.c_str()) != 0)
	{
		_mkdir(newfolder.c_str());
	}
	else
	{
		cout << "fail to create new folder for result file" << endl;
	}
	//end
#else 
	//如果是linux系统 则运行以下代码
	mkdir(newfolder.c_str(), 0777);
	if (mkdir(newfolder.c_str(), 0777) != 0)
	{
		mkdir(newfolder.c_str(), 0777);
	}
	else
	{
		cout << "fail to create new folder for result file" << endl;
	}
	//end
#endif

}

void couthere()
{
	// to test that the program can run up to here
	cout << "here" << endl;
}
void cinhere()
{
	// to test taht the program can run up here
	//and only show once
	double a;
	cout << "the program run here" << endl;
	cin >> a;
}

void output_error_form(double CFL, double dt_ratio, int mesh_set, int* mesh_number, double** error)
{
	cout << "Accuracy-residual-file-output" << endl;

	ofstream error_out("result/error.txt");
	error_out << "the CFL number is " << CFL << endl;
	error_out << "the dt ratio over dx is " << dt_ratio << endl;


	double** order = new double* [mesh_set - 1];
	for (int i = 0; i < mesh_set - 1; i++)
	{
		order[i] = new double[3];
		for (int j = 0; j < 3; j++)
		{
			order[i][j] = log(error[i][j] / error[i + 1][j]) / log(2);
		}
	}


	for (int i = 0; i < mesh_set; i++)
	{
		if (i == 0)
		{
			error_out << "1/" << mesh_number[i]
				<< scientific << setprecision(6)
				<< " & " << error[i][0] << " & ~"
				<< " & " << error[i][1] << " & ~"
				<< " & " << error[i][2] << " & ~"
				<< " \\\\ " << endl;
		}
		else
		{
			error_out << "1/" << mesh_number[i]
				<< " & " << scientific << setprecision(6) << error[i][0];
			error_out << " & " << fixed << setprecision(2) << order[i - 1][0];
			error_out << " & " << scientific << setprecision(6) << error[i][1];
			error_out << " & " << fixed << setprecision(2) << order[i - 1][1];
			error_out << " & " << scientific << setprecision(6) << error[i][2];
			error_out << " & " << fixed << setprecision(2) << order[i - 1][2];
			error_out << " \\\\ " << endl;
		}

	}
	error_out.close();
}


void output1d(Fluid1d* fluids, Block1d block)
{
	stringstream name;
	name << "result/Result1D-" << setfill('0') << setw(5) << block.step << ".plt" << endl;
	string s;
	name >> s;
	ofstream out(s);
	out << "variables = x,density,u,pressure,temperature,entropy,Ma" << endl;
	out << "zone i = " << block.nodex << ", F=POINT" << endl;

	//before output data, converting conservative varabile to primitive variable
	Convar_to_primvar(fluids, block);
	//output the data
	for (int i = block.ghost; i < block.ghost + block.nodex; i++)
	{
		out << fluids[i].cx << " "
			<< setprecision(10)
			<< fluids[i].primvar[0] << " "
			<< fluids[i].primvar[1] << " "
			<< fluids[i].primvar[2] << " "
			<< Temperature(fluids[i].primvar[0], fluids[i].primvar[2]) << " "
			<< entropy(fluids[i].primvar[0], fluids[i].primvar[2]) << " "
			<< sqrt(pow(fluids[i].primvar[1], 2)) / Soundspeed(fluids[i].primvar[0], fluids[i].primvar[2]) << " "
			<< endl;
	}
	out.close();
}

void continue_compute(Fluid2d* fluids, Block2d& block)
{
	fstream in("result/continue-in.txt", ios::in);
	if (!in.is_open())
	{
		cout << "cannot find continue.txt" << endl;
		cout << "a new case will start" << endl;
		return;
	}
	int in_mesh[2];
	in >> in_mesh[0] >> in_mesh[1];

	if (in_mesh[0] == block.nodex && in_mesh[1] == block.nodey)
	{

		fstream dat("result/continue-in.plt", ios::in);
		if (!dat.is_open())
		{
			cout << "cannot find continue.plt, which contains fluid data" << endl;
			cout << "a new case will start" << endl;
			return;
		}
		string s;
		getline(dat, s);
		dat.ignore(256, '\n');

		if (block.ghost <= 0 || block.ghost >= 5)
		{
			cout << "a wrong ghost set up initializing" << endl;
		}

		//cell avg information
		for (int j = block.ghost; j < block.ghost + block.nodey; j++)
		{
			for (int i = block.ghost; i < block.ghost + block.nodex; i++)
			{
				int index = i * block.ny + j;
				dat >> fluids[index].coordx
					>> fluids[index].coordy;

				for (int var = 0; var < 4; var++)
				{
					dat >> fluids[index].convar[var];
				}



			}

		}


		in >> block.t;
		cout << "successfully read in continue-compute-file in t= " << block.t << endl;

		Convar_to_Primvar(fluids, block);
		cout << "change convar to primvar" << endl;
	}
	else
	{
		cout << "mesh size is not same" << endl;
		cout << "a new case will start" << endl;
		return;
	}
	in.close();
	return;
}
void output2d(Fluid2d* fluids, Block2d block)
{
	//for create a output file, pls include the follow standard lib
	//#include <fstream>
	//#include <sstream>
	//#include<iomanip>
	output_record(block);
	stringstream name;
	name << "result/Result2D-" << setfill('0') << setw(5) << block.step << ".plt" << endl;
	string s;
	name >> s;
	ofstream out(s);
	out << "# CFL number is " << block.CFL << endl;
	out << "# tau type (0 refer euler, 1 refer NS) is " << tau_type << endl;
	if (tau_type == Euler)
	{
		out << "# c1_euler " << c1_euler << " c2_euler " << c2_euler << endl;
	}
	if (tau_type == NS)
	{
		out << "# Mu " << Mu << " Nu " << Nu << endl;
	}
	out << "# time marching strategy is " << block.stages << " stage method" << endl;
	out << "variables = x,y,density,u,v,pressure,temperature,entropy,Ma" << endl;
	out << "zone i = " << block.nodex << " " << ", j = " << block.nodey << ", F=POINT" << endl;

	//before output data, converting conservative varabile to primitive variable
	Convar_to_primvar(fluids, block);
	//output the data
	for (int j = block.ghost; j < block.ghost + block.nodey; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex; i++)
		{

			out << fluids[i * block.ny + j].coordx << " "
				<< fluids[i * block.ny + j].coordy << " "
				<< setprecision(10)
				<< fluids[i * block.ny + j].primvar[0] << " "
				<< fluids[i * block.ny + j].primvar[1] << " "
				<< fluids[i * block.ny + j].primvar[2] << " "
				<< fluids[i * block.ny + j].primvar[3] << " "
				<< Temperature(fluids[i * block.ny + j].primvar[0], fluids[i * block.ny + j].primvar[3]) << " "
				<< entropy(fluids[i * block.ny + j].primvar[0], fluids[i * block.ny + j].primvar[3]) << " "
				<< sqrt(pow(fluids[i * block.ny + j].primvar[1], 2) + pow(fluids[i * block.ny + j].primvar[2], 2)) /
				Soundspeed(fluids[i * block.ny + j].primvar[0], fluids[i * block.ny + j].primvar[3]) << " "
				<< endl;
		}
	}

	//fclose(fp);//关闭文件
	out.close();

}
void output2d_center(Fluid2d* fluids, Block2d block)
{
	output_record(block);
	stringstream name;
	name << "result/result2D-" << setfill('0') << setw(5) << block.step << ".plt" << endl;
	string s;
	name >> s;
	ofstream out(s);


	out << "# CFL number is " << block.CFL << endl;
	out << "# tau type (0 refer euler, 1 refer NS) is " << tau_type << endl;
	if (tau_type == Euler)
	{
		out << "# c1_euler " << c1_euler << " c2_euler " << c2_euler << endl;
	}
	if (tau_type == NS)
	{
		out << "# Mu " << Mu << " Nu " << Nu << endl;
	}
	out << "# time marching strategy is " << block.stages << " stage method" << endl;
	out << "variables = x,y,density,u,v,pressure,temperature,entropy,Ma" << endl;
	out << "zone i = " << block.nodex + 1 << " " << ", j = " << block.nodey + 1 << ", DATAPACKING=BLOCK, VARLOCATION=([3-9]=CELLCENTERED)" << endl;

	//output locations
	for (int j = block.ghost; j < block.ghost + block.nodey + 1; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex + 1; i++)
		{
			out << fluids[i * block.ny + j].node[0] << " ";
		}
		out << endl;
	}

	for (int j = block.ghost; j < block.ghost + block.nodey + 1; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex + 1; i++)
		{
			out << fluids[i * block.ny + j].node[1] << " ";
		}
		out << endl;
	}


	//before output data, converting conservative varabile to primitive variable
	Convar_to_primvar(fluids, block);
	//output the data

	//output four primary variables
	for (int var = 0; var < 4; var++)
	{
		for (int j = block.ghost; j < block.ghost + block.nodey; j++)
		{
			for (int i = block.ghost; i < block.ghost + block.nodex; i++)
			{
				out << setprecision(10)
					<< fluids[i * block.ny + j].primvar[var] << " ";
			}
			out << endl;
		}
	}
	//output temperature
	for (int j = block.ghost; j < block.ghost + block.nodey; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex; i++)
		{
			out << setprecision(10)
				<< Temperature(fluids[i * block.ny + j].primvar[0], fluids[i * block.ny + j].primvar[3]) << " ";
		}
		out << endl;
	}
	//output entropy
	for (int j = block.ghost; j < block.ghost + block.nodey; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex; i++)
		{
			out << setprecision(10)
				<< entropy(fluids[i * block.ny + j].primvar[0], fluids[i * block.ny + j].primvar[3]) << " ";
		}
		out << endl;
	}

	//output Ma number
	for (int j = block.ghost; j < block.ghost + block.nodey; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex; i++)
		{
			out << setprecision(10)
				<< sqrt(pow(fluids[i * block.ny + j].primvar[1], 2))
				/ Soundspeed(fluids[i * block.ny + j].primvar[0], fluids[i * block.ny + j].primvar[3]) << " ";
		}
		out << endl;
	}

	//fclose(fp);//关闭文件
	out.close();
}

void output2d_blow_up(Fluid2d* fluids, Block2d block)
{
	output_record(block);
	stringstream name;
	name << "result/BlowUp-2D-" << setfill('0') << setw(5) << block.step << ".plt" << endl;
	string s;
	name >> s;
	ofstream out(s);
	out << "# CFL number is " << block.CFL << endl;
	out << "# tau type (0 refer euler, 1 refer NS) is " << tau_type << endl;
	if (tau_type == Euler)
	{
		out << "# c1_euler " << c1_euler << " c2_euler " << c2_euler << endl;
	}
	if (tau_type == NS)
	{
		out << "# Mu " << Mu << " Nu " << Nu << endl;
	}
	out << "# time marching strategy is " << block.stages << " stage method" << endl;
	out << "variables = x,y,blow_point,density,u,v,pressure" << endl;
	out << "zone i = " << block.nodex + 1 << " " << ", j = " << block.nodey + 1 << ", DATAPACKING=BLOCK, VARLOCATION=([3-7]=CELLCENTERED)" << endl;

	//output locations
	for (int j = block.ghost; j < block.ghost + block.nodey + 1; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex + 1; i++)
		{
			out << fluids[i * block.ny + j].node[0] << " ";
		}
		out << endl;
	}

	for (int j = block.ghost; j < block.ghost + block.nodey + 1; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex + 1; i++)
		{
			out << fluids[i * block.ny + j].node[1] << " ";
		}
		out << endl;
	}


	//before output data, converting conservative varabile to primitive variable
	Convar_to_primvar(fluids, block);
	//output the data

	for (int j = block.ghost; j < block.ghost + block.nodey; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex; i++)
		{
			if (negative_density_or_pressure(fluids[i * block.ny + j].primvar))
			{
				out << 1.0 << " ";
			}
			else
			{
				out << 0.0 << " ";
			}
		}
		out << endl;
	}
	//output four primary variables
	for (int var = 0; var < 4; var++)
	{
		for (int j = block.ghost; j < block.ghost + block.nodey; j++)
		{
			for (int i = block.ghost; i < block.ghost + block.nodex; i++)
			{
				if (negative_density_or_pressure(fluids[i * block.ny + j].primvar))
				{
					out << -1.0 << " ";
				}
				else
				{
					out << setprecision(10)
						<< fluids[i * block.ny + j].primvar[var] << " ";
				}
			}
			out << endl;
		}
	}


	//fclose(fp);//关闭文件
	out.close();
}
void output_record(Block2d block)
{
	//输出一下二维的模拟工况，为了方便记录之用
	stringstream name;
	name << "result/Record2D-" << setfill('0') << setw(5) << block.step << ".txt" << endl;
	string s;
	name >> s;
	ofstream out(s);
	out << "# This is a two dimensional result" << endl;
	if (block.uniform == true)
	{
		out << "# uniform mesh is used for calculation" << endl;
		out << "# left region coordinate " << endl;
		out << block.left << endl;
		out << "# right region coordinate " << endl;
		out << block.right << endl;
		out << "# down region coordinate " << endl;
		out << block.down << endl;
		out << "# up region coordinate " << endl;
		out << block.up << endl;
	}
	else
	{
		out << "# non-uniform mesh is used for calculation" << endl;
	}
	out << "# ghost cell number is " << endl;
	out << block.ghost << endl;

	out << "# Mesh size nodex and nodey" << endl;
	out << block.nodex << " " << block.nodey << endl;
	out << "# CFL number is " << endl;
	out << block.CFL << endl;
	out << "# simulation time is " << endl;
	out << block.t << endl;
	out << "# simulation step is " << endl;
	out << block.step << endl;
	out << "# tau type (0 refer euler, 1 refer NS) is " << endl;
	out << tau_type << endl;

	if (tau_type == Euler)
	{
		out << "# c1_euler " << " c2_euler " << endl;
		out << c1_euler << " " << c2_euler << endl;
	}

	if (tau_type == NS)
	{
		out << "# Mu " << " Nu " << endl;
		out << Mu << " " << Nu << endl;
	}
	out << "# the number of gaussian point it use: " << endl;
	out << gausspoint << endl;

	out << "# normal_reconstruction_for_left_right_states is ";
	if (cellreconstruction_2D_normal == First_order_normal)
	{
		out << "FirstOrder_splitting " << endl;
	}
	else if (cellreconstruction_2D_normal == Vanleer_normal)
	{
		out << "Vanleer_splitting " << endl;
	}
	else
	{
		out << "not_specified" << endl;
	}


	out << "# normal_reconstruction_for_g0_states is ";
	if (g0reconstruction_2D_normal == Center_collision_normal)
	{
		out << "Center_collision_normal " << endl;
	}
	else if (g0reconstruction_2D_normal == Center_3rd_normal)
	{
		out << "Center_3rd_normal " << endl;
	}
	else
	{
		out << "not_specified" << endl;
	}

	out << "# tangential_reconstruction_for_left_right_states is ";
	if (cellreconstruction_2D_tangent == Vanleer_tangent)
	{
		out << "Vanleer_tangent " << endl;
	}
	else if (cellreconstruction_2D_tangent == First_order_tangent)
	{
		out << "First_order_tangent " << endl;
	}
	else
	{
		out << "not_specified" << endl;
	}

	out << "# g0reconstruction_2D_multi is ";
	if (g0reconstruction_2D_tangent == Center_all_collision_multi)
	{
		out << "Center_all_collision_tangent " << endl;
	}
	else if (g0reconstruction_2D_tangent == Center_3rd_tangent)
	{
		out << "Center_all_collision_tangent " << endl;
	}
	else
	{
		out << "not_specified" << endl;
	}

	out << "# time marching strategy is ";
	if (timecoe_list_2d == S1O1_2D)
	{
		out << "S1O1 " << endl;
	}
	if (timecoe_list_2d == S2O4_2D)
	{
		out << "S2O4 " << endl;
	}
	if (timecoe_list_2d == RK4_2D)
	{
		out << "RK4 " << endl;
	}

	out << "# the flux function is ";
	if (flux_function_2d == GKS2D_smooth)
	{
		out << "gks2nd_smooth" << endl;
	}
	if (flux_function_2d == GKS2D)
	{
		if (gks2dsolver == kfvs1st_2d)
		{
			out << "kfvs1st " << endl;
		}
		if (gks2dsolver == kfvs2nd_2d)
		{
			out << "kfvs2nd " << endl;
		}
		if (gks2dsolver == gks1st_2d)
		{
			out << "gks1st " << endl;
		}
		if (gks2dsolver == gks2nd_2d)
		{
			out << "gks2nd " << endl;
		}
	}

	out << "# the limitation for current scheme is " << endl;
	out.close();
}
void output2d_binary(Fluid2d* fluids, Block2d block)
{
	cout << "Output binary result..." << endl;
	//before output data, converting conservative varabile to primitive variable
	Convar_to_primvar(fluids, block);

	output_record(block);
	stringstream name;
	name << "result/Result2D-" << setfill('0') << setw(5) << block.step << ".plt" << endl;
	string s;
	name >> s;
	ofstream out;
	out.open(s, ios::out | ios::binary);

	int IMax = block.nodex;
	int JMax = block.nodey;
	int KMax = 1;
	int NumVar = 7;

	char Title[] = "structure2d";


	char Varname1[] = "X";
	char Varname2[] = "Y";
	char Varname3[] = "Z";
	char Varname4[] = "density";
	char Varname5[] = "u";
	char Varname6[] = "v";
	char Varname7[] = "pressure";

	char Zonename1[] = "Zone 001";

	float ZONEMARKER = 299.0;

	float EOHMARKER = 357.0;

	//==============Header Secontion =================//

	//------1.1 Magic number, Version number

	char MagicNumber[] = "#!TDV101";

	// the magic number must be output with 8 lengths without NULL end
	out.write(MagicNumber, 8);
	//---- - 1.2.Integer value of 1.----------------------------------------------------------

	int IntegerValue = 1;
	out.write((char*)&IntegerValue, sizeof(IntegerValue));

	//---- - 1.3.Title and variable names.------------------------------------------------ -

	//---- - 1.3.1.The TITLE.
	write_character_into_plt(Title, out);
	//---- - 1.3.2 Number of variables(NumVar) in the c_strfile.



	out.write((char*)&NumVar, sizeof(NumVar));


	//------1.3.3 Variable names.N = L[1] + L[2] + ....L[NumVar]

	write_character_into_plt(Varname1, out);
	write_character_into_plt(Varname2, out);
	write_character_into_plt(Varname3, out);
	write_character_into_plt(Varname4, out);
	write_character_into_plt(Varname5, out);
	write_character_into_plt(Varname6, out);
	write_character_into_plt(Varname7, out);

	//---- - 1.4.Zones------------------------------------------------------------------ -

	//--------Zone marker.Value = 299.0

	out.write((char*)&ZONEMARKER, sizeof(ZONEMARKER));

	//--------Zone name.
	write_character_into_plt(Zonename1, out);
	//--------Zone color

	int ZoneColor = -1;

	out.write((char*)&ZoneColor, sizeof(ZoneColor));

	//--------ZoneType

	int ZoneType = 0;

	out.write((char*)&ZoneType, sizeof(ZoneType));

	//--------DaraPacking 0=Block, 1=Point

	int DaraPacking = 1;

	out.write((char*)&DaraPacking, sizeof(DaraPacking));
	//--------Specify Var Location. 0 = Don't specify, all c_str is located at the nodes. 1 = Specify

	int SpecifyVarLocation = 0;

	out.write((char*)&SpecifyVarLocation, sizeof(SpecifyVarLocation));
	//--------Number of user defined face neighbor connections(value >= 0)

	int NumOfNeighbor = 0;

	out.write((char*)&NumOfNeighbor, sizeof(NumOfNeighbor));

	//-------- - IMax, JMax, KMax

	out.write((char*)&IMax, sizeof(IMax));
	out.write((char*)&JMax, sizeof(JMax));
	out.write((char*)&KMax, sizeof(KMax));

	//----------// -1 = Auxiliary name / value pair to follow 0 = No more Auxiliar name / value pairs.

	int AuxiliaryName = 0;

	out.write((char*)&AuxiliaryName, sizeof(AuxiliaryName));

	//----I HEADER OVER--------------------------------------------------------------------------------------------

	//=============================Geometries section=======================

	//=============================Text section======================

	// EOHMARKER, value = 357.0

	out.write((char*)&EOHMARKER, sizeof(EOHMARKER));

	//================II.Data section===============//

	//---- - 2.1 zone---------------------------------------------------------------------- -

	out.write((char*)&ZONEMARKER, sizeof(ZONEMARKER));

	//--------variable c_str format, 1 = Float, 2 = Double, 3 = LongInt, 4 = ShortInt, 5 = Byte, 6 = Bit

	int fomat[20];
	for (int ifomat = 0; ifomat < 20; ifomat++)
	{
		fomat[ifomat] = 2;
	}
	for (int ifomat = 0; ifomat < NumVar; ifomat++)
	{
		out.write((char*)&fomat[ifomat], sizeof(fomat[ifomat]));
	}


	//--------Has variable sharing 0 = no, 1 = yes.

	int HasVarSharing = 0;

	out.write((char*)&HasVarSharing, sizeof(HasVarSharing));

	//----------Zone number to share connectivity list with(-1 = no sharing).

	int ZoneNumToShareConnectivity = -1;

	out.write((char*)&ZoneNumToShareConnectivity, sizeof(ZoneNumToShareConnectivity));
	//----------Zone c_str.Each variable is in c_str format asspecified above.
	for (int j = block.ghost; j < block.ghost + block.nodey; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex; i++)
		{
			double coordz = 0.0;
			out.write((char*)&fluids[i * block.ny + j].coordx, sizeof(double));
			out.write((char*)&fluids[i * block.ny + j].coordy, sizeof(double));
			out.write((char*)&coordz, sizeof(double));
			out.write((char*)&fluids[i * block.ny + j].primvar[0], sizeof(double));
			out.write((char*)&fluids[i * block.ny + j].primvar[1], sizeof(double));
			out.write((char*)&fluids[i * block.ny + j].primvar[2], sizeof(double));
			out.write((char*)&fluids[i * block.ny + j].primvar[3], sizeof(double));
		}

	}
	out.close();

}
void write_character_into_plt(char* str, ofstream& out)
{
	int value = 0;
	while ((*str) != '\0')
	{
		value = (int)*str;
		out.write((char*)&value, sizeof(value));
		str++;
	}

	char null_char[] = "";
	value = (int)*null_char;
	out.write((char*)&value, sizeof(value));
}
void continue_compute_output(Fluid2d* fluids, Block2d block)
{
	//for create a output file, pls include the follow standard lib
	//#include <fstream>
	//#include <sstream>
	//#include<iomanip>
	continue_compute_output_param(block);
	stringstream name;
	name << "result/continue-out" << ".plt" << endl;
	string s;
	name >> s;
	ofstream out(s);
	out << "variables = x,y,convar0,convar1,convar2,convar3";
	out << endl;

	out << "zone i = " << block.nodex << " " << ", j = " << block.nodey << ", F=POINT" << endl;

	//before output data, converting conservative varabile to primitive variable
	Convar_to_primvar(fluids, block);

	//output the data
	for (int j = block.ghost; j < block.ghost + block.nodey; j++)
	{
		for (int i = block.ghost; i < block.ghost + block.nodex; i++)
		{
			out << fluids[i * block.ny + j].coordx << " "
				<< fluids[i * block.ny + j].coordy << " "
				<< setprecision(10);
			for (int var = 0; var < 4; var++)
			{
				out << fluids[i * block.ny + j].convar[var] << " ";
			}

			out << endl;
		}
	}

	out.close();
}
void continue_compute_output_param(Block2d block)
{
	stringstream name;
	name << "result/continue-out" << ".txt" << endl;
	string s;
	name >> s;
	ofstream out(s);
	out << block.nodex << " " << block.nodey << endl; //mesh point
	out << setprecision(14);
	out << block.t << endl;//simulation time
}