Changeset 1806 for trunk/tsuite/programs/mpi/mpi.cpp

Timestamp:

02/19/08 19:49:00 (9 months ago)

Author:

peter

Message:

tsuite/programs/template.cpp:
tsuite/programs/readme_programs.htm:
tsuite/programs/readme_template.htm:

• Add template to start writing your own program that call Cloudy as a subroutine.
  

tsuite/programs/comp4/comp4.cpp:L
tsuite/programs/mpi/mpi.cpp:
tsuite/programs/hazy_kmt/hazy_kmt.cpp:
tsuite/programs/hazy_coolingcurve/hazy_coolingcurve.cpp:
tsuite/programs/vary_nete/vary_nete.cpp:
tsuite/programs/varyn/varyn.cpp:
tsuite/programs/hizlte/hizlte.cpp:
tsuite/programs/collion/collion.cpp:

• Add try-catch blocks.
  
• Convert exit() -> cdEXIT().
  
• Remove calls to puts().
  

Files:

• trunk/tsuite/programs/mpi/mpi.cpp (modified) (3 diffs)

trunk/tsuite/programs/mpi/mpi.cpp

@@ -4 +4 @@
 #include "cddefines.h"
 #include "cddrive.h"
+#include "version.h"
 
 /* This flag indicates where we are multi-processing.\
@@ -183 +184 @@
 int main( int argc, char *argv[] )
 {
-
-        int IntegerMod ,lgAbort;
-        int  myrank ;
-        double hden , absolute , relative , flux;
-        char chVer[10] , chPath[1000] , chFilename[1000] , chFile[2000] ;
-
-        double *xpar , *ypar, *par1, *par2;
-
-        /* following will become array of line wavelengths and the number of lines 
-         * in this array */
-        long int mod, nLines, LimModels, nModels;
-
-        /* these will be passed to cdGetLineList and will become arrays of
-         * labels and wavelengths */
-        char **chLabel ;
-        float *wl;
-
-        long int 
-         NumberWarnings1, NumberCautions1, NumberNotes1, NumberSurprises1, NumberTempFailures1,
-         NumberPresFailures1, NumberIonFailures1, NumberNeFailures1 ;
-        /* number of time Cloudy returned with error condition */
-        int nErrorExits;
-
-        FILE *ioOUT , *ioDATA ;
-        char chLine[100];
-
-        long int n;
-        /* number of processors, =1 for single non-MPI */
-        int numprocs = 1;
-
-        /* this will hold a single grid point */
-        GRIDTAG grid;
-
-        /* start MPI if -DMPI on command line */
-#       ifdef MPI
+        DEBUG_ENTRY( "main()" );
+
+        try {
+                bool lgAbort;
+                int IntegerMod;
+                int  myrank ;
+                double hden , absolute , relative , flux;
+                char chVer[10] , chPath[1000] , chFilename[1000] , chFile[2000] ;
+
+                double *xpar , *ypar, *par1, *par2;
+
+                /* following will become array of line wavelengths and the number of lines 
+                 * in this array */
+                long int mod, nLines, LimModels, nModels;
+
+                /* these will be passed to cdGetLineList and will become arrays of
+                 * labels and wavelengths */
+                char **chLabel ;
+                realnum *wl;
+
+                long int 
+                        NumberWarnings1, NumberCautions1, NumberNotes1, NumberSurprises1, NumberTempFailures1,
+                        NumberPresFailures1, NumberIonFailures1, NumberNeFailures1 ;
+                /* number of time Cloudy returned with error condition */
+                int nErrorExits;
+
+                FILE *ioOUT , *ioDATA ;
+                char chLine[100];
+
+                long int n;
+                /* number of processors, =1 for single non-MPI */
+                int numprocs = 1;
+
+                /* this will hold a single grid point */
+                GRIDTAG grid;
+
+                /* start MPI if -DMPI on command line */
+#               ifdef MPI
                 GRIDTAG gridtag;
                 GRIDTAG *grids;
@@ -228 +232 @@
 
                 Build_derived_type(gridtag, &message_type);
-#       else
+#               else
                 myrank = 0;
-#       endif
-
-        /* the following is the path for the directory where the output should appear,
-         * it needs to end with the OS standard directory delimiter, a "/" on unix */
-        strcpy( chPath , PATHNAME );
-
-        /* this is the first part of the name of the resulting data file.  The final
-         * file will have this name with a ".lin" after it. */
-        strcpy( chFilename , FILENAME );
-
-        /* ====================================================================== */
-        /*
-         * make arrays of parameters for this grid */
-
-        /* total number of models */
-        LimModels = (long)((FLUXLIMIT - FLUXINIT)/INCREMENT + 1.1);
-        LimModels *= (long)((HDENLIMIT - HDENINIT)/INCREMENT+1.1);
-        /* add number of processors since this is most we would possibly have to 
-         * add on to make integer number of mpi calls */
-        LimModels += numprocs;
-
-        xpar = (double*)malloc(LimModels*sizeof(double) );
-        ypar = (double*)malloc(LimModels*sizeof(double) );
-        par1 = (double*)malloc(LimModels*sizeof(double) );
-        par2 = (double*)malloc(LimModels*sizeof(double) );
-
-        if( xpar==NULL || ypar==NULL || par1==NULL || par2==NULL )
-        {
-                fprintf(stderr,"malloc failed\n");
-#               ifdef MPI 
-                MPI_Finalize(); 
 #               endif
-                exit(1);
-        }
-        /* now define set of parameters */
-        hden = HDENINIT;
-        flux = FLUXINIT;
-        nModels = 0;
-        nErrorExits = 0;
-#       ifdef MPI 
-        /* loop along constant U diagonals, starting from
-         * bottom right of loc plane, increasing density, 
-         * and ending on the major diagonal.
-         * this is for load leveling on parallel machines */
-        for( hden = HDENLIMIT; hden>= HDENINIT; hden-=INCREMENT )
-        {
-                for( flux=FLUXINIT; flux<=FLUXLIMIT;  flux+= INCREMENT )
-                {
-                        if( hden + (flux-FLUXINIT) > HDENLIMIT ) break;
-                        assert( nModels < LimModels );
-                        xpar[nModels] = hden + (flux-FLUXINIT);
-                        ypar[nModels] = flux;
-                        par1[nModels] = COLDEN;
-                        par2[nModels] = 0.;
-                        ++nModels;
-                }
-        }
-        /* loop increasing flux, starting at lower left plus increment */
-        for( flux=FLUXINIT+INCREMENT; flux<=FLUXLIMIT;  flux+= INCREMENT )
-        {
-                for( hden = HDENINIT; hden<= HDENLIMIT;  hden+=INCREMENT )
-                {
-                        if( flux + (hden-HDENINIT) > FLUXLIMIT ) break;
-                        assert( nModels < LimModels );
-                        xpar[nModels] = hden ;
-                        ypar[nModels] = flux + (hden-HDENINIT);
-                        par1[nModels] = COLDEN;
-                        par2[nModels] = 0.;
-                        ++nModels;
-                }
-        }
-#       else
-        /* on scalar machines do models in xy order */
-        while( hden < 1.00001 * HDENLIMIT )
-        {
-                while( flux < 1.00001*FLUXLIMIT )
-                {
-                        xpar[nModels] = hden;
-                        ypar[nModels] = flux;
-                        par1[nModels] = COLDEN;
-                        par2[nModels] = 0.;
-                        ++nModels;
-                        flux += INCREMENT;
-                }
-                flux = FLUXINIT;
-                hden += INCREMENT;
-        }
-#       endif
-        /* increase total number to an integer multiple of number of processors */
-        if( nModels%numprocs)
-        {
-                /* add extra bit */
-                IntegerMod = nModels + (numprocs - nModels%numprocs);
-        }
-        else
-        {
-                IntegerMod = nModels;
-        }
-
-        /* make up data for the "extra" models */
-        for( mod=nModels; mod<IntegerMod; ++mod)
-        {
-                xpar[mod] = xpar[0];
-                ypar[mod] = ypar[0];
-                par1[mod] = par1[0];
-                par2[mod] = par2[0];
-        }
-
-        /* ====================================================================== */
-
-#       ifdef MPI
-        /* allocate memory for grids */ 
-        if( (grids = ((GRIDTAG *)malloc( (size_t)(numprocs)*sizeof(GRIDTAG )))) == NULL )
-        {
-                fprintf(stderr," main could not malloc grid\n");
-                puts( "[Stop in main]" );
-#               ifdef MPI 
-                MPI_Finalize(); 
-#               endif
-                exit(1);
-        }
-#       endif
-
-        /* initialize the code so that cdGetLineList can be called */
-        cdInit();
-        /* get list of lines from standard data file.  With no arguments this reads
-         * the file BLRLineList, part of the standard data distribution.  There could
-         * have been another file name within the quotes - that file would have been
-         * used instead */
-        nLines = cdGetLineList("" , &chLabel , &wl);
-        /*nLines = cdGetLineList("NLRLineList.dat" , &chLabel , &wl);*/
-
-        /* now copy version into string to print */
-        cdVersion(chVer);
-
-        /* open file for large output if this is desired */
-        if( DO_PRINT )
-        {
-                /* now create final filename */
-                strcpy( chFile , chPath );
-                strcat( chFile , chFilename );
-                strcat( chFile , ".out" );
-                ioOUT = fopen(chFile,"w");
-                if( ioOUT == NULL )
-                {
-                        printf(" main could not open %s for writing.\n", chFile);
+
+                /* the following is the path for the directory where the output should appear,
+                 * it needs to end with the OS standard directory delimiter, a "/" on unix */
+                strcpy( chPath , PATHNAME );
+
+                /* this is the first part of the name of the resulting data file.  The final
+                 * file will have this name with a ".lin" after it. */
+                strcpy( chFilename , FILENAME );
+
+                /* ====================================================================== */
+                /*
+                 * make arrays of parameters for this grid */
+
+                /* total number of models */
+                LimModels = (long)((FLUXLIMIT - FLUXINIT)/INCREMENT + 1.1);
+                LimModels *= (long)((HDENLIMIT - HDENINIT)/INCREMENT+1.1);
+                /* add number of processors since this is most we would possibly have to 
+                 * add on to make integer number of mpi calls */
+                LimModels += numprocs;
+
+                xpar = (double*)malloc(LimModels*sizeof(double) );
+                ypar = (double*)malloc(LimModels*sizeof(double) );
+                par1 = (double*)malloc(LimModels*sizeof(double) );
+                par2 = (double*)malloc(LimModels*sizeof(double) );
+
+                if( xpar==NULL || ypar==NULL || par1==NULL || par2==NULL )
+                {
+                        fprintf(stderr,"malloc failed\n");
 #                       ifdef MPI 
                         MPI_Finalize(); 
 #                       endif
-                        exit(1);
-                }
-        }
-        else
-        {
-                /* there should be nothing coming here, but something might */
-                ioOUT = stderr;
-        }
-
-        /* calculation's results, all the lines in file ending .lin */
-        strcpy( chFile , chPath );
-        strcat( chFile , chFilename );
-        strcat( chFile , ".lin" );
-        ioDATA = fopen(chFile,"w");
-        if( ioDATA == NULL )
-        {
-                printf(" could not open %s for writing.\n" , chFile );
+                        cdEXIT(EXIT_FAILURE);
+                }
+                /* now define set of parameters */
+                hden = HDENINIT;
+                flux = FLUXINIT;
+                nModels = 0;
+                nErrorExits = 0;
 #               ifdef MPI 
-                MPI_Finalize(); 
+                /* loop along constant U diagonals, starting from
+                 * bottom right of loc plane, increasing density, 
+                 * and ending on the major diagonal.
+                 * this is for load leveling on parallel machines */
+                for( hden = HDENLIMIT; hden>= HDENINIT; hden-=INCREMENT )
+                {
+                        for( flux=FLUXINIT; flux<=FLUXLIMIT;  flux+= INCREMENT )
+                        {
+                                if( hden + (flux-FLUXINIT) > HDENLIMIT ) break;
+                                assert( nModels < LimModels );
+                                xpar[nModels] = hden + (flux-FLUXINIT);
+                                ypar[nModels] = flux;
+                                par1[nModels] = COLDEN;
+                                par2[nModels] = 0.;
+                                ++nModels;
+                        }
+                }
+                /* loop increasing flux, starting at lower left plus increment */
+                for( flux=FLUXINIT+INCREMENT; flux<=FLUXLIMIT;  flux+= INCREMENT )
+                {
+                        for( hden = HDENINIT; hden<= HDENLIMIT;  hden+=INCREMENT )
+                        {
+                                if( flux + (hden-HDENINIT) > FLUXLIMIT ) break;
+                                assert( nModels < LimModels );
+                                xpar[nModels] = hden ;
+                                ypar[nModels] = flux + (hden-HDENINIT);
+                                par1[nModels] = COLDEN;
+                                par2[nModels] = 0.;
+                                ++nModels;
+                        }
+                }
+#               else
+                /* on scalar machines do models in xy order */
+                while( hden < 1.00001 * HDENLIMIT )
+                {
+                        while( flux < 1.00001*FLUXLIMIT )
+                        {
+                                xpar[nModels] = hden;
+                                ypar[nModels] = flux;
+                                par1[nModels] = COLDEN;
+                                par2[nModels] = 0.;
+                                ++nModels;
+                                flux += INCREMENT;
+                        }
+                        flux = FLUXINIT;
+                        hden += INCREMENT;
+                }
 #               endif
-                exit(1);
-        }
-
-        /* print the header information before we begin the calculation */
-        /* print version number on both headers */
-        fprintf(ioDATA,"Cloudy version %s, %s\n",chVer,TITLE);
-
-        for( mod=myrank; mod<IntegerMod; mod+=numprocs )
-        {
-                hden = xpar[mod];
-                flux = ypar[mod];
-                /* zero out grid, which will hold all info for a single grid point */
-                memset(&grid, 0, sizeof(GRIDTAG));
-
-                /* initialize the code for this run */
+                /* increase total number to an integer multiple of number of processors */
+                if( nModels%numprocs)
+                {
+                        /* add extra bit */
+                        IntegerMod = nModels + (numprocs - nModels%numprocs);
+                }
+                else
+                {
+                        IntegerMod = nModels;
+                }
+
+                /* make up data for the "extra" models */
+                for( mod=nModels; mod<IntegerMod; ++mod)
+                {
+                        xpar[mod] = xpar[0];
+                        ypar[mod] = ypar[0];
+                        par1[mod] = par1[0];
+                        par2[mod] = par2[0];
+                }
+
+                /* ====================================================================== */
+
+#               ifdef MPI
+                /* allocate memory for grids */ 
+                if( (grids = ((GRIDTAG *)malloc( (size_t)(numprocs)*sizeof(GRIDTAG )))) == NULL )
+                {
+                        fprintf(stderr," main could not malloc grid\n");
+#                       ifdef MPI 
+                        MPI_Finalize(); 
+#                       endif
+                        cdEXIT(EXIT_FAILURE);
+                }
+#               endif
+
+                /* initialize the code so that cdGetLineList can be called */
                 cdInit();
-
-                /* direct the standard output to this file */
-                cdOutp(ioOUT);
-
-                /* send flag saying whether to create large output */
-                cdTalk( DO_PRINT );
-
-                /* title for grid */
-                sprintf(chLine,"title %s", TITLE);
-                n = cdRead( chLine  );
-
-                /* print only last iteration? */
-#               if PRINT_LAST
-                n = cdRead("print last iteration ");
-#               endif
-
-                /* option for fast model, or only header */
-#               if QUICK_MODEL
-                        n = cdRead( "stop zone 3 "  );/**/
-                        n = cdRead( "constant temper 4 "  );/**/
-#               endif
-#               if VERY_QUICK_MODEL
-                        cdNoExec();
-#               endif
-
-                /* iterate if not fast model */
-#               if ( (!QUICK_MODEL) && (!VERY_QUICK_MODEL) &&(ITERATIONS!=0) )
-#                       if ITERATIONS < 0
-                                n = cdRead( "iterate convergence "  );/**/
-#                       else 
-                                sprintf(chLine,"iterate %i", ITERATIONS);
-                                n = cdRead( chLine  );
-#                       endif
-#               endif
-
-#               ifdef MPI 
-                        /* set flag so that exit handler will call MPI_Finalize */
-                        cdMPI();
-#               endif
-
-                /* option to turn off file buffering if code might crash */
-#               ifdef NO_BUFFERING
-                        n = cdRead("no buffering ");
-#               endif
-
-                /* if we have run off end of array of models say not to execute,
-                 * still must do something on this processor so that the gather can occur
-                 * at the bottom of the loop */
-                if( mod >= nModels )
-                        cdNoExec();
-
-                /* flux and density */
-                sprintf(chLine,"phi(h) %f", flux);
-                n = cdRead( chLine  );
-
-                sprintf(chLine,"hden %f", hden);
-                n = cdRead( chLine  );
-
-                /* turn on large FeII atom, VERY slow */
-#               if FEII
-                n = cdRead( "atom feii  "  );
-#               endif
-
-                /* this is the continuum we used in the large apjs paper */
-                n = cdRead( "agn 6.00 -1.40 -0.50 -1.0  "  );/**/
-
-                /* a bare powerlaw with a break at 1 microns */
-                /*n = cdRead( "table powerlaw -1.0 1 micron break "  );*/
-
-                /* the much maligned Mathews&Ferland continuum */
-                /*n = cdRead( "table agn  "  );*/
-
-                /*n = cdRead( "blackbody 142,000  "  );*/
-
-                /* broken power law used in Fred's paper */
-                /*n = cdRead( "interpolate (0.00000001, -14.899), (0.0091126732, 0.000)  "  );
-                n = cdRead( "continue (1.00, -1.2242), (73.54, -4.2106)  "  );
-                n = cdRead( "continue (3675, -5.7395), (7354000, -11.2526)  "  );*/
-
-                /* broken power law used in Mark's paper */
-                /*n = cdRead( "interpolate (10.517, -30.850) (13.383, -23.684)   "  );
-                n = cdRead( "continue (16.684, -26.986) (17.383, -27.9996)    "  );
-                n = cdRead( "continue (18.383, -28.8899) (19.124, -29.268)    "  );
-                n = cdRead( "continue (22.383, -35.788)  "  );*/
-
-                /* add cosmic IR background as well */
-                n = cdRead( "background z=0  "  );
-
-                sprintf(chLine,"stop column density %f ", par1[mod]);
-                n = cdRead( chLine  );/**/
-
-                n = cdRead( "failures 3 "  );
-
-                /* options to change abundances */
-#               if 0
-                n = cdRead( "metals 10 "  );/**/
-                n = cdRead( "element nitrogen scale 10 "  );/**/
-                n = cdRead( "element helium scale 1.66 "  );/**/
-                n = cdRead( "metals 20 "  );/**/
-                n = cdRead( "element nitrogen scale 20 "  );/**/
-                n = cdRead( "element helium scale 2.41 "  );/**/
-#               endif
-
-                /*sprintf(chLine,"turbulence %f km/sec", vturb);
-                n = cdRead( chLine  );*/
-
-                /* all line intensities will be relative to incident continuum near Lya */
-                n = cdRead( "normalize to label \"inci\" 1215 "  );
-
-                /* actually call the code, 1 indicates error exit 
-                 * but this could be warning or abort */
-                grid.lgBadEnd = cdDrive();
-                nErrorExits += grid.lgBadEnd;
-
-                /* print header information for very first model only */
-                if( mod==0 )
-                {
-                        if( (nLines+nFeIIBands+nFeIIConBins) > NLINTOT )
-                        {
-                                fprintf( stderr , "there are too many lines - increase NLINTOT ");
-                                printf(  "there are too many lines - increase NLINTOT ");
+                /* get list of lines from standard data file.  With no arguments this reads
+                 * the file BLRLineList, part of the standard data distribution.  There could
+                 * have been another file name within the quotes - that file would have been
+                 * used instead */
+                nLines = cdGetLineList("" , &chLabel , &wl);
+                /*nLines = cdGetLineList("NLRLineList.dat" , &chLabel , &wl);*/
+
+                /* now copy version into string to print */
+                version.chVersion = "c00.00";
+                cdVersion(chVer);
+
+                /* open file for large output if this is desired */
+                if( DO_PRINT )
+                {
+                        /* now create final filename */
+                        strcpy( chFile , chPath );
+                        strcat( chFile , chFilename );
+                        strcat( chFile , ".out" );
+                        ioOUT = fopen(chFile,"w");
+                        if( ioOUT == NULL )
+                        {
+                                printf(" main could not open %s for writing.\n", chFile);
 #                               ifdef MPI 
                                 MPI_Finalize(); 
 #                               endif
-                                exit(1);
-                        }
-
-                        /* for very first model (mod==0) send input stream to data file, followed
-                         * by keyword showing end and finally set of tables */
-                        cdPrintCommands( ioDATA );
-
-                        /* all the printout happens here */
-                        /* print header for the data file */
-                        fprintf(ioDATA,"abort\twarn\tExecT\tdensity\tflux\tcolden\tpar2\t");
+                                cdEXIT(EXIT_FAILURE);
+                        }
+                }
+                else
+                {
+                        /* there should be nothing coming here, but something might */
+                        ioOUT = stderr;
+                }
+
+                /* calculation's results, all the lines in file ending .lin */
+                strcpy( chFile , chPath );
+                strcat( chFile , chFilename );
+                strcat( chFile , ".lin" );
+                ioDATA = fopen(chFile,"w");
+                if( ioDATA == NULL )
+                {
+                        printf(" could not open %s for writing.\n" , chFile );
+#                       ifdef MPI 
+                        MPI_Finalize(); 
+#                       endif
+                        cdEXIT(EXIT_FAILURE);
+                }
+
+                /* print the header information before we begin the calculation */
+                /* print version number on both headers */
+                fprintf(ioDATA,"Cloudy version %s, %s\n",chVer,TITLE);
+
+                for( mod=myrank; mod<IntegerMod; mod+=numprocs )
+                {
+                        hden = xpar[mod];
+                        flux = ypar[mod];
+                        /* zero out grid, which will hold all info for a single grid point */
+                        memset(&grid, 0, sizeof(GRIDTAG));
+
+                        /* initialize the code for this run */
+                        cdInit();
+
+                        /* direct the standard output to this file */
+                        cdOutp(ioOUT);
+
+                        /* send flag saying whether to create large output */
+                        cdTalk( DO_PRINT );
+
+                        /* title for grid */
+                        sprintf(chLine,"title %s", TITLE);
+                        n = cdRead( chLine  );
+
+                        /* print only last iteration? */
+#                       if PRINT_LAST
+                        n = cdRead("print last iteration ");
+#                       endif
+
+                        /* option for fast model, or only header */
+#                       if QUICK_MODEL
+                        n = cdRead( "stop zone 3 "  );/**/
+                        n = cdRead( "constant temper 4 "  );/**/
+#                       endif
+#                       if VERY_QUICK_MODEL
+                        cdNoExec();
+#                       endif
+
+                        /* iterate if not fast model */
+#                       if ( (!QUICK_MODEL) && (!VERY_QUICK_MODEL) &&(ITERATIONS!=0) )
+#                       if ITERATIONS < 0
+                        n = cdRead( "iterate convergence "  );/**/
+#                       else 
+                        sprintf(chLine,"iterate %i", ITERATIONS);
+                        n = cdRead( chLine  );
+#                       endif
+#                       endif
+
+#                       ifdef MPI 
+                        /* set flag so that exit handler will call MPI_Finalize */
+                        cdMPI();
+#                       endif
+
+                        /* option to turn off file buffering if code might crash */
+#                       ifdef NO_BUFFERING
+                        n = cdRead("no buffering ");
+#                       endif
+
+                        /* if we have run off end of array of models say not to execute,
+                         * still must do something on this processor so that the gather can occur
+                         * at the bottom of the loop */
+