#include "pdp1.h"
#include "xgrafix.h"

char Revision[4]="1.11";

// Function void InitWindows(void) {{{
void InitWindows(void)
{
	register int i, isp;
	char buffer[50];

	// Set up each window structure {{{

	if (nsp) {
		// Item Number(t) {{{
		XGSet2D("linlin", "Time",
								"Number(t)", "closed",
								100, 400, 1.0, 1.0,
								True, True,
								0.0, 0.0, 0.0, 0.0);

		for (isp=0; isp<nsp; isp++)
			XGCurve(t_array, np_hist[isp], &hist_hi, isp);

		//******************************************* }}}
		// Item Vx-X Phase Space {{{
		for (isp=0; isp<nsp; isp++) {
			sprintf(buffer, "Vx-X Phase Space %d", isp+1);

			XGSet2D("linlin", "X",
									buffer, "closed",
									300, 10, dx, dx/dt,
									False, False,
									0.0, length, -vxscale, vxscale);

			XGScat2D(x[isp], vx[isp], &np[isp], isp);
		}
		//******************************************* }}}
		// Item Vy-Vx Phase Space {{{
		XGSet2D("linlin", "Vx",
								"Vy-Vx Phase Space", "closed",
								400, 10, dx/dt, dx/dt,
								False, False,
								-vxscale, vxscale, -vxscale, vxscale);

		for (isp=0; isp<nsp; isp++)
			XGScat2D(vx[isp], vy[isp], &np[isp], isp);

		//******************************************* }}}
		// Item N(x) {{{
		XGSet2D("linlin", "X",
								"N(x)", "closed",
								600, 500, dx, nc2p/area/dx,
								False, True,
								0.0, length, 0.0, 0.0);

		for (isp=0; isp<nsp; isp++)
			XGCurve(x_grid, sp_n[isp], &ng, isp);

		//******************************************* }}}
		// Item U(x) {{{
		XGSet2D("linlin", "X",
								"U(x)", "closed",
								650, 50, dx, 1.0,
								False, True,
								0.0, length, 0.0, 0.0);

		for (isp=0; isp<nsp; isp++)
			XGCurve(x_grid, sp_u_show[isp], &ng, isp);

		//******************************************* }}}
		// Item KE(x) [eV] {{{
		XGSet2D("linlin", "X",
								"KE(x) \\[eV\\]", "closed",
								650, 50, dx, 1.0,
								False, True,
								0.0, length, 0.0, 0.0);

		for (isp=0; isp<nsp; isp++)
			XGCurve(x_grid, sp_ke_show[isp], &ng, isp);

		//******************************************* }}}
		// Item J(x) {{{
		XGSet2D("linlin", "X",
								"J(x)", "closed",
								650, 50, dx, 1.0,
								False, True,
								0.0, length, 0.0, 0.0);

		for (isp=0; isp<nsp; isp++)
			XGCurve(x_grid, sp_j_show[isp], &ng, isp);

		//******************************************* }}}
		// Item J-E(x) {{{
		XGSet2D("linlin", "X",
								"J-E(x)", "closed",
								650, 50, dx, 1.0,
								False, True,
								0.0, length, 0.0, 0.0);

		for (isp=0; isp<nsp; isp++)
			XGCurve(x_grid, jdote_show[isp], &ng, isp);
		//******************************************* }}}
	}
	// Item Rho(x) {{{
	XGSet2D("linlin", "X",
							"Rho(x)", "closed",
							400, 100, dx, 1.0,
							False, True,
							0.0, length, 0.0, 0.0);

	XGCurve(x_grid, rho, &ng, 2);

	//******************************************* }}}
	// Item E field(x) {{{
	XGSet2D("linlin", "X",
							"E field(x)", "closed",
							500, 10, dx, 1.0,
							True, True,
							0.0, length, 0.0, 0.0);

	XGCurve(x_grid, e, &ng, 3);

	//******************************************* }}}
	// Item Potential(x) {{{
	XGSet2D("linlin", "X",
							"Potential(x)", "closed",
							400, 300, dx, 1.0,
							False, True,
							0.0, length, 0.0, 0.0);

	XGCurve(x_grid, phi, &ng, 4);

	//******************************************* }}}
	// Item Mid Potential(t) {{{
	XGSet2D("linlin", "Time",
							"Mid Potential(t)", "closed",
							500, 400, 1.0, 1.0,
							True, True,
							0.0, 0.0, 0.0, 0.0);

	XGCurve(t_array, com_phi_hist[1], &hist_hi, 4);

	//******************************************* }}}
	// Item LHS Potential(t) {{{
	XGSet2D("linlin", "Time",
							"LHS Potential(t)", "closed",
							700, 400, 1.0, 1.0,
							True, True,
							0.0, 0.0, 0.0, 0.0);

	XGCurve(t_array, com_phi_hist[0], &hist_hi, 4);

	//******************************************* }}}
	// Item Current(t) {{{
	XGSet2D("linlin", "Time",
							"Current(t)", "closed",
							600, 400, 1.0, 1.0,
							True, True,
							0.0, 0.0, 0.0, 0.0);

	XGCurve(t_array, com_cur_hist, &hist_hi, 4);

	//******************************************* }}}
	// Item Power(t) {{{
	XGSet2D("linlin", "Time",
							"Power(t)", "closed",
							550, 450, 1.0, 1.0,
							True, True,
							0.0, 0.0, 0.0, 0.0);

	XGCurve(t_array, com_pow_hist, &hist_hi, 4);

	//******************************************* }}}
	// Item Sigma(t) {{{
	XGSet2D("linlin", "Time",
							"Sigma(t)", "closed",
							500, 500, 1.0, 1.0,
							True, True,
							0.0, 0.0, 0.0, 0.0);

	XGCurve(t_array, wall_sigma_hist, &hist_hi, 3);

	//******************************************* }}}
	// Item Field Energy(t) {{{
	XGSet2D("linlog", "Time",
							"Field Energy(t)", "closed",
							650, 400, 1.0, 1.0,
							True, True,
							0.0, 0.0, 0.0, 0.0);

	XGCurve(t_array, ese_hist, &hist_hi, 4);

	//******************************************* }}}
	if (nsp) {
		// Item Ave Kinetic Energy(t) [eV] {{{
		XGSet2D("linlog", "Time",
								"Ave Kinetic Energy(t) \\[eV\\]", "closed",
								500, 200, 1.0, 1.0,
								True, True,
								0.0, 0.0, 0.0, 0.0);

		for (isp=0; isp<nsp; isp++)
			XGCurve(t_array, kes_hist[isp], &hist_hi, isp);

		//******************************************* }}}
		// Item Wall Charge(t) {{{
		XGSet2D("linlin", "Time",
								"Wall Charge(t)", "closed",
								600, 200, 1.0, 1.0,
								True, True,
								0.0, 0.0, 0.0, 0.0);

		for (isp=0; isp<nsp; isp++)
			XGCurve(t_array, jwall_hist[isp], &hist_hi, isp);

		//******************************************* }}}
		// Item F(E) {{{
		for (isp=0; isp<nsp; isp++) {
			sprintf(buffer, "F(E) %d", isp+1);

			XGSet2D("linlin", "E",
									buffer, "closed",
									650, 350, Escale[isp], nc2p,
									False, True,
									e_array[isp][0]*Escale[isp],
									e_array[isp][nbin[isp]-1]*Escale[isp],
									0.0, 0.0);

			XGCurve(e_array[isp], fe[isp], &nbin[isp], isp);
		}

		//******************************************* }}}
		// Item F(E) Mid {{{
		for (isp=0; isp<nsp; isp++) {
			sprintf(buffer, "F(E) Mid %d", isp+1);

			XGSet2D("linlog", "E",
									buffer, "closed",
									650, 350, Escale[isp], nc2p,
									False, True,
									emin_mid[isp]*Escale[isp],
									e_mid_array[isp][nbin_mid[isp]-1]*Escale[isp],
									0.0, 0.0);

			XGCurve(e_mid_array[isp], fe_mid_show[isp], &nbin_mid[isp], isp);
		}

		//******************************************* }}}
		// Item F(theta) {{{
		XGSet2D("linlin", "Theta",
								"F(theta)", "closed",
								600, 350, 180/M_PI, 1.0,
								False, True,
								0.0, 90.0, 0.0, 0.0);

		for (isp=0; isp<nsp; isp++)
			XGCurve(th_array[isp], ftheta[isp], &nbin[isp], isp);

		//******************************************* }}}
		// Item rate_title[i] {{{
		for (i=0; i<ndiag; i++) {
			XGSet2D("linlin", "X",
									rate_title[i], "closed",
									100, 500, dx, nc2p/(dx*area*dt),
									False, True,
									0.0, length, 0.0, 0.0);

			XGCurve(x_grid, rate_show[i], &ng, 3);
		}
		//******************************************* }}}
	}
	if (nfft) {
		if (nsp) {
			// Item Time Ave n(x) {{{
			XGSet2D("linlin", "X",
									"Time Ave n(x)", "closed",
									600, 500, dx, nc2p/area/dx,
									False, True,
									0.0, length, 0.0, 0.0);

			for (isp=0; isp<nsp; isp++)
				XGCurve(x_grid, sp_n_ave_show[isp], &ng, isp);

			//******************************************* }}}
			// Item Time Ave u(x) {{{
			XGSet2D("linlin", "X",
									"Time Ave u(x)", "closed",
									600, 500, dx, 1.0,
									False, True,
									0.0, length, 0.0, 0.0);

			for (isp=0; isp<nsp; isp++)
				XGCurve(x_grid, sp_u_ave_show[isp], &ng, isp);

			//******************************************* }}}
			// Item Time Ave j(x) {{{
			XGSet2D("linlin", "X",
									"Time Ave j(x)", "closed",
									600, 500, dx, 1.0,
									False, True,
									0.0, length, 0.0, 0.0);

			for (isp=0; isp<nsp; isp++)
				XGCurve(x_grid, sp_j_ave_show[isp], &ng, isp);

			//******************************************* }}}
			// Item Time Ave T(x) {{{
			XGSet2D("linlin", "X",
									"Time Ave T(x)", "closed",
									600, 500, dx, 1.0,
									False, True,
									0.0, length, 0.0, 0.0);

			for (isp=0; isp<nsp; isp++)
				XGCurve(x_grid, sp_ke_ave_show[isp], &ng, isp);
			//******************************************* }}}
		}
		// Item Time Ave E field(x) {{{
		XGSet2D("linlin", "X",
								"Time Ave E field(x)", "closed",
								10, 500, dx, 1.0,
								False, True,
								0.0, length, 0.0, 0.0);

		XGCurve(x_grid, e_ave_show, &ng, 3);

		//******************************************* }}}
		// Item Time Ave Potential(x) {{{
		XGSet2D("linlin", "X", "Time Ave Potential(x)", "closed",
								400, 300, dx, 1.0,
								False, True, 0.0, length, 0.0, 0.0);

		XGCurve(x_grid, phi_ave_show, &ng, 4);

		//******************************************* }}}
		// Item Local Mid Potential(t) {{{
		XGSet2D("linlin", "Time", "Local Mid Potential(t)", "closed",
								300, 550, 1.0, 1.0,
								True, True, 0.0, 0.0, 0.0, 0.0);

		XGCurve(Local_t_array, phi_hist[1], &thist_hi, 3);

		//******************************************* }}}
		// Item Local LHS Potential(t) {{{
		XGSet2D("linlin", "Time", "Local LHS Potential(t)", "closed",
								300, 550, 1.0, 1.0,
								True, True, 0.0, 0.0, 0.0, 0.0);

		XGCurve(Local_t_array, phi_hist[0], &thist_hi, 3);

		//******************************************* }}}
		// Item Local Current(t) {{{
		XGSet2D("linlin", "Time", "Local Current(t)", "closed",
								300, 550, 1.0, 1.0,
								True, True, 0.0, 0.0, 0.0, 0.0);

		XGCurve(Local_t_array, cur_hist, &thist_hi, 3);

		//******************************************* }}}
		// Item Local Power(t) {{{
		XGSet2D("linlin", "Time", "Local Power(t)", "closed",
								300, 550, 1.0, 1.0,
								True, True, 0.0, 0.0, 0.0, 0.0);

		XGCurve(Local_t_array, pow_hist, &thist_hi, 3);

		//******************************************* }}}
		// Item Mag of Mid V(f) {{{
		XGSet2D("linlog", "Freq", "Mag of Mid V(f)", "closed",
								100, 250, 1.0, 1.0,
								True, True, 0.0, 0.0, 0.0, 0.0);

		XGCurve(f_array, mphi_fft, &freq_hi, 4);

		//******************************************* }}}
		// Item Phase of Mid V(f) {{{
		XGSet2D("linlin", "Freq", "Phase of Mid V(f)", "closed",
								400, 250, 1.0, 1.0,
								True, False, 1.0, 1.0, -180.0, 180.0);

		XGCurve(f_array, mphi_fft+freq_hi, &freq_hi, 4);

		//******************************************* }}}
		// Item Mag of LHS V(f) {{{
		XGSet2D("linlog", "Freq", "Mag of LHS V(f)", "closed",
								100, 250, 1.0, 1.0,
								True, True, 0.0, 0.0, 0.0, 0.0);

		XGCurve(f_array, phi_fft, &freq_hi, 4);

		//******************************************* }}}
		// Item Phase of LHS V(f) {{{
		XGSet2D("linlin", "Freq", "Phase of LHS V(f)", "closed",
								400, 250, 1.0, 1.0,
								True, False, 1.0, 1.0, -180.0, 180.0);

		XGCurve(f_array, phi_fft+freq_hi, &freq_hi, 4);

		//******************************************* }}}
		// Item Mag of I(f) {{{
		XGSet2D("linlog", "Freq", "Mag of I(f)", "closed",
								100, 250, 1.0, 1.0,
								True, True, 0.0, 0.0, 0.0, 0.0);

		XGCurve(f_array, cur_fft, &freq_hi, 4);

		//******************************************* }}}
		// Item Phase of I(f) {{{
		XGSet2D("linlin", "Freq", "Phase of I(f)", "closed",
								400, 250, 1.0, 1.0,
								True, False, 1.0, 1.0, -180.0, 180.0);

		XGCurve(f_array, cur_fft+freq_hi, &freq_hi, 4);

		//******************************************* }}}
		// Item Mag of Power(f) {{{
		XGSet2D("linlog", "Freq", "Mag of Power(f)", "closed",
								100, 250, 1.0, 1.0,
								True, True, 0.0, 0.0, 0.0, 0.0);

		XGCurve(f_array, pow_fft, &freq_hi, 4);

		//******************************************* }}}
		// Item Phase of Power(f) {{{
		XGSet2D("linlin", "Freq", "Phase of Power(f)", "closed",
								400, 250, 1.0, 1.0,
								True, False, 1.0, 1.0, -180.0, 180.0);

		XGCurve(f_array, pow_fft+freq_hi, &freq_hi, 4);

		//******************************************* }}}
	}
	// }}}
} // }}}

// Function void Dump(char *filename) {{{

//*************************************************************
// Dumping the current state of the system into a binary file.
// Note: the binary file is written in the format used by IBM
// and DEC compatible machines (low bytes followed by high
// bytes). For this Dump() and Restore() call the functions
// sun_read() and sun_write().

void Dump(char *filename)
{
	register int i, isp,j;
	float ftemp;
	FILE *DMPFile;

	if ((DMPFile = fopen(filename, "w")) == NULL) {
		puts("Dump: open failed");
		return;
	}

	XGWrite((void *) Revision, strlen(Revision), 1,  DMPFile, "char");
	ftemp = (float) t;
	XGWrite((void *) (&ftemp), strlen(Revision), 1, DMPFile, "float");
	XGWrite((void *) (&oldsigma), strlen(Revision), 1, DMPFile, "float");
	XGWrite((void *) (&extq), strlen(Revision), 1, DMPFile, "float");
	XGWrite((void *) (&extq_1), strlen(Revision), 1, DMPFile, "float");
	XGWrite((void *) (&extq_2), strlen(Revision), 1, DMPFile, "float");
	XGWrite((void *) (&extq_3), strlen(Revision), 1, DMPFile, "float");
	XGWrite((void *) (&nsp), strlen(Revision), 1, DMPFile, "int");
	XGWrite((void *) jwall, strlen(Revision), nsp, DMPFile, "float");
	XGWrite((void *) np, strlen(Revision), nsp, DMPFile, "int");

	for (isp=0; isp<nsp; isp++) {
		for (i=0; i<np[isp]; i++) {
			ftemp = x[isp][i]/xnc;
			XGWrite(&ftemp, 4, 1, DMPFile, "float");
			ftemp = vscale*vx[isp][i];
			XGWrite(&ftemp, 4, 1, DMPFile, "float");
			ftemp = vscale*vy[isp][i];
			XGWrite(&ftemp, 4, 1, DMPFile, "float");
			ftemp = vscale*vz[isp][i];
			XGWrite(&ftemp, 4, 1, DMPFile, "float");
		}
	}

	// Dump Time average Values also


	if (nfft) {
		XGWrite(e_ave_show, 4, ng, DMPFile, "float");
		XGWrite(phi_ave_show, 4, ng, DMPFile, "float");
		for (j=0; j<nsp; j++)
			XGWrite(sp_ke_ave_show[j], 4, ng, DMPFile, "float");
		for (j=0; j<nsp; j++)
			XGWrite(sp_j_ave_show[j], 4, ng, DMPFile, "float");
		for (j=0; j<nsp; j++)
			XGWrite(sp_n_ave_show[j], 4, ng, DMPFile, "float");
		for (j=0; j<nsp; j++)
			XGWrite(sp_u_ave_show[j], 4, ng, DMPFile, "float");
	}


	fclose(DMPFile);
} // }}}

// Function void Restore(char *filename) {{{
void Restore(char *filename)
{
	char Rev[5];
	register int i, j, isp;
	float ftemp;
	FILE *DMPFile;

	if ((DMPFile = fopen(filename, "r+b")) == NULL) {
		puts("Dump: open failed");
		return;
	}
	XGRead(Rev, 1, 4, DMPFile, "char");
	for (i=0; i<4; i++)
		if (Rev[i]!=Revision[i]) {
			puts("Incompatible dump file version");
			exit(1);
		}
	XGRead((void *) (&ftemp), strlen(Revision), 1, DMPFile, "float");
	t = (double) ftemp;
	XGRead((void *) (&sigma), strlen(Revision), 1, DMPFile, "float");
	XGRead((void *) (&extq), strlen(Revision), 1, DMPFile, "float");
	XGRead((void *) (&extq_1), strlen(Revision), 1, DMPFile, "float");
	XGRead((void *) (&extq_2), strlen(Revision), 1, DMPFile, "float");
	XGRead((void *) (&extq_3), strlen(Revision), 1, DMPFile, "float");
	XGRead((void *) (&nsp), strlen(Revision), 1, DMPFile, "int");
	XGRead((void *) jwall, strlen(Revision), nsp, DMPFile, "float");
	XGRead((void *) np, strlen(Revision), nsp, DMPFile, "int");

	for (isp=0; isp<nsp; isp++) {
		for (i=0; i<np[isp]; i++) {
			XGRead(&ftemp, 4, 1, DMPFile, "float");
			x[isp][i] = ftemp*xnc;
			XGRead(&ftemp, 4, 1, DMPFile, "float");
			vx[isp][i]= ftemp/vscale;
			XGRead(&ftemp, 4, 1, DMPFile, "float");
			vy[isp][i]= ftemp/vscale;
			XGRead(&ftemp, 4, 1, DMPFile, "float");
			vz[isp][i]= ftemp/vscale;
		}
	}

	// Read Time average Values also
	if (nfft) {
		XGRead(e_ave_show, 4, ng, DMPFile, "float");
		XGRead(phi_ave_show, 4, ng, DMPFile, "float");
		for (j=0; j<nsp; j++)
			XGRead(sp_ke_ave_show[j], 4, ng, DMPFile, "float");
		for (j=0; j<nsp; j++)
			XGRead(sp_j_ave_show[j], 4, ng, DMPFile, "float");
		for (j=0; j<nsp; j++)
			XGRead(sp_n_ave_show[j], 4, ng, DMPFile, "float");
		for (j=0; j<nsp; j++)
			XGRead(sp_u_ave_show[j], 4, ng, DMPFile, "float");
	}

	fclose(DMPFile);
} // }}}

// Function void Quit(void) {{{
void Quit(void)
{
} // }}}


// Modeline for ViM {{{1
// vim:set ts=4:
// vim600:fdm=marker fdl=0 fdc=3:
// 1}}}