/* This file is part of Cloudy and is copyright (C)1978-2013 by Gary J. Ferland and
 * others.  For conditions of distribution and use see copyright notice in license.txt */
/*ParsePrint parse the print command  */
/*prt_constants print physical constants */
/* PrtMacros - print macros in cddefines.h and their status -  *print macros* */
#include "cddefines.h"
#include "physconst.h"
#include "rfield.h"
#include "rt.h"
#include "cpu.h"
#include "iso.h"
#include "iterations.h"
#include "lines.h"
#include "called.h"
#include "elementnames.h"
#include "thirdparty.h"
#include "ionbal.h"
#include "prt.h"
#include "h2.h"
#include "parser.h"
#include "version.h"
/*prt_constants print physical constants */
STATIC void prt_constants(void);


// PrtMacros - print macros in cddefines.h and their status -  *print macros*
STATIC void PrtMacros( void )
{

	DEBUG_ENTRY( "PrtMacros()" );

	fprintf( ioQQQ," PrtMacros:\n FLT_IS_DBL\t");
#	ifdef FLT_IS_DBL
	fprintf( ioQQQ,"defined.\n");
#	endif

	fprintf( ioQQQ , "\n DMALLOC\t");
#	ifdef DMALLOC
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n SYS_CONFIG\t");
#	ifdef SYS_CONFIG
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n MPI_GRID_RUN\t");
#	ifdef MPI_GRID_RUN
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n USE_GPROF\t");
#	ifdef USE_GPROF
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n HAVE_FUNC\t");
#	ifdef HAVE_FUNC
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n _MSC_VER\t");
#	ifdef _MSC_VER
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n __INTEL_COMPILER\t");
#	ifdef __INTEL_COMPILER
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n OLD_ASSERT\t");
#	ifdef OLD_ASSERT
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n HAVE_POWI\t");
#	ifdef HAVE_POWI
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n HAVE_POW_DOUBLE_INT\t");
#	ifdef HAVE_POW_DOUBLE_INT
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n HAVE_POW_DOUBLE_LONG\t");
#	ifdef HAVE_POW_DOUBLE_LONG
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n HAVE_POW_FLOAT_INT\t");
#	ifdef HAVE_POW_FLOAT_INT
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n HAVE_POW_FLOAT_LONG\t");
#	ifdef HAVE_POW_FLOAT_LONG
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n HAVE_POW_FLOAT_DOUBLE\t");
#	ifdef HAVE_POW_FLOAT_DOUBLE
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n HAVE_POW_DOUBLE_FLOAT\t");
#	ifdef HAVE_POW_DOUBLE_FLOAT
	fprintf( ioQQQ,"defined");
#	endif

	fprintf( ioQQQ , "\n");

}

void ParsePrint(
	/* input line was converted to caps by calling routine */
	Parser &p )
{
	int ipISO;
	long int
	  j, 
	  nelem,
	  num1;
	double a;

	DEBUG_ENTRY( "ParsePrint()" );

	/* >>chng 01 aug 91, had been series of if branches, and could hit more than
	 * one key - dangerous!  changed to else if so only one hit per line possible */
	if( p.nMatch("AGES") )
	{
		/* print all estimates of cloud timescales */
		prt.lgPrnAges = true;
	}

	else if( p.nMatch("ARRA") )
	{
		/* print arrays for ionization balance of heavy elements */
		if( p.nMatch( "ONLY"  ) )
		{
			/* returns element number on C scale */
			if( (nelem = p.GetElem())<0 )
			{
				fprintf(ioQQQ,"An element name must appear on this PRINT ARRAYS ONLY xx command.\n");
				cdEXIT(EXIT_FAILURE);
			}
			/* have the element number, turn on its print */
			prt.lgPrtArry[nelem] = true;
		}
		else
		{
			/* this flag, print arrays for all elements */
			for( nelem=ipHYDROGEN; nelem<LIMELM; ++nelem )
			{
				prt.lgPrtArry[nelem] = true;
			}
		}
	}

	else if( p.nMatch("CITA") )
	{
		prt.lgPrtCitations = true;
	}

	else if( p.nMatch("COLU") && p.nMatch("DENS") )
	{
		if( p.nMatch(" ON ") )
		{
			/* print column densities of elements - this is default */
			prt.lgPrintColumns = true;
		}
		else if( p.nMatch(" OFF") )
		{
			/* print column densities of elements */
			prt.lgPrintColumns = false;
		}
	}

	/* option to print departure coefficients in addition to level pops 
	 * keywords He-like to do He-like sequence element, else do h-like
	 * element name, if not recognized, does hydrogen
	 * so with no options prints hydrogen itself */
	else if( p.nMatch("DEPA") )
	{
		if( p.nMatch("HE-L") )
		{
			ipISO = ipHE_LIKE;
		}
		else
		{
			ipISO = ipH_LIKE;
		}

		/* now check for element name */
		nelem = p.GetElem( );

		/* return value is < 0 if no element recognized - in this case use root of sequence */
		nelem = MAX2( nelem, ipISO );

		/* print departure coefficients instead of hydrogen level populations */
		iso_sp[ipISO][nelem].lgPrtDepartCoef = true;
	}

	else if( p.nMatch("CONS") )
	{
		/* print physical constants, routine is below */
		prt_constants();
	}

	else if( p.nMatch("ERRO") )
	{
		/* print errors to special window */
		lgPrnErr = true;
	}

	else if( p.nMatch("HEAT") )
	{
		/* print heat arrays */
		prt.lgPrintHeating = true;
	}

	else if( p.nMatch("PATH") )
	{
		/* print the path */
		cpu.i().printDataPath();
	}

	/*else if( p.nMatch("H-LI"))*/
	else if( p.nMatch("POPU"))
	{
		if( p.nMatch("HE-L") )
		{
			ipISO = ipHE_LIKE;
		}
		else
		{
			ipISO = ipH_LIKE;
		}

		/* now check for element name */
		nelem = p.GetElem( );
		/* return value is < 0 if no element recognized - in this case use H */
		nelem = MAX2(0,nelem);

		/* if no element specified but he-like iso, then use helium */
		if( nelem==0 && ipISO==ipHE_LIKE )
			nelem = ipHELIUM;

		if( nelem < ipISO )
		{
			fprintf(ioQQQ,"This iso-sequence (%s) and element (%s) are impossible.\n",
				elementnames.chElementName[ipISO],
				elementnames.chElementName[nelem]);
			cdEXIT(EXIT_FAILURE);
		}

		/* print hydrogenic H-like level populations */
		iso_sp[ipISO][nelem].lgPrtLevelPops = true;
	}

	/* option to only print last iteration */
	else if( p.nMatch("LAST") )
	{
		prt.lgPrtLastIt = true;
	}

	/* the print line command as several options */
	else if( p.nMatch("LINE") )
	{
		if( p.nMatch(" ALL") )
		{
			/* turn on all printed components */
			prt.lgPrnPump = true;
			prt.lgPrnColl = true;
			prt.lgPrnHeat = true;
		}

		else if( p.nMatch("CELL") )
		{
			/* print line cell on physics scale, first cell in continuum is 1
			 * give all lines in this cell */
			prt.lgPrnLineCell = true;
			prt.nPrnLineCell = (long)p.FFmtRead();
			if( p.lgEOL() )
				p.NoNumb("cell for line print" );
			if( prt.nPrnLineCell < 1 )
			{
				/* non-positive cells are not allowed */
				fprintf(ioQQQ , "The cell number on the PRINT LINE CELL command must be positive.\n");
				fprintf(ioQQQ , "The cell number was %li.\n" , prt.nPrnLineCell);
			}
		}

		else if( p.nMatch("COLL") )
		{
			/* either print line collisions or print line iso collapsed */
			/* also print collisional contributions */
			if( p.nMatch(" ISO") )
			{
				/* print predictions from collapsed levels of iso sequences */
				prt.lgPrnIsoCollapsed = true;
			}
			else
			{
				/* print line collisions */
				prt.lgPrnColl = true;
			}
		}

		else if( p.nMatch("COLU") )
		{
			/* option to print main line array as a single column */
			prt.lgPrtLineArray = false;
			/* this also has an option - liNEAR - to print linear quantity 
			 * in exponential format */
			if( p.nMatch("NEAR") )
				prt.lgPrtLineLog = false;
		}

		else if( p.nMatch("FAIN") && !(p.nMatch("OPTI")&&p.nMatch("DEPT")) )
		{
			/* print line faint - above do not trigger on optical depth 
			 * option to adjust intensity of faintest line to print */
			/* >> 01 feb 01, move print faint into print line faint */
			/* faintest line, rel to norm line, to print; either linear of log */
			a = p.FFmtRead();

			/* option for, if no number, keyword=" OFF", to print all lines */
			if( p.lgEOL() )
			{
				if( p.nMatch(" OFF") )
				{
					prt.lgFaintOn = false;
				}
				else
				{
					fprintf( ioQQQ, 
						" There faintest line to print must be on this line, sorry.\n" );
					cdEXIT(EXIT_FAILURE);
				}
			}

			prt.lgFntSet = true;
			if( a <= 0. || p.nMatch(" LOG") )
			{
				prt.TooFaint = (realnum)pow(10.,a);
			}
			else
			{
				prt.TooFaint = (realnum)a;
			}
		}

		else if( p.nMatch("FLUX") && p.nMatch("EART"))
		{
			/* print line flux seen at earth */
			prt.lgPrintFluxEarth = true;
		}

		else if( p.nMatch(" H2") && p.nMatch("ELEC") )
		{
			/* print H2 electronic lines too - -1 since number of electronic
			 * levels is not yet known, will set when H2 actually called */
			h2.nElecLevelOutput = -1;
		}

		else if( p.nMatch("HEAT") )
		{
			/* also print heating contributions */
			prt.lgPrnHeat = true;
		}

		else if( p.nMatch("INWA") )
		{
			/* also print inward contributions */
			prt.lgPrnInwd = true;
		}

		else if( p.nMatch("OPTI") && p.nMatch("DEPT") )
		{
			/* print line optical depths, with option for smallest to print */
			if( p.nMatch(" OFF") )
			{
				/* turn off or on printing of optical depths - default off */
				prt.lgPrtTau = false;
			}
			else
			{
				prt.lgPrtTau = true;
			}
			if( p.nMatch("FAIN") )
			{
				/* log of faintest optical depth, default is linear value of 0.1 */
				prt.PrtTauFnt = (realnum)pow(10.,p.FFmtRead());
				if( p.lgEOL() )
				{
					fprintf( ioQQQ, " There must be a number for the FAINT option.  They are HEAD and ZONE.  Sorry.\n" );
					cdEXIT(EXIT_FAILURE);
				}
			}
		}

		else if( p.nMatch("PUMP") )
		{
			/* also print pump contributions */
			prt.lgPrnPump = true;
		}

		else if( p.nMatch("SORT") )
		{
			/* >>chng 01 aug 18, print sort command works after all these years,
			 * sort by wavelength or intensity */
			/* turn on sorting with respect to wavelength */
			prt.lgSortLines = true;
			if( p.nMatch("WAVE") )
			{
				/* sort by wavelength */
				/* remember which one to do */
				prt.lgSortLineIntensity = false;
				prt.lgSortLineWavelength = true;

				/* wavelength has range option */
				/* option to only certain print range of lines */
				if( p.nMatch("RANG") )
				{
					prt.wlSort1 = (realnum)p.getWaveOpt();

					prt.wlSort2 = (realnum)p.getWaveOpt();

					if( p.lgEOL() )
					{
						fprintf( ioQQQ, " There must be two numbers for the RANGE option, the lower and upper wavelength.  Sorry.\n" );
						cdEXIT(EXIT_FAILURE);
					}
					if( prt.wlSort1 <0. || prt.wlSort2 <0. || 
						prt.wlSort1 >= prt.wlSort2 )
					{
						fprintf( ioQQQ, " The lower and upper wavelength must be positive and in the correct order.  Sorry.\n" );
						cdEXIT(EXIT_FAILURE);
					}
				}
				else
				{
					prt.wlSort1 = -1;
					prt.wlSort2 = 1e30f;
				}
			}
			else if( p.nMatch("INTE") )
			{
				/* sort by intensity/luminosity */
				/* remember which one to do */
				prt.lgSortLineIntensity = true;
				prt.lgSortLineWavelength = false;
			}
			else
			{
				fprintf( ioQQQ, "I can sort by wavelength or intensity - one must be specified.\nSorry.\n" );
				cdEXIT(EXIT_FAILURE);
			}
		}

		else if( p.nMatch(" SUM") )
		{
			/* option to read in set of lines to sum over */
			ParsePrtLineSum( p );
		}

		else if( p.nMatch("SURF") && p.nMatch("BRIG") )
		{
			/* print surface brightness rather than 4pi J */
			prt.lgSurfaceBrightness = true;
			/* default is per sr, arcsec option changes to sq arcsec */
			if( p.nMatch("ARCS" ) )
			{
				/* use sr */
				prt.lgSurfaceBrightness_SR = false;
			}
			else
			{
				/* use sq arcsec */
				prt.lgSurfaceBrightness_SR = true;
			}
		}

		else if( p.nMatch("CUMU") )
		{
			/* print lines cumulative - integral of line emission over time */
			prt.lgPrintLineCumulative = true;
		}

		else
		{
			fprintf( ioQQQ, "One of the keys should have appeared.  \nPlease consult Hazy.\nSorry.\n" );
			cdEXIT(EXIT_FAILURE);
		}
	}

	/* print maser lines when TAV is called */
	else if( p.nMatch("MASE") )
	{
		prt.lgPrtMaser = true;
	}

	else if( p.nMatch("ONLY") )
	{
		if( p.nMatch("ZONE") )
			prt.lgOnlyZone = true;

		else if( p.nMatch("HEAD") )
			prt.lgOnlyHead = true;

		else
		{
			fprintf( ioQQQ, " There must be a keyword for the ONLY option.  They are HEAD and ZONE.  Sorry.\n" );
			cdEXIT(EXIT_FAILURE);
		}
	}

	else if( p.nMatch("STAR") )
	{
		/* start printout at specified zone */
		called.lgTalk = false;
		prt.lgPrtStart = true;
		prt.nstart = (long int)p.FFmtRead();
		if( p.lgEOL() )
		{
			fprintf( ioQQQ, 
				" The zone on which the print is to start MUST be entered on this line.  Sorry.\n" );
			cdEXIT(EXIT_FAILURE);
		}
	}

	/* print continuum command */
	else if( p.nMatch("CONT") )
	{
		if( p.nMatch("BLOC") )
		{
			/* option to print emergent continuum at end of calculation*/
			fprintf(ioQQQ , " PROBLEM The PRINT CONTINUUM BLOCK command has been removed.  Ignored for now.\n");
		}
		else if( p.nMatch("INDI"  ))
		{
			/* option to print lines and continuum that go into each continuum 
			 * index the continuum index is the cell within the continuum 
			 * array - this identifies lines that occur within each 
			 * continuum cell */
			prt.lgPrtContIndices = true;
			/* these are lower and upper limits to the energy range in Rydbergs.
			* they are the first and second number on the command line, lower and
			* upper bounds of the code are used if not specified */
			/* if no number on line then zero is returned, this is fine, since
			 * we want the lower energy bound of the code */
			prt.lgPrtContIndices_lo_E = (realnum)p.FFmtRead();
			prt.lgPrtContIndices_hi_E = (realnum)p.FFmtRead();
			/* if we hit end of line then use high-energy limit of code - that is,
			 * include all energies */
			if( p.lgEOL() )
				prt.lgPrtContIndices_hi_E = (realnum)rfield.egamry;
		}
		else
		{
			/* option to print continuum points within emission lines block */
			fprintf( ioQQQ, " PROBLEM PRINT CONTINUUM command is now the default, and the command has been removed.\n" );
		}
	}

	else if( p.nMatch("COOL") )
	{
		/* print cooling array for a specified one */
		prt.nzdump = (long int)p.FFmtRead();

		/* dump all zones if argument is zero or not present  */
		if( p.lgEOL() )
		{
			prt.nzdump = 0;
		}
	}

	else if( p.nMatch("QUIE") || (p.nMatch(" OFF") && 
		!p.nMatch("FAIN" )) )
	{
		/* in above, there is also a 'print faint off' command
		 * QUIET or OFF means turn off printout */
		called.lgTalk = false;
	}

	else if( p.nMatch("MACR") )
	{
		// print status of macros in cddefines.ht */
		PrtMacros();
	}

	else if( p.nMatch(" ON ") )
	{
		/* on means turn on printout, lgTalkIsOK is set false in grid_do.cpp.
		 * this keeps printout quiet during optimize, even when init files are parsed */
		/* called.lgTalkForcedOff was set true with cdTalk(false), if this was
		 * set then do not respect this command.  this is to prevent print on at end
		 * of init file from turning on print in grids when print is turned off */
		if( called.lgTalkIsOK && !called.lgTalkForcedOff )
		{
			called.lgTalk = cpu.i().lgMPI_talk();
		}
	}

	else if (p.nMatch("RECOMB"))
	{
		ionbal.lgRecom_Badnell_print = true;
		/* option to print recombination rates then exit */
	}

	else if( p.nMatch("SHOR") )
	{
		/* make short printout, don't print last */
		prt.lgPrtShort = true;
		if( !prt.lgFntSet )
			prt.TooFaint = 0.001f;
	}

	else if( p.nMatch("VERS") )
	{
		/* print compiler and code version information */
		fprintf( ioQQQ, "\nThis is Cloudy %s\n%s\n\n" ,
			t_version::Inst().chVersion,
			t_version::Inst().chInfo );
	}

	else if( p.nMatch("VOIGT") )
	{
		/* Voigt function debugging print - parameter is damping constant a */
		realnum damp = (realnum)p.FFmtRead();
		if( p.lgEOL() )
		{
			fprintf( ioQQQ, " The damping constant must appear on the print voigt command.  Sorry.\n" );
			cdEXIT(EXIT_FAILURE);
		}

		const long NVOIGT=100;
		realnum xprofile[NVOIGT], profileVoigtH[NVOIGT];
		for( long i=0; i<NVOIGT; ++i )
			xprofile[i] = (realnum)i * 10.f / (realnum)NVOIGT;

		VoigtH( damp, xprofile, profileVoigtH, NVOIGT );

		fprintf(ioQQQ,"\n    x        VoigtH\n");
		for( long int i=0; i<NVOIGT; ++i )
		{
			fprintf(ioQQQ,"%.4e %.4e\n", xprofile[i], profileVoigtH[i] );
		}
	}

	else if( p.nMatch("ZONE") || p.nMatch("EVER") )
	{
		/* print every nth zone - command was originally print every but
		 * is being changed to print zone */
		num1 = (long int)p.FFmtRead();
		if( p.lgEOL() )
		{
			fprintf( ioQQQ, " The number of zones to print MUST be entered on this line.  Sorry.\n" );
			cdEXIT(EXIT_FAILURE);
		}

		iterations.IterPrnt[0] = MAX2(num1,1);

		for( j=1; j < iterations.iter_malloc; j++ )
		{
			iterations.IterPrnt[j] = (long int)p.FFmtRead();
			if( p.lgEOL() )
			{
				iterations.IterPrnt[j] = iterations.IterPrnt[j-1];
			}
		}
	}

	/* check if no keywords were recognized. */
	else
	{
		fprintf( ioQQQ, " There MUST be a keyword on the following line.  Sorry.\n" );
		fprintf( ioQQQ, " The PRINT FAINT command is now the PRINT LINE FAINT command.\n" );
		p.PrintLine(ioQQQ);
		cdEXIT(EXIT_FAILURE);
	}
	return;
}

/*prt_constants print physical and machine constants */
STATIC void prt_constants(void)
{

	DEBUG_ENTRY( "prt_constants()" );

	fprintf(ioQQQ,"\n\nPhysical constants used by Cloudy, taken from physconst.h\n");

	fprintf(ioQQQ,"EE\t%.15g\n",EE);
	fprintf(ioQQQ,"EULER\t%.15g\n",EULER);
	fprintf(ioQQQ,"PI\t%.15g\n",PI);
	fprintf(ioQQQ,"PI2\t%.15g\n",PI2);
	fprintf(ioQQQ,"PI4\t%.15g\n",PI4);
	fprintf(ioQQQ,"PI8\t%.15g\n",PI8);
	fprintf(ioQQQ,"SQRT2\t%.15g\n",SQRT2);
	fprintf(ioQQQ,"SQRTPI\t%.15g\n",SQRTPI);
	fprintf(ioQQQ,"SQRTPIBY2\t%.15g\n",SQRTPIBY2);
	fprintf(ioQQQ,"LN_TWO\t%.15g\n",LN_TWO);
	fprintf(ioQQQ,"LN_TEN\t%.15g\n",LN_TEN);
	fprintf(ioQQQ,"LOG10_E\t%.15g\n",LOG10_E);
	fprintf(ioQQQ,"OPTDEP2EXTIN\t%.15g\n",OPTDEP2EXTIN);
	fprintf(ioQQQ,"RADIAN\t%.15g\n",RADIAN);
	fprintf(ioQQQ,"SOLAR_MASS\t%.15g\n",SOLAR_MASS);
	fprintf(ioQQQ,"SOLAR_LUMINOSITY\t%.15g\n",SOLAR_LUMINOSITY);
	fprintf(ioQQQ,"AU\t%.15g\n",AU);
	fprintf(ioQQQ,"ATOMIC_MASS_UNIT\t%.15g\n",ATOMIC_MASS_UNIT);
	fprintf(ioQQQ,"ELECTRON_MASS\t%.15g\n",ELECTRON_MASS);
	fprintf(ioQQQ,"PROTON_MASS\t%.15g\n",PROTON_MASS);
	fprintf(ioQQQ,"BOLTZMANN\t%.15g\n",BOLTZMANN);
	fprintf(ioQQQ,"SPEEDLIGHT\t%.15g\n",SPEEDLIGHT);
	fprintf(ioQQQ,"HPLANCK\t%.15g\n",HPLANCK);
	fprintf(ioQQQ,"GRAV_CONST\t%.15g\n",GRAV_CONST);
	fprintf(ioQQQ,"ELEM_CHARGE\t%.15g\n",ELEM_CHARGE);
	fprintf(ioQQQ,"RYD_INF\t%.15g\n",RYD_INF);
	fprintf(ioQQQ,"HIONPOT\t%.15g\n",HIONPOT);
	fprintf(ioQQQ,"AS1RAD\t%.15g\n",AS1RAD);
	fprintf(ioQQQ,"SQAS1SR\t%.15g\n",SQAS1SR);
	fprintf(ioQQQ,"SQAS_SKY\t%.15g\n",SQAS_SKY);
	fprintf(ioQQQ,"PARSEC\t%.15g\n",PARSEC);
	fprintf(ioQQQ,"H_BAR \t%.15g\n",H_BAR );
	fprintf(ioQQQ,"ELEM_CHARGE_ESU \t%.15g\n",ELEM_CHARGE_ESU );
	fprintf(ioQQQ,"ELECTRIC_CONST\t%.15g\n",ELECTRIC_CONST);
	fprintf(ioQQQ,"HION_LTE_POP\t%.15g\n",HION_LTE_POP);
	fprintf(ioQQQ,"SAHA\t%.15g\n",SAHA);
	fprintf(ioQQQ,"ERG1CM\t%.15g\n",ERG1CM);
	fprintf(ioQQQ,"T1CM\t%.15g\n",T1CM);
	fprintf(ioQQQ,"WAVNRYD\t%.15g\n",WAVNRYD);
	fprintf(ioQQQ,"RYDLAM\t%.15g\n",RYDLAM);
	fprintf(ioQQQ,"EN1RYD\t%.15g\n",EN1RYD);
	fprintf(ioQQQ,"TE1RYD\t%.15g\n",TE1RYD);
	fprintf(ioQQQ,"EVDEGK\t%.15g\n",EVDEGK);
	fprintf(ioQQQ,"EVRYD\t%.15g\n",EVRYD);
	fprintf(ioQQQ,"EN1EV\t%.15g\n",EN1EV);
	fprintf(ioQQQ,"FR1RYD\t%.15g\n",FR1RYD);
	fprintf(ioQQQ,"HNU3C2\t%.15g\n",HNU3C2);
	fprintf(ioQQQ,"FR1RYDHYD\t%.15g\n",FR1RYDHYD );
	fprintf(ioQQQ,"HBAReV\t%.15g\n",HBAReV );
	fprintf(ioQQQ,"RYDLAMHYD\t%.15g\n",RYDLAMHYD );
	fprintf(ioQQQ,"STEFAN_BOLTZ\t%.15g\n",STEFAN_BOLTZ);
	fprintf(ioQQQ,"FREQ_1EV\t%.15g\n",FREQ_1EV);
	fprintf(ioQQQ,"FINE_STRUCTURE\t%.15g\n",FINE_STRUCTURE);
	fprintf(ioQQQ,"BOHR_RADIUS_CM\t%.15g\n",BOHR_RADIUS_CM);
	fprintf(ioQQQ,"TWO_PHOT_CONST\t%.15g\n",TWO_PHOT_CONST);
	fprintf(ioQQQ,"COLL_CONST\t%.15g\n",COLL_CONST);
	fprintf(ioQQQ,"MILNE_CONST\t%.15g\n",MILNE_CONST);
	fprintf(ioQQQ,"TRANS_PROB_CONST\t%.15g\n",TRANS_PROB_CONST);
	fprintf(ioQQQ,"\n");

	fprintf(ioQQQ,"Some other interesting sizes:\n");
	fprintf(ioQQQ,"bool\t%lu\n",(unsigned long)sizeof(bool));
	fprintf(ioQQQ,"char\t%lu\n",(unsigned long)sizeof(char));
	fprintf(ioQQQ,"int\t%lu\n",(unsigned long)sizeof(int));
	fprintf(ioQQQ,"long int\t%lu\n",(unsigned long)sizeof(long int));
	fprintf(ioQQQ,"unsigned int\t%lu\n",(unsigned long)sizeof(unsigned int));
	fprintf(ioQQQ,"float\t%lu\n",(unsigned long)sizeof(sys_float));
	fprintf(ioQQQ,"realnum\t%lu\n",(unsigned long)sizeof(realnum));
	fprintf(ioQQQ,"double\t%lu\n",(unsigned long)sizeof(double));
	fprintf(ioQQQ,"double*\t%lu\n",(unsigned long)sizeof(double*));
	fprintf(ioQQQ,"\n");

	fprintf(ioQQQ,"Some constants from float.h.\n");
	/* some constants from float.h */
	fprintf(ioQQQ,"DBL_DIG \t%i\n", DBL_DIG);         /* # of decimal digits of precision */
	fprintf(ioQQQ,"DBL_EPSILON \t%.15g\n",DBL_EPSILON);   /* smallest such that 1.0+DBL_EPSILON != 1.0 */
	fprintf(ioQQQ,"DBL_MANT_DIG\t%i\n",DBL_MANT_DIG); /* # of bits in mantissa */
	fprintf(ioQQQ,"DBL_MAX\t%.15g\n", DBL_MAX);           /* max value */
	fprintf(ioQQQ,"DBL_MAX_10_EXP\t%i\n", DBL_MAX_10_EXP); /* max decimal exponent */
	fprintf(ioQQQ,"DBL_MAX_EXP\t%i\n", DBL_MAX_EXP);  /* max binary exponent */
	fprintf(ioQQQ,"DBL_MIN\t%.15g\n", DBL_MIN);           /* min positive value */

	fprintf(ioQQQ,"FLT_DIG\t%i\n", FLT_DIG);          /* # of decimal digits of precision */
	fprintf(ioQQQ,"FLT_EPSILON\t%.15g\n", FLT_EPSILON);   /* smallest such that 1.0+FLT_EPSILON != 1.0 */
	fprintf(ioQQQ,"FLT_MANT_DIG\t%i\n", FLT_MANT_DIG); /* # of bits in mantissa */
	fprintf(ioQQQ,"FLT_MAX\t%.15g\n", FLT_MAX);            /* max value */
	fprintf(ioQQQ,"FLT_MAX_10_EXP\t%i\n", FLT_MAX_10_EXP);/* max decimal exponent */
	fprintf(ioQQQ,"FLT_MAX_EXP\t%i\n", FLT_MAX_EXP);   /* max binary exponent */
	fprintf(ioQQQ,"FLT_MIN\t%.15g\n", FLT_MIN);            /* min positive value */

	fprintf(ioQQQ,"BIGFLOAT\t%.15g\n", BIGFLOAT);
	fprintf(ioQQQ,"SMALLFLOAT\t%.15g\n", SMALLFLOAT);
	fprintf(ioQQQ,"BIGDOUBLE\t%.15g\n", BIGDOUBLE);
	fprintf(ioQQQ,"SMALLDOUBLE\t%.15g\n", SMALLDOUBLE);

	fprintf(ioQQQ,"\nThis machine has %ld threads.\n", cpu.i().nCPU() );

	return;
}