/home66/gary/public_html/cloudy/c08_branch/source/parse_print.cpp

Go to the documentation of this file.

/* This file is part of Cloudy and is copyright (C)1978-2008 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 */
#include "cddefines.h"
#include "physconst.h"
#include "rfield.h"
#include "iso.h"
#include "iterations.h"
#include "lines.h"
#include "called.h"
#include "elementnames.h"
#include "prt.h"
#include "h2.h"
#include "parse.h"
#include "version.h"
/*prt_constants print physical constants */
STATIC void prt_constants(void);

void ParsePrint(
        /* input line was converted to caps by calling routine */
        char *chCARD_CAPS )
{
        bool lgEOL;
        int ipISO;
        long int i, 
          j, 
          nelem,
          num1;
        double a;
        double sum;

        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( nMatch("AGES",chCARD_CAPS) )
        {
                /* print all estimates of cloud timescales */
                prt.lgPrnAges = true;
        }

        else if( nMatch("ARRA",chCARD_CAPS) )
        {
                /* print arrays for ionization balance of heavy elements */
                if( nMatch( "ONLY" , chCARD_CAPS ) )
                {
                        /* returns element number on C scale */
                        if( (nelem = GetElem(chCARD_CAPS))<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( nMatch("CITA",chCARD_CAPS) )
        {
                /* the print citations command */
                fprintf( ioQQQ, "\n\nCloudy is a research project that involves the creative"
                        " efforts of many people.  It should be cited as follows:\n" );
                fprintf( ioQQQ, "Calculations were performed with version %s of Cloudy,"
                        " last described by %s.\n\n",
                        t_version::Inst().chVersion,
                        t_version::Inst().chCitationShort);
                fprintf( ioQQQ, "The reference is:\n%s\n\n", t_version::Inst().chCitation );
                fprintf( ioQQQ, "In Latex this is:\n%s\n\n", t_version::Inst().chCitationLatex  );
        }

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

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

        /* 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( nMatch("DEPA",chCARD_CAPS) )
        {
                if( nMatch("HE-L",chCARD_CAPS) )
                {
                        ipISO = ipHE_LIKE;
                }
                else
                {
                        ipISO = ipH_LIKE;
                }

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

                /* 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.lgPrtDepartCoef[ipISO][nelem] = true;
        }

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

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

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

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

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

                /* now check for element name */
                nelem = GetElem( chCARD_CAPS );
                /* 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.lgPrtLevelPops[ipISO][nelem] = true;
        }

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

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

                else if( nMatch("CELL",chCARD_CAPS) )
                {
                        /* print line cell on physics scale, first cell in continuum is 1
                         * give all lines in this cell */
                        prt.lgPrnLineCell = true;
                        i = 5;
                        prt.nPrnLineCell = (long)FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);
                        if( lgEOL )
                                NoNumb( chCARD_CAPS );
                        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( nMatch("COLL",chCARD_CAPS) )
                {
                        /* also print collisional contributions */
                        prt.lgPrnColl = true;
                }

                else if( nMatch("COLU",chCARD_CAPS) )
                {
                        /* 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( nMatch("NEAR",chCARD_CAPS) )
                                prt.lgPrtLineLog = false;
                }

                /* force printing emergent intensities */
                else if( nMatch("EMER",chCARD_CAPS) && nMatch("GENT",chCARD_CAPS) )
                {
                        prt.lgPrtLineEmergent = true;
                        LineSave.lgLineEmergent = true;
                }

                else if( nMatch("FAIN",chCARD_CAPS) && !(nMatch("OPTI",chCARD_CAPS)&&nMatch("DEPT",chCARD_CAPS)) )
                {
                        /* 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 */
                        i = 5;
                        a = FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);

                        /* option for, if no number, keyword=" OFF", to print all lines */
                        if( lgEOL )
                        {
                                if( nMatch(" OFF",chCARD_CAPS) )
                                {
                                        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. )
                        {
                                prt.TooFaint = (realnum)pow(10.,a);
                        }
                        else
                        {
                                prt.TooFaint = (realnum)a;
                        }
                }

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

                else if( nMatch(" H2",chCARD_CAPS) && nMatch("ELEC",chCARD_CAPS) )
                {
                        /* 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( nMatch("HEAT",chCARD_CAPS) )
                {
                        /* also print heating contributions */
                        prt.lgPrnHeat = true;
                }

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

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

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

                else if( nMatch("SORT",chCARD_CAPS) )
                {
                        /* >>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( nMatch("WAVE",chCARD_CAPS) )
                        {
                                /* 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( nMatch("RANG",chCARD_CAPS) )
                                {
                                        i = 5;
                                        prt.wlSort1 = (realnum)FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);
                                        /* line was entered, look for possible micron or cm label */
                                        if( chCARD_CAPS[i-1] == 'M' )
                                        {
                                                /* microns */
                                                prt.wlSort1 *= 1e4;
                                        }
                                        else if( chCARD_CAPS[i-1] == 'C' )
                                        {
                                                /* microns */
                                                prt.wlSort1 *= 1e8;
                                        }
                                        prt.wlSort2 = (realnum)FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);
                                        /* line was entered, look for possible micron or cm label */
                                        if( chCARD_CAPS[i-1] == 'M' )
                                        {
                                                /* microns */
                                                prt.wlSort2 *= 1e4;
                                        }
                                        else if( chCARD_CAPS[i-1] == 'C' )
                                        {
                                                /* microns */
                                                prt.wlSort2 *= 1e8;
                                        }
                                        if( 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( nMatch("INTE",chCARD_CAPS) )
                        {
                                /* 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( nMatch(" SUM",chCARD_CAPS) )
                {
                        /* option to read in set of lines to sum over */
                        sum = PrtLineSum( "READ" );
                        /* sum is not used anywhere, following makes lint shut up */
                        if( false ) fprintf(ioQQQ,"%.2e\n", sum);
                }

                else if( nMatch("SURF",chCARD_CAPS) && nMatch("BRIG",chCARD_CAPS) )
                {
                        /* print surface brightness rather than 4pi J */
                        prt.lgSurfaceBrightness = true;
                        /* default is per sr, arcsec option changes to sq arcsec */
                        if( nMatch("ARCS",chCARD_CAPS ) )
                        {
                                /* use sr */
                                prt.lgSurfaceBrightness_SR = false;
                        }
                        else
                        {
                                /* use sq arcsec */
                                prt.lgSurfaceBrightness_SR = 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( nMatch("MASE",chCARD_CAPS) )
        {
                prt.lgPrtMaser = true;
        }

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

                else if( nMatch("HEAD",chCARD_CAPS) )
                        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( nMatch("STAR",chCARD_CAPS) )
        {
                /* start printout at specified zone */
                called.lgTalk = false;
                prt.lgPrtStart = true;
                i = 5;
                prt.nstart = (long int)FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);
                if( 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( nMatch("CONT",chCARD_CAPS) )
        {
                /* >>chng 01 jun 30, logic of keys swapped around, so no keyword gets nFnu info */
                /* print continuum diffuse turns on nFnu continuum at many energies */
                if( nMatch("BLOC",chCARD_CAPS) )
                {
                        /* option to print emergent continuum at end of calculation*/
                        prt.lgPrtCont = true;
                }
                else if( nMatch("INDI" , chCARD_CAPS ))
                {
                        /* 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 */
                        i = 5;
                        /* 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)FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);
                        prt.lgPrtContIndices_hi_E = (realnum)FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);
                        /* if we hit end of line then use high-energy limit of code - that is,
                         * include all energies */
                        if( lgEOL )
                                prt.lgPrtContIndices_hi_E = (realnum)rfield.egamry;
                }
                else
                {
                        /* option to print continuum points within emission lines block */
                        prt.lgPrnDiff = true;
                }
        }

        else if( nMatch("COOL",chCARD_CAPS) )
        {
                /* print cooling array for a specified one */
                i = 5;
                prt.nzdump = (long int)FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);

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

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

        else if( nMatch(" ON ",chCARD_CAPS) )
        {
                /* on means turn on printout, lgTalkIsOK is set true in cdInit, but set
                 * false in dooptimize.  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 = true;
                }
        }

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

        else if( nMatch("EVER",chCARD_CAPS) )
        {
                /* print every nth zone */
                i = 5;
                num1 = (long int)FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);
                if( 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)FFmtRead(chCARD_CAPS,&i,INPUT_LINE_LENGTH,&lgEOL);
                        if( 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" );
                fprintf( ioQQQ, " %80.80s\n", chCARD_CAPS );
                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,"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,"\n\n\n");

        return;
}

---