Index: source/cont_createmesh.cpp
===================================================================
--- source/cont_createmesh.cpp	(revision 14356)
+++ source/cont_createmesh.cpp	(working copy)
@@ -326,14 +326,14 @@
 		/*>>chng 06 aug 15, this is now 2D array, saving diffuse continuum
 		* over all zones for use in exact RT */
 		/*memset(&rfield.ConEmitLocal[lo]       , 0 , n*sizeof(realnum) );*/
-		memset(&rfield.ConEmitReflec[0][lo]     , 0 , n*sizeof(realnum) );
-		memset(&rfield.ConEmitOut[0][lo]        , 0 , n*sizeof(realnum) );
-		memset(&rfield.reflin[0][lo]            , 0 , n*sizeof(realnum) );
-		memset(&rfield.ConRefIncid[0][lo]       , 0 , n*sizeof(realnum) );
+		memset(&rfield.ConEmitReflec[0][lo]     , 0 , n*sizeof(double) );
+		memset(&rfield.ConEmitOut[0][lo]        , 0 , n*sizeof(double) );
+		memset(&rfield.reflin[0][lo]            , 0 , n*sizeof(double) );
+		memset(&rfield.ConRefIncid[0][lo]       , 0 , n*sizeof(double) );
 		memset(&rfield.SummedCon[lo]            , 0 , n*sizeof(double) );
 		memset(&rfield.convoc[lo]               , 0 , n*sizeof(realnum) );
-		memset(&rfield.flux[0][lo]              , 0 , n*sizeof(realnum) );
-		memset(&rfield.flux_total_incident[0][lo], 0 , n*sizeof(realnum) );
+		memset(&rfield.flux[0][lo]              , 0 , n*sizeof(double) );
+		memset(&rfield.flux_total_incident[0][lo], 0 , n*sizeof(double) );
 		memset(&rfield.flux_beam_const_save[lo] , 0 , n*sizeof(realnum) );
 		memset(&rfield.flux_time_beam_save[lo]  , 0 , n*sizeof(realnum) );
 		memset(&rfield.flux_isotropic_save[lo]  , 0 , n*sizeof(realnum) );
@@ -343,7 +343,7 @@
 		memset(&rfield.otslin[lo]               , 0 , n*sizeof(realnum) );
 		memset(&rfield.otscon[lo]               , 0 , n*sizeof(realnum) );
 		memset(&rfield.ConInterOut[lo]          , 0 , n*sizeof(realnum) );
-		memset(&rfield.outlin[0][lo]            , 0 , n*sizeof(realnum) );
+		memset(&rfield.outlin[0][lo]            , 0 , n*sizeof(double) );
 		memset(&rfield.outlin_noplot[lo]        , 0 , n*sizeof(realnum) );
 		memset(&rfield.ConOTS_local_OTS_rate[lo], 0 , n*sizeof(realnum) );
 		memset(&rfield.ConOTS_local_photons[lo] , 0 , n*sizeof(realnum) );
Index: source/cont_setintensity.cpp
===================================================================
--- source/cont_setintensity.cpp	(revision 14356)
+++ source/cont_setintensity.cpp	(working copy)
@@ -165,7 +165,7 @@
 			cdEXIT(EXIT_FAILURE);
 		}
 
-		rfield.flux[0][i] = (realnum)(flux*rfield.widflx(i));
+		rfield.flux[0][i] = flux*rfield.widflx(i);
 
 		/* save separation into isotropic constant and beamed, and possibly 
 		 * time-variable beamed continua */
@@ -216,7 +216,7 @@
 
 	for( i=iso_sp[ipH_LIKE][ipHYDROGEN].fb[ipH1s].ipIsoLevNIonCon-1; i < rfield.nflux_with_check; i++ )
 	{
-		if( rfield.flux[0][i]*rfield.anu(i)/rfield.widflx(i) > (realnum)peak )
+		if( rfield.flux[0][i]*rfield.anu(i)/rfield.widflx(i) > peak )
 		{
 			/* prt.ipeak points to largest f_nu at H-ionizing energies
 			 * and is passed to other parts of code */
@@ -511,7 +511,7 @@
 	for( i=0; i < rfield.nflux_with_check; i++ )
 	{
 		/* set up occupation number array */
-		rfield.OccNumbIncidCont[i] = rfield.flux[0][i]*rfield.convoc[i];
+		rfield.OccNumbIncidCont[i] = realnum(rfield.flux[0][i])*rfield.convoc[i];
 		if( rfield.OccNumbIncidCont[i] > rfield.occmax )
 		{
 			rfield.occmax = rfield.OccNumbIncidCont[i];
@@ -1047,7 +1047,7 @@
 	for( i=il-1; i < iupper; i++ )
 	{
 		/* sum photon number */
-		*q += rfield.flux[0][i];
+		*q += realnum(rfield.flux[0][i]);
 		/* en1ryd is needed to stop overflow */
 		/* sum flux */
 		*p += (realnum)(rfield.flux[0][i]*(rfield.anu(i)*EN1RYD));
Index: source/grains.cpp
===================================================================
--- source/grains.cpp	(revision 14356)
+++ source/grains.cpp	(working copy)
@@ -4596,7 +4596,7 @@
 
 	DEBUG_ENTRY( "GrainDrift()" );
 
-	vector<realnum> help( rfield.nPositive );
+	vector<double> help( rfield.nPositive );
 	for( i=0; i < rfield.nPositive; i++ )
 	{
 		help[i] = (rfield.flux[0][i]+rfield.ConInterOut[i]+rfield.outlin[0][i]+rfield.outlin_noplot[i])*
Index: source/iter_startend.cpp
===================================================================
--- source/iter_startend.cpp	(revision 14356)
+++ source/iter_startend.cpp	(working copy)
@@ -1137,13 +1137,13 @@
 		for( long n=0; n<rfield.nflux; ++n)
 		{
 			
-			rfield.flux[1][n] += (realnum) rfield.flux[0][n]*cumulative_factor;
-			rfield.ConEmitReflec[1][n] += (realnum) rfield.ConEmitReflec[0][n]*cumulative_factor;
-			rfield.ConEmitOut[1][n] += (realnum) rfield.ConEmitOut[0][n]*cumulative_factor;
-			rfield.ConRefIncid[1][n] += (realnum) rfield.ConRefIncid[0][n]*cumulative_factor;
-			rfield.flux_total_incident[1][n] += (realnum) rfield.flux_total_incident[0][n]*cumulative_factor;
-			rfield.reflin[1][n] += (realnum) rfield.reflin[0][n]*cumulative_factor;
-			rfield.outlin[1][n] += (realnum) rfield.outlin[0][n]*cumulative_factor;
+			rfield.flux[1][n] += rfield.flux[0][n]*cumulative_factor;
+			rfield.ConEmitReflec[1][n] += rfield.ConEmitReflec[0][n]*cumulative_factor;
+			rfield.ConEmitOut[1][n] += rfield.ConEmitOut[0][n]*cumulative_factor;
+			rfield.ConRefIncid[1][n] += rfield.ConRefIncid[0][n]*cumulative_factor;
+			rfield.flux_total_incident[1][n] += rfield.flux_total_incident[0][n]*cumulative_factor;
+			rfield.reflin[1][n] += rfield.reflin[0][n]*cumulative_factor;
+			rfield.outlin[1][n] += rfield.outlin[0][n]*cumulative_factor;
 		}
 	}
 	
@@ -1178,7 +1178,7 @@
 		if( (realnum)(fac/SDIV(rfield.ConInterOut[i]))>SMALLFLOAT && fac > SMALLFLOAT )
 		{
 			rfield.ConInterOut[i] /= (realnum)fac;
-			rfield.outlin[0][i] /= (realnum)fac;
+			rfield.outlin[0][i] /= fac;
 			rfield.outlin_noplot[i] /= (realnum)fac;
 		}
 	}
Index: source/lines_service.cpp
===================================================================
--- source/lines_service.cpp	(revision 14356)
+++ source/lines_service.cpp	(working copy)
@@ -534,23 +534,23 @@
 
 		/* the reflected part */
 		rfield.reflin[0][ip] +=
-			(realnum)(inwd*phots*radius.BeamInIn);
+			inwd*phots*radius.BeamInIn;
 		
 		/* inward beam that goes out since sphere set */
 		rfield.outlin[0][ip] +=
-			(realnum)(inwd*phots*radius.BeamInOut*opac.tmn[ip]*nonScatteredFraction);
+			double(inwd*phots*radius.BeamInOut*opac.tmn[ip]*nonScatteredFraction);
 		
 		/* outward part */
 		rfield.outlin[0][ip] +=
-			(realnum)((1.-inwd)*phots*radius.BeamOutOut*opac.tmn[ip]*nonScatteredFraction);
+			double((1.-inwd)*phots*radius.BeamOutOut*opac.tmn[ip]*nonScatteredFraction);
 	}
 	else
 	{
 		rfield.reflin[0][ip] +=
-			(realnum)(phots*radius.dVolReflec);
+			phots*radius.dVolReflec;
 
 		rfield.outlin[0][ip] +=
-			(realnum)(phots*radius.dVolOutwrd*opac.ExpZone[ip]);
+			phots*radius.dVolOutwrd*opac.ExpZone[ip];
 	}
 }
 
Index: source/mole_h2.cpp
===================================================================
--- source/mole_h2.cpp	(revision 14356)
+++ source/mole_h2.cpp	(working copy)
@@ -1763,8 +1763,8 @@
 		long ip_H2_level = ipoint( 1.07896 - 2.5 / EVRYD);
 		for( long i= ip_H2_level; i < ip_cut_off; ++i )
 		{
-			flux_accum_photodissoc_BigH2_H2s += ( rfield.flux[0][i-1] + rfield.ConInterOut[i-1]+ 
-				rfield.outlin[0][i-1]+ rfield.outlin_noplot[i-1]  );
+			flux_accum_photodissoc_BigH2_H2s += rfield.flux[0][i-1] + rfield.ConInterOut[i-1]+ 
+				rfield.outlin[0][i-1]+ rfield.outlin_noplot[i-1];
 		}
 
 		/* sum over all levels to obtain s and g populations and dissociation rates */
@@ -1810,8 +1810,8 @@
 
 				for( long i= ip_H2_level; i < ip_cut_off; ++i )
 				{
-					flux_accum_photodissoc_BigH2_H2g += ( rfield.flux[0][i-1] + rfield.ConInterOut[i-1]+ 
-						rfield.outlin[0][i-1]+ rfield.outlin_noplot[i-1] );
+					flux_accum_photodissoc_BigH2_H2g += rfield.flux[0][i-1] + rfield.ConInterOut[i-1]+ 
+						rfield.outlin[0][i-1]+ rfield.outlin_noplot[i-1];
 				}
 
 				photodissoc_BigH2_H2g += pop * flux_accum_photodissoc_BigH2_H2g;
Index: source/rfield.cpp
===================================================================
--- source/rfield.cpp	(revision 14356)
+++ source/rfield.cpp	(working copy)
@@ -114,7 +114,7 @@
 	if( iflux < 0 || iflux >= rfield.nflux )
 		return  0.;
 
-	double this_flux = (double)rfield.flux[ nEmType ][ iflux ];
+	double this_flux = rfield.flux[ nEmType ][ iflux ];
 	if( nEmType == 0 &&
 	    ( ! continuum.lgPrtIsotropicCont || ! lgSaveIsotr ) )
 	{
Index: source/rfield.h
===================================================================
--- source/rfield.h	(revision 14356)
+++ source/rfield.h	(working copy)
@@ -66,7 +66,7 @@
 	/** the following are the arrays containing the local radiation field */
 
 	/**flux is photons per cell N.B. width of cells vary with energy, given by widflx */
-	vector<realnum> flux[2];
+	vector<double> flux[2];
 
 	/** this is the isotropic part of the constant continuum */
 	vector<realnum> flux_isotropic;
@@ -143,19 +143,19 @@
 	multi_arr<realnum,2> ConSourceFcnLocal/* [depth][energy]*/;
 
 	/** reflected diffuse emission continuum */
-	vector<realnum> ConEmitReflec[2];
+	vector<double> ConEmitReflec[2];
 
 	/** outward diffuse emission continuum (not the interactive one),
 	 * this is incremented in radinc because of interplay between absorption
 	 * and emission - get the outward bremsstrahlung right 
 	 * photons cell-1 cm-2 s-1 */
-	vector<realnum> ConEmitOut[2];
+	vector<double> ConEmitOut[2];
 
 	/** this is set in RT_diffuse and carries interactive continua */
 	vector<realnum> ConInterOut;
 
 	/** ConRefIncid is reflected portion of incident continuum */
-	vector<realnum> ConRefIncid[2];
+	vector<double> ConRefIncid[2];
 
 	/** these are energy-by-energy sums of various arrays, used to save time in
 	 * evaluating rate integrals */
@@ -186,7 +186,7 @@
 	multi_arr<realnum,2> otssav;
 
 	/** outward directed line emission photons cm-2 s-1 */
-	vector<realnum> outlin[2];
+	vector<double> outlin[2];
 	vector<realnum> outlin_noplot;
 
 	/** local diffuse line emission, photons cm-3 s-1 */
@@ -193,10 +193,10 @@
 	vector<realnum> DiffuseLineEmission;
 
 	/** reflected line */
-	vector<realnum> reflin[2];
+	vector<double> reflin[2];
 
 	/** save incident continuum for later iterations */
-	vector<realnum> flux_total_incident[2];
+	vector<double> flux_total_incident[2];
 	vector<realnum> flux_beam_const_save, flux_time_beam_save, flux_isotropic_save;
 
 	/** ==1 for time steady, when continuum varies with time, is scale factor */
Index: source/rt_continuum.cpp
===================================================================
--- source/rt_continuum.cpp	(revision 14356)
+++ source/rt_continuum.cpp	(working copy)
@@ -225,7 +225,7 @@
 		rfield.SummedOcc[i] = rfield.SummedCon[i]*rfield.convoc[i];
 
 		// outward lines and diffuse continua 
-		rfield.outlin[0][i] *= (realnum)AttenuationDilutionFactor;
+		rfield.outlin[0][i] *= AttenuationDilutionFactor;
 		rfield.outlin_noplot[i] *= (realnum)AttenuationDilutionFactor;
 
 		// interactive outward diffuse continuum
@@ -238,17 +238,17 @@
 		rfield.ConInterOut[i] *= (realnum)AttenuationDilutionFactor;
 
 		// this is not the interacting continuum 
-		rfield.ConEmitOut[0][i] *= (realnum)AttenuationDilutionFactor;
+		rfield.ConEmitOut[0][i] *= AttenuationDilutionFactor;
 		rfield.ConEmitOut[0][i] += rfield.ConEmitLocal[nzone][i]*(realnum)radius.dVolOutwrd*opac.tmn[i]/**/;
 
 		// set occupation numbers, first attenuated incident continuum 
-		rfield.OccNumbIncidCont[i] = rfield.flux[0][i]*rfield.convoc[i];
+		rfield.OccNumbIncidCont[i] = realnum( rfield.flux[0][i]*rfield.convoc[i] );
 
 		// local diffuse continua 
 		rfield.OccNumbDiffCont[i] = rfield.ConEmitLocal[nzone][i]*rfield.convoc[i];
 
 		// outward diffuse continuum 
-		rfield.OccNumbContEmitOut[i] = rfield.ConEmitOut[0][i]*rfield.convoc[i];
+		rfield.OccNumbContEmitOut[i] = realnum( rfield.ConEmitOut[0][i]*rfield.convoc[i] );
 
 		// integrated energy flux, ergs s^-1 cm^-2 
 		rfield.EnergyIncidCont += rfield.flux[0][i]*rfield.anu(i);
@@ -278,9 +278,9 @@
 		* to log.  defended two ways - above checks that ratio of fluxes is large enough, 
 		* and here convert to double.
 		* error found by Peter van Hoof */
-		double tau_effec = -log((double)rfield.flux[0][iso_sp[ipH_LIKE][ipHYDROGEN].fb[0].ipIsoLevNIonCon-1]/
+		double tau_effec = -log(rfield.flux[0][iso_sp[ipH_LIKE][ipHYDROGEN].fb[0].ipIsoLevNIonCon-1]/
 			(double)opac.tmn[iso_sp[ipH_LIKE][ipHYDROGEN].fb[0].ipIsoLevNIonCon-1]/
-			(double)rfield.flux_total_incident[0][iso_sp[ipH_LIKE][ipHYDROGEN].fb[0].ipIsoLevNIonCon-1]);
+			rfield.flux_total_incident[0][iso_sp[ipH_LIKE][ipHYDROGEN].fb[0].ipIsoLevNIonCon-1]);
 
 		// this is computed absorption optical depth to illuminated face
 		double tau_true = opac.TauAbsFace[iso_sp[ipH_LIKE][ipHYDROGEN].fb[0].ipIsoLevNIonCon-1]*geometry.DirectionalCosin;
@@ -320,8 +320,8 @@
 				rfield.flux_isotropic[i];
 
 			rfield.ConInterOut[i] *= (realnum)AttenuationScatteringFactor;
-			rfield.ConEmitOut[0][i] *= (realnum)AttenuationScatteringFactor;
-			rfield.outlin[0][i] *= (realnum)AttenuationScatteringFactor;
+			rfield.ConEmitOut[0][i] *= AttenuationScatteringFactor;
+			rfield.outlin[0][i] *= AttenuationScatteringFactor;
 			rfield.outlin_noplot[i] *= (realnum)AttenuationScatteringFactor;
 		}
 	}
@@ -377,15 +377,15 @@
 					radius.drad_x_fillfac * opac.E2TauAbsFace[i]*radius.r1r0sq;
 
 				// ConEmitReflec - reflected diffuse continuum
-				rfield.ConEmitReflec[0][i] += (realnum)(Reflec_Diffuse_Cont);
+				rfield.ConEmitReflec[0][i] += Reflec_Diffuse_Cont;
 
 				// the reflected part of the incident continuum
-				rfield.ConRefIncid[0][i] += (realnum)(rfield.flux[0][i]*opac.opacity_sct[i]*
-					radius.drad_x_fillfac*opac.E2TauAbsFace[i]*radius.r1r0sq);
+				rfield.ConRefIncid[0][i] += rfield.flux[0][i]*opac.opacity_sct[i]*
+					radius.drad_x_fillfac*opac.E2TauAbsFace[i]*radius.r1r0sq;
 
 				// reflected line emission 
-				rfield.reflin[0][i] += (realnum)(rfield.outlin[0][i]*opac.opacity_sct[i]*
-					radius.drad_x_fillfac*opac.E2TauAbsFace[i]*radius.r1r0sq);
+				rfield.reflin[0][i] += rfield.outlin[0][i]*opac.opacity_sct[i]*
+					radius.drad_x_fillfac*opac.E2TauAbsFace[i]*radius.r1r0sq;
 			}
 		}
 	}
Index: source/save_do.cpp
===================================================================
--- source/save_do.cpp	(revision 14356)
+++ source/save_do.cpp	(working copy)
@@ -101,7 +101,7 @@
 	switch( ct )
 	{
 	case CT_INCI:
-		val = double(rfield.flux_total_incident[nEmType][j])*factor*radius.PI4_rinner_sq;
+		val = rfield.flux_total_incident[nEmType][j]*factor*radius.PI4_rinner_sq;
 		break;
 	case CT_OUTW_INCI:
 		ASSERT( trans_coef_total != NULL );
@@ -977,7 +977,7 @@
 							rfield.anu(j)/rfield.widflx(j) : save.Resolution;
 
 						/* reflected continuum */
-						double flxref = rfield.anu2(j)*((double)rfield.ConRefIncid[0][j]+rfield.ConEmitReflec[0][j])/
+						double flxref = rfield.anu2(j)*(rfield.ConRefIncid[0][j]+rfield.ConEmitReflec[0][j])/
 						  rfield.widflx(j)*EN1RYD;
 						/* reflected lines */
 						double fref = rfield.anu(j)*resolution*rfield.reflin[0][j]*EN1RYD;
@@ -3311,7 +3311,7 @@
 						  opac.opacity_abs[j],
 						  rfield.ConSourceFcnLocal[nzone][j],
 						  rfield.ConSourceFcnLocal[nzone][j]/plankf(j),
-						  safe_div(rfield.ConSourceFcnLocal[nzone][j],rfield.flux[0][j]));
+						  safe_div(double(rfield.ConSourceFcnLocal[nzone][j]),rfield.flux[0][j]));
 					}
 				}
 			}
