PageRenderTime 340ms CodeModel.GetById 18ms app.highlight 274ms RepoModel.GetById 1ms app.codeStats 1ms

/leggi_bin/parametri.cpp

https://github.com/ALaDyn/tools-ALaDyn
C++ | 2409 lines | 2331 code | 62 blank | 16 comment | 1083 complexity | 5d49a93e16095f2a2f88087362321990 MD5 | raw file
   1#ifndef __BINNING_C
   2#define __BINNING_C
   3
   4#include "leggi_binario_ALaDyn_fortran.h"
   5
   6
   7
   8/* costruttore default - inizializza a zero per ora. Siccome tutto e' inizializzato a zero
   9non puo' nemmeno calcolare le le dimensioni dei bin!
  10Verificare che non ci siano cose intelligenti da poter fare! */
  11Parametri::Parametri()
  12{
  13	intpar.resize(NUMERO_PARAMETRI_FILE_DAT, 0);
  14	realpar.resize(NUMERO_PARAMETRI_FILE_DAT, 0.0);
  15	subsample = 1;
  16	span = 5;
  17	ncpu_x = ncpu_y = ncpu_z = ncpu = 0;
  18	ndv = npunti_x = npunti_x_ricampionati = fattore_ricampionamento = npunti_y_ricampionati = npunti_z_ricampionati = npx_per_cpu = npy_per_cpu = npz_per_cpu = 0;
  19	endianness = 0;
  20	nuovi_dati_su_griglia = false;
  21	multifile = false;
  22	stretched_grid = true;
  23	stretched_along_x = 1;
  24	massa_particella_MeV = 0.;
  25	nbin = nbin_x = nbin_px = nbin_y = nbin_py = nbin_z = nbin_pz = nbin_w = nbin_E = nbin_gamma = nbin_theta = nbin_thetaT = nbin_ty = nbin_tz = 120;
  26	tnow = 0.0;
  27	xmin = pxmin = ymin = pymin = zmin = pzmin = wmin = thetamin = thetaTmin = Emin = gammamin = 0.0;
  28	xmax = pxmax = ymax = pymax = zmax = pzmax = wmax = thetamax = thetaTmax = Emax = gammamax = 1.0;
  29	tymin = tzmin = -1.0;
  30	tymax = tzmax = 1.0;
  31	ymin_b = ymax_b = pymin_b = pymax_b = zmin_b = zmax_b = pzmin_b = pzmax_b = wmin_b = wmax_b = gammamin_b = gammamax_b = true;
  32	xmin_b = xmax_b = pxmin_b = pxmax_b = Emin_b = Emax_b = thetaTmin_b = thetaTmax_b = thetamin_b = thetamax_b = true;
  33	tymin_b = tymax_b = tzmin_b = tzmax_b = nbin_ty_b = nbin_tz_b = true;
  34	nbin_b = true;
  35	nbin_E_b = nbin_theta_b = nbin_thetaT_b = nbin_gamma_b = true;
  36	nbin_x_b = nbin_px_b = nbin_y_b = nbin_py_b = nbin_z_b = nbin_pz_b = true;
  37	fai_plot_wspec = fai_plot_Espec = fai_plot_thetaspec = fai_plot_thetaTspec = fai_plot_Etheta = fai_plot_EthetaT = false;
  38	fai_plot_xy = fai_plot_xz = fai_plot_yz = fai_plot_xpx = fai_plot_xpy = fai_plot_xpz = fai_plot_ypx = false;
  39	fai_plot_ypy = fai_plot_ypz = fai_plot_zpx = fai_plot_zpy = fai_plot_zpz = fai_plot_pxpy = fai_plot_pxpz = fai_plot_pypz = fai_plot_xw = fai_plot_rcf = false;
  40	overwrite_weight = false;
  41	overwrite_weight_value = 1.0;
  42	do_not_ask_missing = false;
  43
  44	last_cpu = MAX_NUMBER_OF_CPUS;		// il tool funziona quindi per un ncpu_max, attualmente, pari a 32768
  45
  46	for (int i = 0; i < NPARAMETRI; i++)
  47	{
  48		p_b[i] = true;
  49		p[i] = -1;
  50	}
  51
  52	old_fortran_bin = false;
  53	endian_file = 0;
  54	endian_machine = is_big_endian();
  55	file_particelle_P = file_particelle_E = file_particelle_HI = file_particelle_LI = false;
  56	file_campi_Ex = file_campi_Ey = file_campi_Ez = file_campi_Bx = file_campi_By = file_campi_Bz = false;
  57	file_densita_elettroni = file_densita_protoni = file_densita_LI = file_densita_HI = file_densita_driver = false;
  58	file_densita_energia_griglia_elettroni = file_densita_energia_griglia_protoni = file_densita_energia_griglia_HI = file_densita_energia_griglia_LI = false;
  59}
  60
  61
  62
  63float Parametri::dimmi_dimx()
  64{
  65	return (xmax - xmin) / static_cast <float> (nbin_x);
  66}
  67float Parametri::dimmi_dimy()
  68{
  69	return (ymax - ymin) / static_cast <float> (nbin_y);
  70}
  71float Parametri::dimmi_dimz()
  72{
  73	return (zmax - zmin) / static_cast <float> (nbin_z);
  74}
  75float Parametri::dimmi_dimty()
  76{
  77	return (tymax - tymin) / static_cast <float> (nbin_ty);
  78}
  79float Parametri::dimmi_dimtz()
  80{
  81	return (tzmax - tzmin) / static_cast <float> (nbin_tz);
  82}
  83float Parametri::dimmi_dimpx()
  84{
  85	return (pxmax - pxmin) / static_cast <float> (nbin_px);
  86}
  87float Parametri::dimmi_dimpy()
  88{
  89	return (pymax - pymin) / static_cast <float> (nbin_py);
  90}
  91float Parametri::dimmi_dimpz()
  92{
  93	return (pzmax - pzmin) / static_cast <float> (nbin_pz);
  94}
  95float Parametri::dimmi_dimw()
  96{
  97	return (wmax - wmin) / static_cast <float> (nbin_w);
  98}
  99float Parametri::dimmi_dimgamma()
 100{
 101	return (gammamax - gammamin) / static_cast <float> (nbin_gamma);
 102}
 103float Parametri::dimmi_dimtheta()
 104{
 105	return (thetamax - thetamin) / static_cast <float> (nbin_theta);
 106}
 107float Parametri::dimmi_dimthetaT()
 108{
 109	return (thetaTmax - thetaTmin) / static_cast <float> (nbin_thetaT);
 110}
 111float Parametri::dimmi_dimE()
 112{
 113	return (Emax - Emin) / static_cast <float> (nbin_E);
 114}
 115
 116
 117int Parametri::dimmi_nbin(int colonna)
 118{
 119	if (colonna == 0)		return nbin_x;
 120	else if (colonna == 1)	return nbin_y;
 121	else if (colonna == 2)	return nbin_z;
 122	else if (colonna == 3)	return nbin_px;
 123	else if (colonna == 4)	return nbin_py;
 124	else if (colonna == 5)	return nbin_pz;
 125	else if (colonna == 6)	return nbin_gamma;
 126	else if (colonna == 7)	return nbin_theta;
 127	else if (colonna == 8)	return nbin_E;
 128	else if (colonna == 9)	return nbin_thetaT;
 129	else if (colonna == 10)	return nbin_ty;
 130	else if (colonna == 11)	return nbin_tz;
 131	else if (colonna == 12)	return nbin_w;
 132	else return 120;
 133}
 134
 135
 136
 137float Parametri::dimmi_dim(int colonna)
 138{
 139	if (colonna == 0)		return dimmi_dimx();
 140	else if (colonna == 1)	return dimmi_dimy();
 141	else if (colonna == 2)	return dimmi_dimz();
 142	else if (colonna == 3)	return dimmi_dimpx();
 143	else if (colonna == 4)	return dimmi_dimpy();
 144	else if (colonna == 5)	return dimmi_dimpz();
 145	else if (colonna == 6)	return dimmi_dimgamma();
 146	else if (colonna == 7)	return dimmi_dimtheta();
 147	else if (colonna == 8)	return dimmi_dimE();
 148	else if (colonna == 9)	return dimmi_dimthetaT();
 149	else if (colonna == 10)	return dimmi_dimty();
 150	else if (colonna == 11)	return dimmi_dimtz();
 151	else if (colonna == 12)	return dimmi_dimw();
 152	else return 1.0;
 153}
 154
 155
 156void Parametri::leggi_file_dat(std::ifstream& file_dat)
 157{
 158	std::string riga_persa;
 159	int fattore_ricampionamento;
 160	int discriminante_versione_file;
 161	float coord;
 162	std::getline(file_dat, riga_persa);	// per leggere la riga Integer parameters
 163
 164	for (int i = 0; i < NUMERO_PARAMETRI_FILE_DAT; i++) file_dat >> intpar[i];
 165	ncpu_x = 1;
 166	ncpu_y = intpar[0];
 167	ncpu_z = intpar[1];
 168	ncpu = ncpu_x * ncpu_y * ncpu_z;
 169	npunti_x = intpar[2];
 170	npunti_x_ricampionati = intpar[3];
 171	fattore_ricampionamento = npunti_x / npunti_x_ricampionati;
 172	npx_per_cpu = npunti_x_ricampionati;
 173	npunti_y_ricampionati = intpar[4];
 174	npy_per_cpu = intpar[5];
 175	npunti_z_ricampionati = intpar[6];
 176	npz_per_cpu = intpar[7];
 177	ndv = intpar[17];
 178	discriminante_versione_file = intpar[18];	// poco piu' sotto viene poi associato a parametri->nuovi_dati_su_griglia che e' un semplice bool e di piu' difficile lettura
 179	endianness = intpar[19];
 180
 181	std::getline(file_dat, riga_persa);	// per pulire i caratteri rimanenti sull'ultima riga degli interi
 182	std::getline(file_dat, riga_persa);	// per leggere la riga Real parameters
 183
 184	for (int i = 0; i < NUMERO_PARAMETRI_FILE_DAT; i++) file_dat >> realpar[i];
 185	tnow = realpar[0];
 186	xmin = realpar[1];
 187	xmax = realpar[2];
 188	ymin = realpar[3];
 189	ymax = realpar[4];
 190	zmin = realpar[5];
 191	zmax = realpar[6];
 192
 193	if (file_particelle_P || file_particelle_E || file_particelle_HI || file_particelle_LI)
 194	{
 195		if (ndv == 4 || ndv == 6) p[WEIGHT] = 0;
 196		else if (ndv == 5 || ndv == 7) p[WEIGHT] = 1;
 197		else printf("Attenzione: valore illegale di ndv\n"), exit(-17);
 198		if (ndv == 4 || ndv == 5) zmin = 0.0, zmax = 1.0;
 199		p[NCOLONNE] = ndv;
 200		p_b[NCOLONNE] = false;
 201		p_b[WEIGHT] = false;
 202	}
 203	else
 204	{
 205		if (npunti_z_ricampionati == 1) zmin = 0.0, zmax = 1.0;
 206		if (discriminante_versione_file == -1) nuovi_dati_su_griglia = true;
 207		p[WEIGHT] = 0;
 208		p[NCOLONNE] = npunti_z_ricampionati;
 209		p_b[NCOLONNE] = false;
 210		p_b[WEIGHT] = false;
 211
 212		if (nuovi_dati_su_griglia)
 213		{
 214			std::getline(file_dat, riga_persa);	// per pulire i caratteri rimanenti sull'ultima riga dei float
 215			std::getline(file_dat, riga_persa);	// per togliere la riga vuota che separa la griglia dai parametri
 216
 217
 218			for (int i = 0; i < npunti_x_ricampionati; i++)
 219			{
 220				file_dat >> coord;
 221				xcoord.push_back(coord);
 222			}
 223			for (int i = 0; i < npunti_y_ricampionati; i++)
 224			{
 225				file_dat >> coord;
 226				ycoord.push_back(coord);
 227			}
 228			for (int i = 0; i < npunti_z_ricampionati; i++)
 229			{
 230				file_dat >> coord;
 231				zcoord.push_back(coord);
 232			}
 233		}
 234		else			// mettiamo una griglia temporanea fissa, che al limite sara' sovrascritta da quella stretchata se presente nel binario
 235		{
 236			float dx, dy, dz;
 237			if (npunti_x_ricampionati > 1) dx = (xmax - xmin) / (npunti_x_ricampionati - 1);
 238			else dx = (xmax - xmin);
 239			if (npunti_y_ricampionati > 1) dy = (ymax - ymin) / (npunti_y_ricampionati - 1);
 240			else dy = (ymax - ymin);
 241			if (npunti_z_ricampionati > 1) dz = (zmax - zmin) / (npunti_z_ricampionati - 1);
 242			else dz = (zmax - zmin);
 243
 244			for (int i = 0; i < npunti_x_ricampionati; i++)
 245			{
 246				coord = xmin + dx*i;
 247				xcoord.push_back(coord);
 248			}
 249			for (int i = 0; i < npunti_y_ricampionati; i++)
 250			{
 251				coord = ymin + dy*i;
 252				ycoord.push_back(coord);
 253			}
 254			for (int i = 0; i < npunti_z_ricampionati; i++)
 255			{
 256				coord = zmin + dz*i;
 257				zcoord.push_back(coord);
 258			}
 259		}
 260	}
 261	endian_file = (endianness - 1);
 262}
 263
 264void Parametri::chiedi_numero_colonne()
 265{
 266	int ncolonne;
 267	std::cout << "Il file contiene 4, 5, 6 o 7 colonne? ";
 268	std::cin >> ncolonne;
 269	if (ncolonne == 6 || ncolonne == 4) p[WEIGHT] = 0;
 270	else if (ncolonne == 7 || ncolonne == 5) p[WEIGHT] = 1;
 271	else exit(-5);
 272	p[NCOLONNE] = ncolonne;
 273	p_b[NCOLONNE] = false;
 274	p_b[WEIGHT] = false;
 275}
 276
 277
 278void Parametri::chiedi_2Do3D()
 279{
 280	int dimensioni;
 281	std::cout << "E' una griglia 3D (3) o 2D (2)? ";
 282	std::cin >> dimensioni;
 283	if (dimensioni == 2) p[NCOLONNE] = 1;
 284	else if (dimensioni == 3) p[NCOLONNE] = 3;
 285	else
 286	{
 287		std::cout << "Choice not valid" << std::endl;
 288		exit(-5);
 289	}
 290	p_b[NCOLONNE] = false;
 291}
 292
 293
 294void Parametri::chiedi_endian_file()
 295{
 296	std::cout << "Il file e' little [x86] (0) o big [ppc] (1) endian? ";
 297	std::cin >> endian_file;
 298	if (endian_file != 1 && endian_file != 0) exit(-4);
 299}
 300
 301
 302void Parametri::check_filename(const char *nomefile)
 303{
 304	if (nomefile[0] == 'P')
 305	{
 306		if (nomefile[1] == 'r')
 307		{
 308			if (nomefile[2] == 'p')
 309			{
 310				massa_particella_MeV = (float)MP_MEV;
 311				file_particelle_P = true;
 312			}
 313			else if (nomefile[2] == 'e')
 314			{
 315				file_densita_energia_griglia_protoni = true;
 316				sprintf(support_label, "pren");
 317			}
 318			else
 319			{
 320				std::cout << "File non riconosciuto" << std::endl;
 321				exit(-15);
 322			}
 323		}
 324		else if (nomefile[1] == 'd')
 325		{
 326			file_densita_protoni = true;
 327			sprintf(support_label, "pden");
 328		}
 329		else
 330		{
 331			std::cout << "File non riconosciuto" << std::endl;
 332			exit(-15);
 333		}
 334	}
 335	else if (nomefile[0] == 'H')
 336	{
 337		if (nomefile[1] == 'i')
 338		{
 339			if (nomefile[2] == 'p')
 340			{
 341				massa_particella_MeV = (float)MP_MEV;
 342				file_particelle_HI = true;
 343			}
 344			else if (nomefile[2] == 'd')
 345			{
 346				file_densita_HI = true;
 347				sprintf(support_label, "hidn");
 348			}
 349			else if (nomefile[2] == 'e')
 350			{
 351				file_densita_energia_griglia_HI = true;
 352				sprintf(support_label, "hien");
 353			}
 354			else
 355			{
 356				std::cout << "File non riconosciuto" << std::endl;
 357				exit(-15);
 358			}
 359		}
 360		else
 361		{
 362			std::cout << "File non riconosciuto" << std::endl;
 363			exit(-15);
 364		}
 365	}
 366	else if (nomefile[0] == 'L')
 367	{
 368		if (nomefile[1] == 'i')
 369		{
 370			if (nomefile[2] == 'p')
 371			{
 372				massa_particella_MeV = (float)MP_MEV;
 373				file_particelle_LI = true;
 374			}
 375			else if (nomefile[2] == 'd')
 376			{
 377				file_densita_LI = true;
 378				sprintf(support_label, "lidn");
 379			}
 380			else if (nomefile[2] == 'e')
 381			{
 382				file_densita_energia_griglia_LI = true;
 383				sprintf(support_label, "lien");
 384			}
 385			else
 386			{
 387				std::cout << "File non riconosciuto" << std::endl;
 388				exit(-15);
 389			}
 390		}
 391		else
 392		{
 393			std::cout << "File non riconosciuto" << std::endl;
 394			exit(-15);
 395		}
 396	}
 397	else if (nomefile[0] == 'E')
 398	{
 399		if (nomefile[1] == 'l')
 400		{
 401			if (nomefile[2] == 'p')
 402			{
 403				massa_particella_MeV = (float)ME_MEV;
 404				file_particelle_E = true;
 405			}
 406			else if (nomefile[2] == 'e')
 407			{
 408				file_densita_energia_griglia_elettroni = true;
 409				sprintf(support_label, "elen");
 410			}
 411			else
 412			{
 413				std::cout << "File non riconosciuto" << std::endl;
 414				exit(-15);
 415			}
 416		}
 417		else if (nomefile[1] == 'x')
 418		{
 419			if (nomefile[2] == 'f')
 420			{
 421				file_campi_Ex = true;
 422				sprintf(support_label, "Ex");
 423			}
 424			else
 425			{
 426				std::cout << "File non riconosciuto" << std::endl;
 427				exit(-15);
 428			}
 429		}
 430		else if (nomefile[1] == 'y')
 431		{
 432			if (nomefile[2] == 'f')
 433			{
 434				file_campi_Ey = true;
 435				sprintf(support_label, "Ey");
 436			}
 437			else
 438			{
 439				std::cout << "File non riconosciuto" << std::endl;
 440				exit(-15);
 441			}
 442		}
 443		else if (nomefile[1] == 'z')
 444		{
 445			if (nomefile[2] == 'f')
 446			{
 447				file_campi_Ez = true;
 448				sprintf(support_label, "Ez");
 449			}
 450			else
 451			{
 452				std::cout << "File non riconosciuto" << std::endl;
 453				exit(-15);
 454			}
 455		}
 456		else if (nomefile[1] == 'd')
 457		{
 458			file_densita_elettroni = true;
 459			sprintf(support_label, "eden");
 460		}
 461		else
 462		{
 463			std::cout << "File non riconosciuto" << std::endl;
 464			exit(-15);
 465		}
 466	}
 467	else if (nomefile[0] == 'B')
 468	{
 469		if (nomefile[1] == 'x')
 470		{
 471			if (nomefile[2] == 'f')
 472			{
 473				file_campi_Bx = true;
 474				sprintf(support_label, "Bx");
 475			}
 476			else
 477			{
 478				std::cout << "File non riconosciuto" << std::endl;
 479				exit(-15);
 480			}
 481		}
 482		else if (nomefile[1] == 'y')
 483		{
 484			if (nomefile[2] == 'f')
 485			{
 486				file_campi_By = true;
 487				sprintf(support_label, "By");
 488			}
 489			else
 490			{
 491				std::cout << "File non riconosciuto" << std::endl;
 492				exit(-15);
 493			}
 494		}
 495		else if (nomefile[1] == 'z')
 496		{
 497			if (nomefile[2] == 'f')
 498			{
 499				file_campi_Bz = true;
 500				sprintf(support_label, "Bz");
 501			}
 502			else
 503			{
 504				std::cout << "File non riconosciuto" << std::endl;
 505				exit(-15);
 506			}
 507		}
 508		else if (nomefile[1] == 'd')
 509		{
 510			file_densita_driver = true;
 511			sprintf(support_label, "Bd");
 512		}
 513		else
 514		{
 515			std::cout << "File non riconosciuto" << std::endl;
 516			exit(-15);
 517		}
 518	}
 519	else
 520	{
 521		std::cout << "File non riconosciuto" << std::endl;
 522		exit(-15);
 523	}
 524
 525}
 526
 527void Parametri::parse_command_line(int argc, const char ** argv)
 528{
 529	std::ifstream fileParametri;
 530	std::string nomefile;
 531	bool usa_file_parametri = false;
 532	bool failed_opening_file;
 533	for (int i = 2; i < argc; i++)
 534		/************************************************************************
 535		We will iterate over argv[] to get the parameters stored inside.
 536		Note that we're starting on 1 because we don't need to know the
 537		path of the program, which is stored in argv[0], and the input file,
 538		which is supposed to be given as the first argument and so is in argv[1]
 539		************************************************************************/
 540	{
 541		//	  std::cout << argv[i] << std::endl;
 542
 543		if (std::string(argv[i]) == "-readParamsfromFile" || std::string(argv[i]) == "-readParamsFromFile" || std::string(argv[i]) == "-readParams" || std::string(argv[i]) == "-readparamsfromfile")
 544		{
 545			if (i < argc - 1 && argv[i + 1][0] != '-')
 546			{
 547				nomefile = std::string(argv[i + 1]);
 548				usa_file_parametri = true;
 549				i++;
 550				std::cout << "Using " << nomefile << " as the binning parameters file" << std::endl;
 551			}
 552			else
 553			{
 554				nomefile = std::string(argv[1]) + ".extremes";
 555				usa_file_parametri = true;
 556				std::cout << "Using " << nomefile << " as the binning parameters file" << std::endl;
 557			}
 558		}
 559		else if (std::string(argv[i]) == "-params")
 560		{
 561			std::cout << "Forcing the output of the parameters from .dat/.bin files" << std::endl;
 562			p[OUT_PARAMS] = 1;
 563			p_b[OUT_PARAMS] = false;
 564		}
 565		else if (std::string(argv[i]) == "-swap")
 566		{
 567			std::cout << "Forcing a bit endianness swapping" << std::endl;
 568			p[SWAP] = 1;
 569			p_b[SWAP] = false;
 570		}
 571		else if (std::string(argv[i]) == "-noswap")
 572		{
 573			std::cout << "Forcing a bit endianness NON swapping" << std::endl;
 574			p[SWAP] = 0;
 575			p_b[SWAP] = false;
 576		}
 577		else if (std::string(argv[i]) == "-force_new")
 578		{
 579			std::cout << "Forced using new files routine even without .dat file" << std::endl;
 580			old_fortran_bin = false;
 581		}
 582		else if (std::string(argv[i]) == "-stop")
 583		{
 584			last_cpu = atoi(argv[i + 1]);
 585			if (last_cpu < 1) last_cpu = 1;
 586			std::cout << "Forced stopping reading at CPU #" << last_cpu << std::endl;
 587			i++;
 588		}
 589		else if (std::string(argv[i]) == "-span")
 590		{
 591			span = atoi(argv[i + 1]);
 592			if (span < 0) span = 0;
 593			std::cout << "Span factor for lineout: " << span << std::endl;
 594			i++;
 595		}
 596		else if (std::string(argv[i]) == "-subsample")
 597		{
 598			subsample = atoi(argv[i + 1]);
 599			if (file_particelle_P || file_particelle_E || file_particelle_HI || file_particelle_LI)
 600			{
 601				if (subsample < 1)
 602				{
 603					subsample = 1;
 604					std::cout << "Value for subsampling not valid, disabled" << std::endl;
 605				}
 606				else
 607				{
 608					std::cout << "Will subsample with a ratio of 1:" << subsample << " if any ASCII dump will be requested" << std::endl;
 609				}
 610			}
 611			else
 612			{
 613				std::cout << "Subsample factor is valid only for phase space files and will be used only for ASCII output" << std::endl;
 614			}
 615			i++;
 616		}
 617		else if (std::string(argv[i]) == "-ncol")
 618		{
 619			int ncolumns = atoi(argv[i + 1]);
 620			p[NCOLONNE] = ncolumns;
 621			if (ncolumns == 6) p[WEIGHT] = 0;
 622			else if (ncolumns == 7) p[WEIGHT] = 1;
 623			std::cout << "Forced number of columns in binary file to " << ncolumns << std::endl;
 624			p_b[NCOLONNE] = false;
 625			p_b[WEIGHT] = false;
 626			i++;
 627		}
 628		else if (std::string(argv[i]) == "-dump_vtk")
 629		{
 630			std::cout << "You asked to have a VTK dump of the input file" << std::endl;
 631			p[OUT_VTK] = 1;
 632			p_b[OUT_VTK] = false;
 633		}
 634		else if (std::string(argv[i]) == "-dump_vtk_nostretch")
 635		{
 636			std::cout << "You asked to have a VTK dump of the non-stretched grid.\n";
 637			std::cout << "If not explicitly said, the grid will be considered stretched in ALL directions" << std::endl;
 638			p[OUT_VTK_NOSTRETCH] = 1;
 639			p_b[OUT_VTK_NOSTRETCH] = false;
 640		}
 641		else if (std::string(argv[i]) == "-no_stretch_x")
 642		{
 643			std::cout << "Assuming the grid is NOT stretched along x axis.\n";
 644			stretched_along_x = 0;
 645		}
 646		else if (std::string(argv[i]) == "-dump_cutx")
 647		{
 648			if (p[NCOLONNE] > 1)
 649			{
 650				if (argv[i + 1][0] != '-')
 651				{
 652					float posizione_taglio = (float)atof(argv[i + 1]);
 653					posizioni_taglio_griglia_x.push_back(posizione_taglio);
 654					std::cout << "You asked to cut the grid at x = " << posizione_taglio << std::endl;
 655					i++;
 656				}
 657				else
 658				{
 659					std::cout << "You asked to cut the grid at the middle of the x-axis" << std::endl;
 660				}
 661				p[OUT_CUTX] = 1;
 662				p_b[OUT_CUTX] = false;
 663			}
 664			else
 665			{
 666				std::cout << "Unable to apply a cut on the grid in 2D, please use -dump_gnuplot" << std::endl;
 667				if (argv[i + 1][0] != '-') i++;
 668				p[OUT_CUTX] = 0;
 669				p_b[OUT_CUTX] = false;
 670			}
 671		}
 672
 673		else if (std::string(argv[i]) == "-dump_cuty")
 674		{
 675			if (p[NCOLONNE] > 1)
 676			{
 677				if (argv[i + 1][0] != '-')
 678				{
 679					float posizione_taglio = (float)atof(argv[i + 1]);
 680					posizioni_taglio_griglia_y.push_back(posizione_taglio);
 681					std::cout << "You asked to cut the grid at y = " << posizione_taglio << std::endl;
 682					i++;
 683				}
 684				else
 685				{
 686					std::cout << "You asked to cut the grid at the middle of the y-axis" << std::endl;
 687				}
 688				p[OUT_CUTY] = 1;
 689				p_b[OUT_CUTY] = false;
 690			}
 691			else
 692			{
 693				std::cout << "Unable to apply a cut on the grid in 2D, please use -dump_gnuplot" << std::endl;
 694				if (argv[i + 1][0] != '-') i++;
 695				p[OUT_CUTY] = 0;
 696				p_b[OUT_CUTY] = false;
 697			}
 698		}
 699
 700		else if (std::string(argv[i]) == "-dump_cutz")
 701		{
 702			if (p[NCOLONNE] > 1)
 703			{
 704				if (argv[i + 1][0] != '-')
 705				{
 706					float posizione_taglio = (float)atof(argv[i + 1]);
 707					posizioni_taglio_griglia_z.push_back(posizione_taglio);
 708					std::cout << "You asked to cut the grid at z = " << posizione_taglio << std::endl;
 709					i++;
 710				}
 711				else
 712				{
 713					std::cout << "You asked to cut the grid at the middle of the z-axis" << std::endl;
 714				}
 715				p[OUT_CUTZ] = 1;
 716				p_b[OUT_CUTZ] = false;
 717			}
 718			else
 719			{
 720				std::cout << "Unable to apply a cut on the grid in 2D, please use -dump_gnuplot" << std::endl;
 721				if (argv[i + 1][0] != '-') i++;
 722				p[OUT_CUTZ] = 0;
 723				p_b[OUT_CUTZ] = false;
 724			}
 725		}
 726
 727		else if (std::string(argv[i]) == "-dump_lineoutx")
 728		{
 729			std::cout << "You asked to have a lineout of the grid along the x-axis" << std::endl;
 730			p[OUT_LINEOUT_X] = 1;
 731			p_b[OUT_LINEOUT_X] = false;
 732		}
 733
 734		else if (std::string(argv[i]) == "-dump_gnuplot")
 735		{
 736			if (p[NCOLONNE] == 1)
 737			{
 738				std::cout << "You asked to rewrite the 2D grid in ASCII format for gnuplot" << std::endl;
 739				p[OUT_GRID2D] = 1;
 740				p_b[OUT_GRID2D] = false;
 741			}
 742			else
 743			{
 744				std::cout << "Unable to write a 3D grid for gnuplot without slicing it, please use dump_cutx/y/z" << std::endl;
 745				p[OUT_GRID2D] = 0;
 746				p_b[OUT_GRID2D] = false;
 747			}
 748		}
 749		else if (std::string(argv[i]) == "-dump_propaga")
 750		{
 751			std::cout << "You asked to have a .ppg dump of the input phase space" << std::endl;
 752			p[OUT_PROPAGA] = 1;
 753			p_b[OUT_PROPAGA] = false;
 754		}
 755		else if (std::string(argv[i]) == "-dump_csv")
 756		{
 757			std::cout << "You asked to have a .csv dump of the input phase space" << std::endl;
 758			p[OUT_CSV] = 1;
 759			p_b[OUT_CSV] = false;
 760		}
 761		else if (std::string(argv[i]) == "-dump_xyzE")
 762		{
 763			std::cout << "You asked to have a xy(z)E dump of the input phase space" << std::endl;
 764			p[OUT_XYZE] = 1;
 765			p_b[OUT_XYZE] = false;
 766		}
 767		else if (std::string(argv[i]) == "-dump_clean")
 768		{
 769			std::cout << "You asked to have a unique, clean binary file as the output" << std::endl;
 770			p[OUT_CLEAN_BINARY] = 1;
 771			p_b[OUT_CLEAN_BINARY] = false;
 772		}
 773		else if (std::string(argv[i]) == "-parameters")
 774		{
 775			std::cout << "You asked to write the simulation parameters file" << std::endl;
 776			p[OUT_PARAMS] = 1;
 777			p_b[OUT_PARAMS] = false;
 778		}
 779		else if (std::string(argv[i]) == "-find_minmax")
 780		{
 781			std::cout << "You asked to search for minima and maxima" << std::endl;
 782			p[FIND_MINMAX] = 1;
 783			p_b[FIND_MINMAX] = false;
 784		}
 785		else if (std::string(argv[i]) == "-do_binning")
 786		{
 787			std::cout << "You asked to enable plotting functions" << std::endl;
 788			p[DO_BINNING] = 1;
 789			p_b[DO_BINNING] = false;
 790		}
 791		else if (std::string(argv[i]) == "-xmin")
 792		{
 793			xmin = (float)atof(argv[i + 1]);
 794			xmin_b = false;
 795			i++;
 796		}
 797		else if (std::string(argv[i]) == "-xmax")
 798		{
 799			xmax = (float)atof(argv[i + 1]);
 800			xmax_b = false;
 801			i++;
 802		}
 803		else if (std::string(argv[i]) == "-weight")
 804		{
 805			overwrite_weight = true;
 806			overwrite_weight_value = (float)atof(argv[i + 1]);
 807			i++;
 808		}
 809		else if (std::string(argv[i]) == "-wmin")
 810		{
 811			wmin = (float)atof(argv[i + 1]);
 812			wmin_b = false;
 813			i++;
 814		}
 815		else if (std::string(argv[i]) == "-wmax")
 816		{
 817			wmax = (float)atof(argv[i + 1]);
 818			wmax_b = false;
 819			i++;
 820		}
 821		else if (std::string(argv[i]) == "-ymin")
 822		{
 823			ymin = (float)atof(argv[i + 1]);
 824			ymin_b = false;
 825			i++;
 826		}
 827		else if (std::string(argv[i]) == "-ymax")
 828		{
 829			ymax = (float)atof(argv[i + 1]);
 830			ymax_b = false;
 831			i++;
 832		}
 833		else if (std::string(argv[i]) == "-zmin")
 834		{
 835			if (p[NCOLONNE] > 5)
 836			{
 837				zmin = (float)atof(argv[i + 1]);
 838				zmin_b = false;
 839				i++;
 840			}
 841			else
 842			{
 843				std::cout << "Unable to apply a cut in z-dimension on a 2D file" << std::endl;
 844			}
 845		}
 846		else if (std::string(argv[i]) == "-zmax")
 847		{
 848			if (p[NCOLONNE] > 5)
 849			{
 850				zmax = (float)atof(argv[i + 1]);
 851				zmax_b = false;
 852				i++;
 853			}
 854			else
 855			{
 856				std::cout << "Unable to apply a cut in z-dimension on a 2D file" << std::endl;
 857			}
 858		}
 859		else if (std::string(argv[i]) == "-tymin")
 860		{
 861			tymin = (float)atof(argv[i + 1]);
 862			tymin_b = false;
 863			i++;
 864		}
 865		else if (std::string(argv[i]) == "-tymax")
 866		{
 867			tymax = (float)atof(argv[i + 1]);
 868			tymax_b = false;
 869			i++;
 870		}
 871		else if (std::string(argv[i]) == "-tzmin")
 872		{
 873			if (p[NCOLONNE] > 5)
 874			{
 875				tzmin = (float)atof(argv[i + 1]);
 876				tzmin_b = false;
 877				i++;
 878			}
 879			else
 880			{
 881				std::cout << "Unable to apply a cut in z-dimension on a 2D file" << std::endl;
 882			}
 883		}
 884		else if (std::string(argv[i]) == "-tzmax")
 885		{
 886			if (p[NCOLONNE] > 5)
 887			{
 888				tzmax = (float)atof(argv[i + 1]);
 889				tzmax_b = false;
 890				i++;
 891			}
 892			else
 893			{
 894				std::cout << "Unable to apply a cut in z-dimension on a 2D file" << std::endl;
 895			}
 896		}
 897		else if (std::string(argv[i]) == "-pxmin")
 898		{
 899			pxmin = (float)atof(argv[i + 1]);
 900			pxmin_b = false;
 901			i++;
 902		}
 903		else if (std::string(argv[i]) == "-pxmax")
 904		{
 905			pxmax = (float)atof(argv[i + 1]);
 906			pxmax_b = false;
 907			i++;
 908		}
 909		else if (std::string(argv[i]) == "-pymin")
 910		{
 911			pymin = (float)atof(argv[i + 1]);
 912			pymin_b = false;
 913			i++;
 914		}
 915		else if (std::string(argv[i]) == "-pymax")
 916		{
 917			pymax = (float)atof(argv[i + 1]);
 918			pymax_b = false;
 919			i++;
 920		}
 921		else if (std::string(argv[i]) == "-pzmin")
 922		{
 923			if (p[NCOLONNE] > 5)
 924			{
 925				pzmin = (float)atof(argv[i + 1]);
 926				pzmin_b = false;
 927				i++;
 928			}
 929			else
 930			{
 931				std::cout << "Unable to apply a cut in z-dimension on a 2D file" << std::endl;
 932			}
 933		}
 934		else if (std::string(argv[i]) == "-pzmax")
 935		{
 936			if (p[NCOLONNE] > 5)
 937			{
 938				pzmax = (float)atof(argv[i + 1]);
 939				pzmax_b = false;
 940				i++;
 941			}
 942			else
 943			{
 944				std::cout << "Unable to apply a cut in z-dimension on a 2D file" << std::endl;
 945			}
 946		}
 947		else if (std::string(argv[i]) == "-thetamin")
 948		{
 949			thetamin = (float)atof(argv[i + 1]);
 950			thetamin_b = false;
 951			i++;
 952		}
 953		else if (std::string(argv[i]) == "-thetamax")
 954		{
 955			thetamax = (float)atof(argv[i + 1]);
 956			thetamax_b = false;
 957			i++;
 958		}
 959		else if (std::string(argv[i]) == "-thetaTmin")
 960		{
 961			thetaTmin = (float)atof(argv[i + 1]);
 962			thetaTmin_b = false;
 963			i++;
 964		}
 965		else if (std::string(argv[i]) == "-thetaTmax")
 966		{
 967			thetaTmax = (float)atof(argv[i + 1]);
 968			thetaTmax_b = false;
 969			i++;
 970		}
 971		else if (std::string(argv[i]) == "-gammamin")
 972		{
 973			gammamin = (float)atof(argv[i + 1]);
 974			gammamin_b = false;
 975			i++;
 976		}
 977		else if (std::string(argv[i]) == "-gammamax")
 978		{
 979			gammamax = (float)atof(argv[i + 1]);
 980			gammamax_b = false;
 981			i++;
 982		}
 983		else if (std::string(argv[i]) == "-Emin")
 984		{
 985			Emin = (float)atof(argv[i + 1]);
 986			Emin_b = false;
 987			i++;
 988		}
 989		else if (std::string(argv[i]) == "-Emax")
 990		{
 991			Emax = (float)atof(argv[i + 1]);
 992			Emax_b = false;
 993			i++;
 994		}
 995		else if (std::string(argv[i]) == "-plot_xy")
 996		{
 997			fai_plot_xy = 1;
 998		}
 999		else if (std::string(argv[i]) == "-plot_xw")
1000		{
1001			if (p[WEIGHT])
1002			{
1003				fai_plot_xw = 1;
1004			}
1005			else
1006			{
1007				std::cout << "Unable to do a plot with weight using a file without weight!" << std::endl;
1008			}
1009		}
1010		else if (std::string(argv[i]) == "-plot_xz")
1011		{
1012			if (p[NCOLONNE] > 5)
1013			{
1014				fai_plot_xz = 1;
1015			}
1016			else
1017			{
1018				std::cout << "Unable to do a plot with z using a 2D file" << std::endl;
1019			}
1020		}
1021		else if (std::string(argv[i]) == "-plot_yz")
1022		{
1023			if (p[NCOLONNE] > 5)
1024			{
1025				fai_plot_yz = 1;
1026			}
1027			else
1028			{
1029				std::cout << "Unable to do a plot with z using a 2D file" << std::endl;
1030			}
1031		}
1032		else if (std::string(argv[i]) == "-plot_rcf")
1033		{
1034			if (p[NCOLONNE] > 5)
1035			{
1036				fai_plot_rcf = 1;
1037			}
1038			else
1039			{
1040				std::cout << "Unable to do a plot with tz using a 2D file" << std::endl;
1041			}
1042		}
1043		else if (std::string(argv[i]) == "-plot_xpx")
1044		{
1045			fai_plot_xpx = 1;
1046		}
1047		else if (std::string(argv[i]) == "-plot_xpy")
1048		{
1049			fai_plot_xpy = 1;
1050		}
1051		else if (std::string(argv[i]) == "-plot_xpz")
1052		{
1053			if (p[NCOLONNE] > 5)
1054			{
1055				fai_plot_xpz = 1;
1056			}
1057			else
1058			{
1059				std::cout << "Unable to do a plot with z using a 2D file" << std::endl;
1060			}
1061		}
1062		else if (std::string(argv[i]) == "-plot_ypx")
1063		{
1064			fai_plot_ypx = 1;
1065		}
1066		else if (std::string(argv[i]) == "-plot_ypy")
1067		{
1068			fai_plot_ypy = 1;
1069		}
1070		else if (std::string(argv[i]) == "-plot_ypz")
1071		{
1072			if (p[NCOLONNE] > 5)
1073			{
1074				fai_plot_ypz = 1;
1075			}
1076			else
1077			{
1078				std::cout << "Unable to do a plot with z using a 2D file" << std::endl;
1079			}
1080		}
1081		else if (std::string(argv[i]) == "-plot_zpx")
1082		{
1083			if (p[NCOLONNE] > 5)
1084			{
1085				fai_plot_zpx = 1;
1086			}
1087			else
1088			{
1089				std::cout << "Unable to do a plot with z using a 2D file" << std::endl;
1090			}
1091		}
1092		else if (std::string(argv[i]) == "-plot_zpy")
1093		{
1094			if (p[NCOLONNE] > 5)
1095			{
1096				fai_plot_zpy = 1;
1097			}
1098			else
1099			{
1100				std::cout << "Unable to do a plot with z using a 2D file" << std::endl;
1101			}
1102		}
1103		else if (std::string(argv[i]) == "-plot_zpz")
1104		{
1105			if (p[NCOLONNE] > 5)
1106			{
1107				fai_plot_zpz = 1;
1108			}
1109			else
1110			{
1111				std::cout << "Unable to do a plot with z using a 2D file" << std::endl;
1112			}
1113		}
1114		else if (std::string(argv[i]) == "-plot_pxpy")
1115		{
1116			fai_plot_pxpy = 1;
1117		}
1118		else if (std::string(argv[i]) == "-plot_pxpz")
1119		{
1120			if (p[NCOLONNE] > 5)
1121			{
1122				fai_plot_pxpz = 1;
1123			}
1124			else
1125			{
1126				std::cout << "Unable to do a plot with z using a 2D file" << std::endl;
1127			}
1128		}
1129		else if (std::string(argv[i]) == "-plot_pypz")
1130		{
1131			if (p[NCOLONNE] > 5)
1132			{
1133				fai_plot_pypz = 1;
1134			}
1135			else
1136			{
1137				std::cout << "Unable to do a plot with z using a 2D file" << std::endl;
1138			}
1139		}
1140		else if (std::string(argv[i]) == "-plot_etheta")
1141		{
1142			fai_plot_Etheta = 1;
1143		}
1144		else if (std::string(argv[i]) == "-plot_ethetaT")
1145		{
1146			fai_plot_EthetaT = 1;
1147		}
1148		else if (std::string(argv[i]) == "-plot_espec")
1149		{
1150			fai_plot_Espec = 1;
1151		}
1152		else if (std::string(argv[i]) == "-plot_wspec")
1153		{
1154			if (p[WEIGHT])
1155			{
1156				fai_plot_wspec = 1;
1157			}
1158			else
1159			{
1160				std::cout << "Unable to do a plot with weight using a file without weight!" << std::endl;
1161			}
1162		}
1163		else if (std::string(argv[i]) == "-plot_thetaspec")
1164		{
1165			fai_plot_thetaspec = 1;
1166		}
1167		else if (std::string(argv[i]) == "-plot_thetaTspec")
1168		{
1169			fai_plot_thetaTspec = 1;
1170		}
1171		else if (std::string(argv[i]) == "-nbin")
1172		{
1173			nbin = atoi(argv[i + 1]);
1174			if (nbin_x_b) nbin_x = nbin;
1175			if (nbin_y_b) nbin_y = nbin;
1176			if (nbin_z_b) nbin_z = nbin;
1177			if (nbin_px_b) nbin_px = nbin;
1178			if (nbin_py_b) nbin_py = nbin;
1179			if (nbin_pz_b) nbin_pz = nbin;
1180			if (nbin_ty_b) nbin_ty = nbin;
1181			if (nbin_tz_b) nbin_tz = nbin;
1182			if (nbin_gamma_b) nbin_gamma = nbin;
1183			if (nbin_theta_b) nbin_theta = nbin;
1184			if (nbin_theta_b) nbin_thetaT = nbin;
1185			if (nbin_E_b) nbin_E = nbin;
1186			if (nbin_w_b) nbin_w = nbin;
1187			nbin_b = false;
1188			i++;
1189		}
1190		else if (std::string(argv[i]) == "-nbinx")
1191		{
1192			nbin_x = atoi(argv[i + 1]);
1193			nbin_x_b = false;
1194			nbin_b = false;
1195			i++;
1196		}
1197		else if (std::string(argv[i]) == "-nbiny")
1198		{
1199			nbin_y = atoi(argv[i + 1]);
1200			nbin_y_b = false;
1201			nbin_b = false;
1202			i++;
1203		}
1204		else if (std::string(argv[i]) == "-nbinz")
1205		{
1206			nbin_z = atoi(argv[i + 1]);
1207			nbin_z_b = false;
1208			nbin_b = false;
1209			i++;
1210		}
1211		else if (std::string(argv[i]) == "-nbinty")
1212		{
1213			nbin_ty = atoi(argv[i + 1]);
1214			nbin_ty_b = false;
1215			nbin_b = false;
1216			i++;
1217		}
1218		else if (std::string(argv[i]) == "-nbintz")
1219		{
1220			nbin_tz = atoi(argv[i + 1]);
1221			nbin_tz_b = false;
1222			nbin_b = false;
1223			i++;
1224		}
1225		else if (std::string(argv[i]) == "-nbinpx")
1226		{
1227			nbin_px = atoi(argv[i + 1]);
1228			nbin_px_b = false;
1229			nbin_b = false;
1230			i++;
1231		}
1232		else if (std::string(argv[i]) == "-nbinpy")
1233		{
1234			nbin_py = atoi(argv[i + 1]);
1235			nbin_py_b = false;
1236			nbin_b = false;
1237			i++;
1238		}
1239		else if (std::string(argv[i]) == "-nbinpz")
1240		{
1241			nbin_pz = atoi(argv[i + 1]);
1242			nbin_pz_b = false;
1243			nbin_b = false;
1244			i++;
1245		}
1246		else if (std::string(argv[i]) == "-nbintheta")
1247		{
1248			nbin_theta = atoi(argv[i + 1]);
1249			nbin_theta_b = false;
1250			nbin_b = false;
1251			i++;
1252		}
1253		else if (std::string(argv[i]) == "-nbinthetaT")
1254		{
1255			nbin_thetaT = atoi(argv[i + 1]);
1256			nbin_thetaT_b = false;
1257			nbin_b = false;
1258			i++;
1259		}
1260		else if (std::string(argv[i]) == "-nbingamma")
1261		{
1262			nbin_gamma = atoi(argv[i + 1]);
1263			nbin_gamma_b = false;
1264			nbin_b = false;
1265			i++;
1266		}
1267		else if (std::string(argv[i]) == "-nbinE")
1268		{
1269			nbin_E = atoi(argv[i + 1]);
1270			nbin_E_b = false;
1271			nbin_b = false;
1272			i++;
1273		}
1274		else if (std::string(argv[i]) == "-nbinw")
1275		{
1276			nbin_w = atoi(argv[i + 1]);
1277			nbin_w_b = false;
1278			nbin_b = false;
1279			i++;
1280		}
1281		else if (std::string(argv[i]) == "-dontask")
1282		{
1283			do_not_ask_missing = true;
1284		}
1285	}
1286
1287
1288	std::string nomepar, evita, leggi;
1289
1290	if (file_particelle_P || file_particelle_E || file_particelle_HI || file_particelle_LI)
1291	{
1292		if (usa_file_parametri)
1293		{
1294			fileParametri.open(nomefile.c_str());
1295			failed_opening_file = fileParametri.fail();
1296			if (failed_opening_file)
1297			{
1298				std::cout << "Impossibile aprire il file " << nomefile << " contenente i parametri di binnaggio" << std::endl;
1299				exit(50);
1300			}
1301			while (!fileParametri.eof())
1302			{
1303				fileParametri >> nomepar >> evita >> leggi;
1304				if ((nomepar == "xmin" || nomepar == "XMIN") && xmin_b)
1305				{
1306					xmin = (float)std::atof(leggi.c_str());
1307					xmin_b = false;
1308				}
1309				else if ((nomepar == "xmax" || nomepar == "XMAX") && xmax_b)
1310				{
1311					xmax = (float)std::atof(leggi.c_str());
1312					xmax_b = false;
1313				}
1314				else if ((nomepar == "ymin" || nomepar == "YMIN") && ymin_b)
1315				{
1316					ymin = (float)std::atof(leggi.c_str());
1317					ymin_b = false;
1318				}
1319				else if ((nomepar == "ymax" || nomepar == "YMAX") && ymax_b)
1320				{
1321					ymax = (float)std::atof(leggi.c_str());
1322					ymax_b = false;
1323				}
1324				else if ((nomepar == "zmin" || nomepar == "ZMIN") && zmin_b)
1325				{
1326					zmin = (float)std::atof(leggi.c_str());
1327					zmin_b = false;
1328				}
1329				else if ((nomepar == "zmax" || nomepar == "ZMAX") && zmax_b)
1330				{
1331					zmax = (float)std::atof(leggi.c_str());
1332					zmax_b = false;
1333				}
1334				else if ((nomepar == "tymin" || nomepar == "TYMIN") && tymin_b)
1335				{
1336					tymin = (float)std::atof(leggi.c_str());
1337					tymin_b = false;
1338				}
1339				else if ((nomepar == "tymax" || nomepar == "TYMAX") && tymax_b)
1340				{
1341					tymax = (float)std::atof(leggi.c_str());
1342					tymax_b = false;
1343				}
1344				else if ((nomepar == "tzmin" || nomepar == "TZMIN") && tzmin_b)
1345				{
1346					tzmin = (float)std::atof(leggi.c_str());
1347					tzmin_b = false;
1348				}
1349				else if ((nomepar == "tzmax" || nomepar == "TZMAX") && tzmax_b)
1350				{
1351					tzmax = (float)std::atof(leggi.c_str());
1352					tzmax_b = false;
1353				}
1354				else if ((nomepar == "pxmin" || nomepar == "PXMIN") && pxmin_b)
1355				{
1356					pxmin = (float)std::atof(leggi.c_str());
1357					pxmin_b = false;
1358				}
1359				else if ((nomepar == "pxmax" || nomepar == "PXMAX") && pxmax_b)
1360				{
1361					pxmax = (float)std::atof(leggi.c_str());
1362					pxmax_b = false;
1363				}
1364				else if ((nomepar == "pymin" || nomepar == "PYMIN") && pymin_b)
1365				{
1366					pymin = (float)std::atof(leggi.c_str());
1367					pymin_b = false;
1368				}
1369				else if ((nomepar == "pymax" || nomepar == "PYMAX") && pymax_b)
1370				{
1371					pymax = (float)std::atof(leggi.c_str());
1372					pymax_b = false;
1373				}
1374				else if ((nomepar == "pzmin" || nomepar == "PZMIN") && pzmin_b)
1375				{
1376					pzmin = (float)std::atof(leggi.c_str());
1377					pzmin_b = false;
1378				}
1379				else if ((nomepar == "pzmax" || nomepar == "PZMAX") && pzmax_b)
1380				{
1381					pzmax = (float)std::atof(leggi.c_str());
1382					pzmax_b = false;
1383				}
1384				else if ((nomepar == "gammamin" || nomepar == "GAMMAMIN") && gammamin_b)
1385				{
1386					gammamin = (float)std::atof(leggi.c_str());
1387					gammamin_b = false;
1388				}
1389				else if ((nomepar == "gammamax" || nomepar == "GAMMAMAX") && gammamax_b)
1390				{
1391					gammamax = (float)std::atof(leggi.c_str());
1392					gammamax_b = false;
1393				}
1394				else if ((nomepar == "thetamin" || nomepar == "THETAMIN") && thetamin_b)
1395				{
1396					thetamin = (float)std::atof(leggi.c_str());
1397					thetamin_b = false;
1398				}
1399				else if ((nomepar == "thetamax" || nomepar == "THETAMAX") && thetamax_b)
1400				{
1401					thetamax = (float)std::atof(leggi.c_str());
1402					thetamax_b = false;
1403				}
1404				else if ((nomepar == "thetaradmin" || nomepar == "THETARADMIN") && thetaTmin_b)
1405				{
1406					thetaTmin = (float)std::atof(leggi.c_str());
1407					thetaTmin_b = false;
1408				}
1409				else if ((nomepar == "thetaradmax" || nomepar == "THETARADMAX") && thetaTmax_b)
1410				{
1411					thetaTmax = (float)std::atof(leggi.c_str());
1412					thetaTmax_b = false;
1413				}
1414				else if ((nomepar == "emin" || nomepar == "EMIN") && Emin_b)
1415				{
1416					Emin = (float)std::atof(leggi.c_str());
1417					Emin_b = false;
1418				}
1419				else if ((nomepar == "emax" || nomepar == "EMAX") && Emax_b)
1420				{
1421					Emax = (float)std::atof(leggi.c_str());
1422					Emax_b = false;
1423				}
1424				else if ((nomepar == "wmin" || nomepar == "WMIN") && wmin_b)
1425				{
1426					wmin = (float)std::atof(leggi.c_str());
1427					wmin_b = false;
1428				}
1429				else if ((nomepar == "wmax" || nomepar == "WMAX") && wmax_b)
1430				{
1431					wmax = (float)std::atof(leggi.c_str());
1432					wmax_b = false;
1433				}
1434				/*
1435				else
1436				{
1437				std::cout << "Parametro " << nomepar << " non riconosciuto." << std::endl;
1438				}
1439				*/
1440			}
1441			fileParametri.close();
1442		}
1443		if (p_b[FIND_MINMAX] && !do_not_ask_missing)
1444		{
1445			std::cout << "Vuoi cercare massimi e minimi? 0 per no, 1 per si': ";
1446			std::cin >> p[FIND_MINMAX];
1447			p_b[FIND_MINMAX] = false;
1448		}
1449		if (p_b[DO_BINNING] && !do_not_ask_missing)
1450		{
1451			std::cout << "Vuoi fare il binnaggio dei dati? 1 si', 0 no: ";
1452			std::cin >> p[DO_BINNING];
1453			p_b[DO_BINNING] = false;
1454		}
1455		if (p[DO_BINNING] == 1 && nbin_b && !do_not_ask_missing)
1456		{
1457			std::cout << "Quanti bin per asse vuoi usare? (consiglio: 120): ";
1458			std::cin >> nbin;
1459			nbin_x = nbin_y = nbin_z = nbin_px = nbin_py = nbin_pz = nbin_E = nbin_theta = nbin_thetaT = nbin_ty = nbin_tz = nbin;
1460		}
1461
1462		if (p[DO_BINNING] == 1 && !do_not_ask_missing)
1463		{
1464			std::cout << "Vuoi fare il plot x-px? 0 per no, 1 per si': ";
1465			std::cin >> fai_plot_xpx;
1466			std::cout << "Vuoi fare il plot E-theta (deg)? 0 per no, 1 per si': ";
1467			std::cin >> fai_plot_Etheta;
1468			std::cout << "Vuoi fare il plot E-theta (rad)? 0 per no, 1 per si': ";
1469			std::cin >> fai_plot_EthetaT;
1470			std::cout << "Vuoi fare lo spettro in energia? 0 per no, 1 per si': ";
1471			std::cin >> fai_plot_Espec;
1472			std::cout << "Vuoi fare il plot rfc? 0 per no, 1 per si': ";
1473			std::cin >> fai_plot_rcf;
1474			if (fai_plot_xpx)
1475			{
1476				if (xmin_b)
1477				{
1478					std::cout << "xmin = ";
1479					std::cin >> xmin;
1480					xmin_b = false;
1481				}
1482				if (xmax_b)
1483				{
1484					std::cout << "xmax = ";
1485					std::cin >> xmax;
1486					xmax_b = false;
1487				}
1488				if (nbin_x_b)
1489				{
1490					std::cout << "nbin_x = ";
1491					std::cin >> nbin_x;
1492					nbin_x_b = false;
1493				}
1494				if (pxmin_b)
1495				{
1496					std::cout << "pxmin = ";
1497					std::cin >> pxmin;
1498					pxmin_b = false;
1499				}
1500				if (pxmax_b)
1501				{
1502					std::cout << "pxmax = ";
1503					std::cin >> pxmax;
1504					pxmax_b = false;
1505				}
1506				if (nbin_px_b)
1507				{
1508					std::cout << "nbin_px = ";
1509					std::cin >> nbin_px;
1510					nbin_px_b = false;
1511				}
1512			}
1513			if (fai_plot_Etheta || fai_plot_Espec || fai_plot_EthetaT)
1514			{
1515				if (Emin_b)
1516				{
1517					std::cout << "Emin = ";
1518					std::cin >> Emin;
1519					Emin_b = false;
1520				}
1521				if (Emax_b)
1522				{
1523					std::cout << "Emax = ";
1524					std::cin >> Emax;
1525					Emax_b = false;
1526				}
1527				if (nbin_E_b)
1528				{
1529					std::cout << "nbin_E = ";
1530					std::cin >> nbin_E;
1531					nbin_E_b = false;
1532				}
1533			}
1534			if (fai_plot_Etheta)
1535			{
1536				if (thetamin_b)
1537				{
1538					std::cout << "thetamin = ";
1539					std::cin >> thetamin;
1540					thetamin_b = false;
1541				}
1542				if (thetamax_b)
1543				{
1544					std::cout << "thetamax = ";
1545					std::cin >> thetamax;
1546					thetamax_b = false;
1547				}
1548				if (nbin_theta_b)
1549				{
1550					std::cout << "nbin_theta = ";
1551					std::cin >> nbin_theta;
1552					nbin_theta_b = false;
1553				}
1554			}
1555			if (fai_plot_EthetaT)
1556			{
1557				if (thetaTmin_b)
1558				{
1559					std::cout << "thetaRADmin = ";
1560					std::cin >> thetaTmin;
1561					thetaTmin_b = false;
1562				}
1563				if (thetaTmax_b)
1564				{
1565					std::cout << "thetaRADmax = ";
1566					std::cin >> thetaTmax;
1567					thetaTmax_b = false;
1568				}
1569				if (nbin_thetaT_b)
1570				{
1571					std::cout << "nbin_thetaRAD = ";
1572					std::cin >> nbin_thetaT;
1573					nbin_thetaT_b = false;
1574				}
1575			}
1576			if (fai_plot_rcf)
1577			{
1578				if (tymin_b)
1579				{
1580					std::cout << "tymin = ";
1581					std::cin >> tymin;
1582					tymin_b = false;
1583				}
1584				if (tymax_b)
1585				{
1586					std::cout << "tymax = ";
1587					std::cin >> tymax;
1588					tymax_b = false;
1589				}
1590				if (nbin_ty_b)
1591				{
1592					std::cout << "nbin_ty = ";
1593					std::cin >> nbin_ty;
1594					nbin_ty_b = false;
1595				}
1596				if (tzmin_b)
1597				{
1598					std::cout << "tzmin = ";
1599					std::cin >> tzmin;
1600					tzmin_b = false;
1601				}
1602				if (tzmax_b)
1603				{
1604					std::cout << "tzmax = ";
1605					std::cin >> tzmax;
1606					tzmax_b = false;
1607				}
1608				if (nbin_tz_b)
1609				{
1610					std::cout << "nbin_tz = ";
1611					std::cin >> nbin_tz;
1612					nbin_tz_b = false;
1613				}
1614			}
1615		}
1616
1617
1618
1619
1620#ifdef ENABLE_DEBUG
1621		std::cout << "Dal file " << nomefile << " ho letto i seguenti estremi:" << std::endl;
1622		std::cout << "XMIN = " << xmin << std::endl;
1623		std::cout << "XMAX = " << xmax << std::endl;
1624		std::cout << "YMIN = " << ymin << std::endl;
1625		std::cout << "YMAX = " << ymax << std::endl;
1626		std::cout << "ZMIN = " << zmin << std::endl;
1627		std::cout << "ZMAX = " << zmax << std::endl;
1628		std::cout << "PXMIN = " << pxmin << std::endl;
1629		std::cout << "PXMAX = " << pxmax << std::endl;
1630		std::cout << "PYMIN = " << pymin << std::endl;
1631		std::cout << "PYMAX = " << pymax << std::endl;
1632		std::cout << "PZMIN = " << pzmin << std::endl;
1633		std::cout << "PZMAX = " << pzmax << std::endl;
1634		std::cout << "GAMMAMIN = " << gammamin << std::endl;
1635		std::cout << "GAMMAMAX = " << gammamax << std::endl;
1636		std::cout << "THETAMIN = " << thetamin << std::endl;
1637		std::cout << "THETAMAX = " << thetamax << std::endl;
1638		std::cout << "THETARADMIN = " << thetaTmin << std::endl;
1639		std::cout << "THETARADMAX = " << thetaTmax << std::endl;
1640		std::cout << "EMIN = " << Emin << std::endl;
1641		std::cout << "EMAX = " << Emax << std::endl;
1642		std::cout << "TYMIN = " << tymin << std::endl;
1643		std::cout << "TYMAX = " << tymax << std::endl;
1644		std::cout << "TZMIN = " << tzmin << std::endl;
1645		std::cout << "TZMAX = " << tzmax << std::endl;
1646		std::cout << "WMIN = " << wmin << std::endl;
1647		std::cout << "WMAX = " << wmax << std::endl;
1648#endif
1649		if (p_b[OUT_VTK] && !do_not_ask_missing)
1650		{
1651			std::cout << "Vuoi l'output completo binario VTK? 1 si', 0 no: ";
1652			std::cin >> p[OUT_VTK];
1653			p_b[OUT_VTK] = false;
1654		}
1655		if (p_b[OUT_CLEAN_BINARY] && !do_not_ask_missing)
1656		{
1657			std::cout << "Vuoi l'output completo binario pulito? 1 si', 0 no: ";
1658			std::cin >> p[OUT_CLEAN_BINARY];
1659			p_b[OUT_CLEAN_BINARY] = false;
1660		}
1661		if (p_b[OUT_PROPAGA] && !do_not_ask_missing)
1662		{
1663			std::cout << "Vuoi l'output completo per Propaga? 1 si', 0 no: ";
1664			std::cin >> p[OUT_PROPAGA];
1665			p_b[OUT_PROPAGA] = false;
1666		}
1667		if (p_b[OUT_XYZE] && !do_not_ask_missing)
1668		{
1669			std::cout << "Vuoi l'output di un file ASCII contenente x y (z) ed energia? 1 si', 0 no: ";
1670			std::cin >> p[OUT_XYZE];
1671			p_b[OUT_XYZE] = false;
1672		}
1673		if (p_b[OUT_CSV] && !do_not_ask_missing)
1674		{
1675			std::cout << "Vuoi l'output completo CSV per Paraview? 1 si', 0 no: ";
1676			std::cin >> p[OUT_CSV];
1677			p_b[OUT_CSV] = false;
1678		}
1679		if (p_b[OUT_PARAMS] && !do_not_ask_missing)
1680		{
1681			std::cout << "Vuoi l'output dei parametri contenuti nel file? 1 si', 0 no: ";
1682			std::cin >> p[OUT_PARAMS];
1683			p_b[OUT_PARAMS] = false;
1684		}
1685	}
1686	else
1687	{
1688		if (p_b[OUT_VTK] && !do_not_ask_missing)
1689		{
1690			std::cout << "Vuoi l'output completo binario VTK? 1 si', 0 no: ";
1691			std::cin >> p[OUT_VTK];
1692			p_b[OUT_VTK] = false;
1693		}
1694		if (p_b[OUT_VTK_NOSTRETCH] && !do_not_ask_missing)
1695		{
1696			std::cout << "Vuoi l'output binario VTK della parte non stretchata? 1 si', 0 no: ";
1697			std::cin >> p[OUT_VTK_NOSTRETCH];
1698			p_b[OUT_VTK_NOSTRETCH] = false;
1699		}
1700		if (p[OUT_VTK_NOSTRETCH] && !do_not_ask_missing)
1701		{
1702			std::cout << "La griglia e' stretchata anche lungo l'asse x? 1 si', 0 no: ";
1703			std::cin >> stretched_along_x;
1704		}
1705		if (p[NCOLONNE] > 1)
1706		{
1707			if (p_b[OUT_CUTX] && !do_not_ask_missing)
1708			{
1709				std::cout << "Vuoi l'output di una slice tagliata lungo x per gnuplot? 1 si', 0 no: ";
1710				std::cin >> p[OUT_CUTX];
1711				p_b[OUT_CUTX] = false;
1712				float posizione_taglio = 0.0;
1713				if (p[OUT_CUTX] == 1)
1714				{
1715					std::cout << "Dimmi in che posizione (in micrometri) tagliare: ";
1716					std::cin >> posizione_taglio;
1717					posizioni_taglio_griglia_x.push_back(posizione_taglio);
1718				}
1719			}
1720			if (p_b[OUT_CUTY] && !do_not_ask_missing)
1721			{
1722				std::cout << "Vuoi l'output di una slice tagliata lungo y per gnuplot? 1 si', 0 no: ";
1723				std::cin >> p[OUT_CUTY];
1724				p_b[OUT_CUTY] = false;
1725				float posizione_taglio = 0.0;
1726				if (p[OUT_CUTY] == 1)
1727				{
1728					std::cout << "Dimmi in che posizione (in micrometri) tagliare: ";
1729					std::cin >> posizione_taglio;
1730					posizioni_taglio_griglia_y.push_back(posizione_taglio);
1731				}
1732			}
1733			if (p_b[OUT_CUTZ] && !do_not_ask_missing)
1734			{
1735				std::cout << "Vuoi l'output di una slice tagliata lungo z per gnuplot? 1 si', 0 no: ";
1736				std::cin >> p[OUT_CUTZ];
1737				p_b[OUT_CUTZ] = false;
1738				float posizione_taglio = 0.0;
1739				if (p[OUT_CUTZ] == 1)
1740				{
1741					std::cout << "Dimmi in che posizione (in micrometri) tagliare: ";
1742					std::cin >> posizione_taglio;
1743					posizioni_taglio_griglia_z.push_back(posizione_taglio);
1744				}
1745			}
1746			p[OUT_GRID2D] = 0;
1747			p_b[OUT_GRID2D] = false;
1748		}
1749		else
1750		{
1751			if (p_b[OUT_GRID2D] && !do_not_ask_missing)
1752			{
1753				std::cout << "Vuoi riscrivere la griglia in ASCII per gnuplot? 1 si', 0 no: ";
1754				std::cin >> p[OUT_GRID2D];
1755				p_b[OUT_GRID2D] = false;
1756			}
1757			p[OUT_CUTX] = 0;
1758			p_b[OUT_CUTX] = false;
1759			p[OUT_CUTY] = 0;
1760			p_b[OUT_CUTY] = false;
1761			p[OUT_CUTZ] = 0;
1762			p_b[OUT_CUTZ] = false;
1763		}
1764		if (p_b[OUT_PARAMS] && !do_not_ask_missing)
1765		{
1766			std::cout << "Vuoi l'output dei parametri contenuti nel file? 1 si', 0 no: ";
1767			std::cin >> p[OUT_PARAMS];
1768			p_b[OUT_PARAMS] = false;
1769		}
1770		if (p_b[OUT_LINEOUT_X] && !do_not_ask_missing)
1771		{
1772			std::cout << "Vuoi l'output di un lineout della griglia lungo x? 1 si', 0 no: ";
1773			std::cin >> p[OUT_LINEOUT_X];
1774			p_b[OUT_LINEOUT_X] = false;
1775		}
1776	}
1777	fileParametri.close();
1778}
1779
1780
1781
1782bool Parametri::check_parametri()
1783{
1784	bool test = true;
1785	if (!p_b[SWAP] && p[SWAP] != 0 && p[SWAP] != 1)		// check swap o non-swap
1786	{
1787		printf("Attenzione: modalita` swap mal definita\n");
1788		test = false;
1789	}
1790	else
1791	{
1792		if (!p_b[SWAP] && (p[SWAP] == 0 || p[SWAP] == 1))
1793		{
1794			test = true;		// tutto ok, in questo caso il parametro va bene!
1795		}
1796		else if (p_b[SWAP] && do_not_ask_missing)
1797		{
1798			p[SWAP] = 0;
1799			p_b[SWAP] = false;
1800			test = true;
1801		}
1802		else
1803		{
1804			printf("Attenzione: modalita` swap non definita\n");
1805			test = false;
1806		}
1807	}
1808	if (file_particelle_P || file_particelle_E || file_particelle_HI || file_particelle_LI)
1809	{
1810		if (!p_b[WEIGHT] && p[WEIGHT] != 0 && p[WEIGHT] != 1)
1811		{
1812			printf("Attenzione: modalita` weight mal definita\n");
1813			test = false;
1814		}
1815		else
1816		{
1817			if (!p_b[WEIGHT] && (p_b[WEIGHT] == 0 || p_b[WEIGHT] == 1))
1818			{
1819				test = true;		// tutto ok, in questo caso il parametro va bene!
1820			}
1821			else if (p_b[WEIGHT] && do_not_ask_missing)
1822			{
1823				p[WEIGHT] = 1;
1824				p_b[WEIGHT] = false;
1825				test = true;
1826			}
1827			else
1828			{
1829				printf("Attenzione: modalita` weight non definita\n");
1830				test = false;
1831			}
1832		}
1833		if (!p_b[OUT_CSV] && p[OUT_CSV] != 0 && p[OUT_CSV] != 1)	// check leggi_particelle: out-ascii o non-out-ascii
1834		{
1835			printf("Attenzione: output csv mal definito\n");
1836			test = false;
1837		}
1838		else
1839		{
1840			if (!p_b[OUT_CSV] && (p_b[OUT_CSV] == 0 || p_b[OUT_CSV] == 1))
1841			{
1842				test = true;		// tutto ok, in questo caso il parametro va bene!
1843			}
1844			else if (p_b[OUT_CSV] && do_not_ask_missing)
1845			{
1846				p[OUT_CSV] = 0;
1847				p_b[OUT_CSV] = false;
1848				test = true;
1849			}
1850			else
1851			{
1852				printf("Attenzione: output csv non definito\n");
1853				test = false;
1854			}
1855		}
1856		if (!p_b[OUT_PROPAGA] && p[OUT_PROPAGA] != 0 && p[OUT_PROPAGA] != 1)	// check leggi_particelle: out-ascii o non-out-ascii
1857		{
1858			printf("Attenzione: output ppg mal definito\n");
1859			test = false;
1860		}
1861		else
1862		{
1863			if (!p_b[OUT_PROPAGA] && (p_b[OUT_PROPAGA] == 0 || p_b[OUT_PROPAGA] == 1))
1864			{
1865				test = true;		// tutto ok, in questo caso il parametro va bene!
1866			}
1867			else if (p_b[OUT_PROPAGA] && do_not_ask_missing)
1868			{
1869				p[OUT_PROPAGA] = 0;
1870				p_b[OUT_PROPAGA] = false;
1871				test = true;
1872			}
1873			else
1874			{
1875				printf("Attenzione: output ppg non definito\n");
1876				test = false;
1877			}
1878		}
1879		if (!p_b[OUT_XYZE] && p[OUT_XYZE] != 0 && p[OUT_XYZE] != 1)
1880		{
1881			printf("Attenzione: output xyzE mal definito\n");
1882			test = false;
1883		}
1884		else
1885		{
1886			if (!p_b[OUT_XYZE] && (p_b[OUT_XYZE] == 0 || p_b[OUT_XYZE] == 1))
1887			{
1888				test = true;		// tutto ok, in questo caso il parametro va bene!
1889			}
1890			else if (p_b[OUT_XYZE] && do_not_ask_missing)
1891			{
1892				p[OUT_XYZE] = 0;
1893				p_b[OUT_XYZE] = false;
1894				test = true;
1895			}
1896			else
1897			{
1898				printf("Attenzione: output xyzE non definito\n");
1899				test = false;
1900			}
1901		}
1902		if (!p_b[OUT_VTK] && p[OUT_VTK] != 0 && p[OUT_VTK] != 1)
1903		{
1904			printf("Attenzione: output vtk mal definito\n");
1905			test = false;
1906		}
1907		else
1908		{
1909			if (!p_b[OUT_VTK] && (p[OUT_VTK] == 0 || p[OUT_VTK] == 1))
1910			{
1911				test = true;		// tutto ok, in questo caso il parametro va bene!
1912			}
1913			else if (p_b[OUT_VTK] && do_not_ask_missing)
1914			{
1915				p[OUT_VTK] = 0;
1916				p_b[OUT_VTK] = false;
1917				test = true;
1918			}
1919			else
1920			{
1921				printf("Attenzione: output vtk non definito\n");
1922				test = false;
1923			}
1924		}
1925		if (!p_b[OUT_CLEAN_BINARY] && p[OUT_CLEAN_BINARY] != 0 && p[OUT_CLEAN_BINARY] != 1)
1926		{
1927			printf("Attenzione: output binario pulito mal definito\n");
1928			test = false;
1929		}
1930		else
1931		{
1932			if (!p_b[OUT_CLEAN_BINARY] && (p[OUT_CLEAN_BINARY] == 0 || p[OUT_CLEAN_BINARY] == 1))
1933			{
1934				test = true;		// tutto ok, in questo caso il parametro va bene!
1935			}
1936			else if (p_b[OUT_CLEAN_BINARY] && do_not_ask_missing)
1937			{
1938				p[OUT_CLEAN_BINARY] = 0;
1939				p_b[OUT_CLEAN_BINARY] = false;
1940				test = true;
1941			}
1942			else
1943			{
1944				printf("Attenzione: output binario pulito non definito\n");
1945				test = false;
1946			}
1947		}
1948
1949		if (!p_b[FIND_MINMAX] && p[FIND_MINMAX] != 0 && p[FIND_MINMAX] != 1)
1950		{
1951			printf("Attenzione: ricerca minimi/massimi mal definita\n");
1952			test = false;
1953		}
1954		else
1955		{
1956			if (!p_b[FIND_MINMAX] && (p[FIND_MINMAX] == 0 || p[FIND_MINMAX] == 1))
1957			{
1958				test = true;		// tutto ok, in questo caso il parametro va bene!
1959			}
1960			else if (p_b[FIND_MINMAX] && do_not_ask_missing)
1961			{
1962				p[FIND_MINMAX] = 0;
1963				p_b[FIND_MINMAX] = false;
1964				test = true;
1965			}
1966			else
1967			{
1968				printf("Attenzione: ricerca minimi/massimi non definita\n");
1969				test = false;
1970			}
1971		}
1972		if (!p_b[DO_BINNING] && p[DO_BINNING] != 0 && p[DO_BINNING] != 1)
1973		{
1974			printf("Attenzione: parametro binnaggio mal definito\n");
1975			test = false;
1976		}
1977		else
1978		{
1979			if (!p_b[DO_BINNING] && (p[DO_BINNING] == 0 || p[DO_BINNING] == 1))
1980			{
1981				test = true;		// tutto ok, in questo caso il parametro va bene!
1982			}
1983			else if (p_b[DO_BINNING] && do_not_ask_missing)
1984			{
1985				p[DO_BINNING] = 0;
1986				p_b[DO_BINNING] = false;
1987				test = true;
1988			}
1989			else
1990			{
1991				printf("Attenzione: parametro binnaggio non definito\n");
1992				test = false;
1993			}
1994		}
1995		if (!p_b[OUT_PARAMS] && p[OUT_PARAMS] != 0 && p[OUT_PARAMS] != 1)
1996		{
1997			printf("Attenzione: output parametri mal definito\n");
1998			test = false;
1999		}
2000		else
2001		{
2002			if (!p_b[OUT_PARAMS] && (p[OUT_PARAMS] == 0 || p[OUT_PARAMS] == 1))
2003			{
2004				test = true;		// tutto ok, in questo caso il parametro va bene!
2005			}
2006			else if (p_b[OUT_PARAMS] && do_not_ask_missing)
2007			{
2008				p[OUT_PARAMS] = 0;
2009				p_b[OUT_PARAMS] = false;
2010				test = true;
2011			}
2012			else
2013			{
2014				printf("Attenzione: output parametri non definito\n");
2015				test = false;
2016			}
2017		}
2018		if (!p_b[NCOLONNE] && p[NCOLONNE] != 4 && p[NCOLONNE] != 5 && p[NCOLONNE] != 6 && p[NCOLONNE] != 7)
2019		{
2020			printf("Attenzione: ncolonne mal definite\n");
2021			test = false;
2022		}
2023		else
2024		{
2025			if (!p_b[NCOLONNE] && (p[NCOLONNE] == 4 || p[NCOLONNE] == 5 || p[NCOLONNE] == 6 || p[NCOLONNE] == 7))
2026			{
2027				test = true;		// tutto ok, in questo caso il parametro va bene!
2028			}
2029			else if (p_b[NCOLONNE] && do_not_ask_missing)
2030			{
2031				p[NCOLONNE] = 7;
2032				p_b[NCOLONNE] = false;
2033				test = true;
2034			}
2035			else
2036			{
2037				printf("Attenzione: numero colonne nel file binario non definito\n");
2038				test = false;
2039			}
2040		}
2041
2042
2043		if (xmin > xmax)
2044		{
2045			printf("Attenzione: xmin > xmax\n");
2046			test = false;
2047		}
2048		if (ymin > ymax)
2049		{
2050			printf("Attenzione: ymin > ymax\n");
2051			test = false;
2052		}
2053		if (zmin > zmax)
2054		{
2055			printf("Attenzione: zmin > zmax\n");
2056			test = false;
2057		}
2058		if (pxmin > pxmax)
2059		{
2060			printf("Attenzione: pxmin > pxmax\n");
2061			test = false;
2062		}
2063		if (pymin > pymax)
2064		{
2065			printf("Attenzione: pymin > pymax\n");
2066			test = false;
2067		}
2068		if (pzmin > pzmax)
2069		{
2070			printf("Attenzione: pzmin > pzmax\n");
2071			test = false;
2072		}
2073		if (Emin > Emax)
2074		{
2075			printf("Attenzione: Emin > Emax\n");
2076			test = false;
2077		}
2078		if (thetamin > thetamax)
2079		{
2080			printf("Attenzione: thetamin > thetamax\n");
2081			test = false;
2082		}
2083		if (thetaTmin > thetaTmax)
2084		{
2085			printf("Attenzione: thetaTmin > thetaTmax\n");
2086			test = false;
2087		}
2088		if (tymin > tymax)
2089		{
2090			printf("Attenzione: tymin > tymax\n");
2091			test = false;
2092		}
2093		if (tzmin > tzmax)
2094		{
2095			printf("Attenzione: tzmin > tzmax\n");
2096			test = false;
2097		}
2098		if (wmin > wmax)
2099		{
2100			printf("Attenzione: wmin > wmax\n");
2101			test = false;
2102		}
2103		if (nbin_x <= 0)
2104		{
2105			printf("Attenzione: nbin_x < 0\n");
2106			test = false;
2107		}
2108		if (nbin_y <= 0)
2109		{
2110			printf("Attenzione: nbin_y < 0\n");
2111			test = false;
2112		}
2113		if (nbin_z <= 0)
2114		{
2115			printf("Attenzione: nbin_z < 0\n");
2116			test = false;
2117		}
2118		if (nbin_px <= 0)
2119		{
2120			printf("Attenzione: nbin_px < 0\n");
2121			test = false;
2122		}
2123		if (nbin_py <= 0)
2124		{
2125			printf("Attenzione: nbin_py < 0\n");
2126			test = false;
2127		}
2128		if (nbin_pz <= 0)
2129		{
2130			printf("Attenzione: nbin_pz < 0\n");
2131			test = false;
2132		}
2133		if (nbin_E <= 0)
2134		{
2135			printf("Attenzione: nbin_E < 0\n");
2136			test = false;
2137		}
2138		if (nbin_theta <= 0)
2139		{
2140			printf("Attenzione: nbin_theta < 0\n");
2141			test = false;
2142		}
2143		if (nbin_thetaT <= 0)
2144		{
2145			printf("Attenzione: nbin_thetaT < 0\n");
2146			test = false;
2147		}
2148		if (nbin_ty <= 0)
2149		{
2150			printf("Attenzione: nbin_ty < 0\n");
2151			test = false;
2152		}
2153		if (nbin_tz <= 0)
2154		{
2155			printf("Attenzione: nbin_tz < 0\n");
2156			test = false;
2157		}
2158		if (nbin_w <= 0)
2159		{
2160			printf("Attenzione: nbin_w < 0\n");
2161			test = false;
2162		}
2163	}
2164	else
2165	{
2166		if (!p_b[OUT_VTK_NOSTRETCH] && p[OUT_VTK_NOSTRETCH] != 0 && p[OUT_VTK_NOSTRETCH] != 1)
2167		{
2168			printf("Attenzione: output vtk nostretch mal definito\n");
2169			test = false;
2170		}
2171		else
2172		{
2173			if (!p_b[OUT_VTK_NOSTRETCH] && (p[OUT_VTK_NOSTRETCH] == 0 || p[OUT_VTK_NOSTRETCH] == 1))
2174			{
2175				test = true;		// tutto ok, in questo caso il parametro va bene!
2176			}
2177			else if (p_b[OUT_VTK_NOSTRETCH] && do_not_ask_missing)
2178			{
2179				p[OUT_VTK_NOSTRETCH] = 0;
2180				p_b[OUT_VTK_NOSTRETCH] = false;
2181				test = true;
2182			}
2183			else
2184			{
2185				printf("Attenzione: output binario non definito\n");
2186				test = false;
2187			}
2188		}
2189		if (!p_b[OUT_VTK] && p[OUT_VTK] != 0 && p[OUT_VTK] != 1)
2190		{
2191			printf("Attenzione: output binario mal definito\n");
2192			test = false;
2193		}
2194		else
2195		{
2196			if (!p_b[OUT_VTK] && (p[OUT_VTK] == 0 || p[OUT_VTK] == 1))
2197			{
2198				test = true;		// tutto ok, in questo caso il parametro va bene!
2199			}
2200			else if (p_b[OUT_VTK] && do_not_ask_missing)
2201			{
2202				p[OUT_VTK] = 0;
2203				p_b[OUT_VTK] = false;
2204				test = true;
2205			}
2206			else
2207			{
2208				printf("Attenzione: output binario non definito\n");
2209				test = false;
2210			}
2211		}
2212		if (!p_b[OUT_PARAMS] && p[OUT_PARAMS] != 0 && p[OUT_PARAMS] != 1)
2213		{
2214			printf("Attenzione: output parametri mal definito\n");
2215			test = false;
2216		}
2217		else
2218		{
2219			if (!p_b[OUT_PARAMS] && (p[OUT_PARAMS] == 0 || p[OUT_PARAMS] == 1))
2220			{
2221				test = true;		// tutto ok, in questo caso il parametro va bene!
2222			}
2223			else if (p_b[OUT_PARAMS] && do_not_ask_missing)
2224			{
2225				p[OUT_PARAMS] = 0;
2226				p_b[OUT_PARAMS] = false;
2227				test = true;
2228			}
2229			else
2230			{
2231				printf("Attenzione: output parametri non definito\n");
2232				test = false;
2233			}
2234		}
2235		if (!p_b[OUT_LINEOUT_X] && p[OUT_LINEOUT_X] != 0 && p[OUT_LINEOUT_X] != 1)
2236		{
2237			printf("Attenzione: output lineout mal definito\n");
2238			test = false;
2239		}
2240		else
2241		{
2242			if (!p_b[OUT_LINEOUT_X] && (p[OUT_LINEOUT_X] == 0 || p[OUT_LINEOUT_X] == 1))
2243			{
2244				test = true;		// tutto ok, in questo caso il parametro va bene!
2245			}
2246			else if (p_b[OUT_LINEOUT_X] && do_not_ask_missing)
2247			{
2248				p[OUT_LINEOUT_X] = 0;
2249				p_b[OUT_LINEOUT_X] = false;
2250				test = true;
2251			}
2252			else
2253			{
2254				printf("Attenzione: output lineout non definito\n");
2255				test = false;
2256			}
2257		}
2258		if (!p_b[NCOLONNE] && p[NCOLONNE] < 1)
2259		{
2260			printf("Attenzione: dimensioni griglia mal definite\n");
2261			test = false;
2262		}
2263		else
2264		{
2265			if (!p_b[NCOLONNE] && p[NCOLONNE] >= 1)
2266			{
2267				test = true;		// tutto ok, in questo caso il parametro va bene!
2268			}
2269			else
2270			{
2271				printf("Attenzione: non capisco se la griglia e' 2D o 3D\n");
2272				if (old_fortran_bin) printf("Con i files privi di .dat e' necessario specificare -ncol su riga di comando in modalita' batch\n");
2273				test = false;
2274			}
2275		}
2276		if (!p_b[OUT_CUTX] && p[OUT_CUTX] != 0 && p[OUT_CUTX] != 1)
2277		{
2278			printf("Attenzione: output slice mal definito\n");
2279			test = false;
2280		}
2281		else
2282		{
2283			if (!p_b[OUT_CUTX] && (p[OUT_CUTX] == 0 || p[OUT_CUTX] == 1))
2284			{
2285				test = true;		// tutto ok, in questo caso il parametro va bene!
2286			}
2287			else if (p_b[OUT_CUTX] && do_not_ask_missing)
2288			{
2289				p[OUT_CUTX] = 0;
2290				p_b[OUT_CUTX] = false;
2291				test = true;
2292			}
2293			else
2294			{
2295				printf("Attenzione: output slice non definito\n");
2296				test = false;
2297			}
2298		}
2299		if (!p_b[OUT_CUTY] && p[OUT_CUTY] != 0 && p[OUT_CUTY] != 1)
2300		{
2301			printf("Attenzione: output slice mal definito\n");
2302			test = false;
2303		}
2304		else
2305		{
2306			if (!p_b[OUT_CUTY] && (p[OUT_CUTY] == 0 || p[OUT_CUTY] == 1))
2307			{
2308				test = true;		// tutto ok, in questo caso il parametro va bene!
2309			}
2310			else if (p_b[OUT_CUTY] && do_not_ask_missing)
2311			{
2312				p[OUT_CUTY] = 0;
2313				p_b[OUT_CUTY] = false;
2314				test = true;
2315			}
2316			else
2317			{
2318				printf("Attenzione: output slice non definito\n");
2319				test = false;
2320			}
2321		}
2322		if (!p_b[OUT_CUTZ] && p[OUT_CUTZ] != 0 && p[OUT_CUTZ] != 1)
2323		{
2324			printf("Attenzione: output slice mal definito\n");
2325			test = false;
2326		}
2327		else
2328		{
2329			if (!p_b[OUT_CUTZ] && (p[OUT_CUTZ] == 0 || p[OUT_CUTZ] == 1))
2330			{
2331				test = true;		// tutto ok, in questo caso il parametro va bene!
2332			}
2333			else if (p_b[OUT_CUTZ] && do_not_ask_missing)
2334			{
2335				p[OUT_CUTZ] = 0;
2336				p_b[OUT_CUTZ] = false;
2337				test = true;
2338			}
2339			else
2340			{
2341				printf("Attenzione: output slice non definito\n");
2342				test = false;
2343			}
2344		}
2345		if (!p_b[OUT_GRID2D] && p[OUT_GRID2D] != 0 && p[OUT_GRID2D] != 1)
2346		{
2347			printf("Attenzione: output griglia 2D mal definito\n");
2348			test = false;
2349		}
2350		else
2351		{
2352			if (!p_b[OUT_GRID2D] && (p[OUT_GRID2D] == 0 || p[OUT_GRID2D] == 1))
2353			{
2354				test = true;		// tutto ok, in questo caso il parametro va bene!
2355			}
2356			else if (p_b[OUT_GRID2D] && do_not_ask_missing)
2357			{
2358				p[OUT_GRID2D] = 0;
2359				p_b[OUT_GRID2D] = false;
2360				test = true;
2361			}
2362			else
2363			{
2364				printf("Attenzione: output griglia 2D non definito\n");
2365				test = false;
2366			}
2367		}
2368	}
2369
2370
2371	return test;
2372}
2373
2374
2375void Parametri::organizza_minimi_massimi()
2376{
2377	minimi[0] = xmin;
2378	minimi[1] = ymin;
2379	minimi[2] = zmin;
2380	minimi[3] = pxmin;
2381	minimi[4] = pymin;
2382	minimi[5] = pzmin;
2383	minimi[6] = gammamin;
2384	minimi[7] = thetamin;
2385	minimi[8] = Emin;
2386	minimi[9] = thetaTmin;
2387	minimi[10] = tymin;
2388	minimi[11] = tzmin;
2389	minimi[12] = wmin;
2390
2391	massimi[0] = xmax;
2392	massimi[1] = ymax;
2393	massimi[2] = zmax;
2394	massimi[3] = pxmax;
2395	massimi[4] = pymax;
2396	massimi[5] = pzmax;
2397	massimi[6] = gammamax;
2398	massimi[7] = thetamax;
2399	massimi[8] = Emax;
2400	massimi[9] = thetaTmax;
2401	massimi[10] = tymax;
2402	massimi[11] = tzmax;
2403	massimi[12] = wmax;
2404
2405}
2406
2407
2408
2409#endif