unitmod.h File Reference

Header file for the ecological Unit Model. More...

#include "globals.h"

Include dependency graph for unitmod.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	call_cell_dyn (int sector, int step)
	Calling function for the cell_dyn** dynamic ecological modules.
void	cell_dyn1 (int step)
	Global dynamics and forcings.
void	cell_dyn2 (int step)
	Algae/periphyton (vertical) dynamics.
void	cell_dyn4 (int step)
	Organic Soil (vertical) dynamics.
void	horizFlow (int step)
	Horizontal raster fluxes.
void	cell_dyn7 (int step)
	Hydrologic (vertical) dynamics.
void	cell_dyn8 (int step)
	Macrophyte (vertical) dynamics.
void	cell_dyn9 (int step)
	Phosphorus (vertical) dynamics.
void	cell_dyn10 (int step)
	Salt/tracer (vertical) dynamics.
void	cell_dyn12 (int step)
	FLOCculent organic matter (vertical) dynamics.
void	cell_dyn13 (int step)
	Net settling of TP loss (stand-alone).
float	tempCF (int form, float c1, float topt, float tmin, float tmax, float tempC)
	Temperature control function for biology.
void	init_static_data (void)
	Initialize static spatial data.
void	init_dynam_data (void)
	Initialize dynamic spatial data.
void	init_eqns (void)
	Initialization of the model equations.
void	init_canals (int irun)
	Call to initialize the water managment canal network topology and data.
void	init_succession (void)
	Call to initialize the habitat succession module.
void	reinitBIR (void)
	Calls to re-initialize Basin/Indicator-Region data.
void	reinitCanals (void)
	Call to re-initialize canal storages.
void	gen_output (int step, ViewParm *view)
	Generate output.
void	ReadGlobalParms (char *s_parm_name, int s_parm_relval)
	Acquire the model parameters that are global to the domain.
void	ReadHabParms (char *s_parm_name, int s_parm_relval)
	Acquire the model parameters that are specific to different habitat types in the domain.
void	ReadModExperimParms (char *s_parm_name, int s_parm_relval)
	Acquire the model parameters that are used in special model experiments - used only in special, research-oriented applications. (Added for v2.6). NOTE that this was quickly set up for the ELM Peer Review (2006) project, and (at least in v2.6.0) should be used in conjunction with the spatial interpolators for rain and pET inputs. (because this is intended for scales that are potentially incompatible w/ simultaneous use of gridIO inputs on SFWMM stage/depth that are expected w/ gridIO rain/pET). NOTE: this has not been specifically developed/tested for inclusion within the automated sensitivity analyses - thus only been used at this point for the ModExperimParms_NOM nominal parameter set (Nov 2006). .
void	PtInterp_read (void)
	On-the-fly interpolations to develop spatial time series from point data. .
void	get_map_dims (void)
	Get the map dimensions of the global model array.
void	alloc_memory ()
	Allocate memory.
float	graph7 (unsigned char y, float x)
	Time series interplator, data set 7.
float	graph8 (unsigned char y, float x)
	Time series interplator, data set 8.
void	HabSwitch_Init (void)
	Transfers habitat-specific parameters into data struct, allocate memory.
unsigned char	HabSwitch (int ix, int iy, float *Water, float *Nutrient, int *Fire, float *Salinity, unsigned char *HAB)
	Switches habitats (the option that is currently used).
void	Run_Canal_Network (float *SWH, float *ElevMap, float *MC, float *GWV, float *poros, float *GWcond, double *NA, double *PA, double *SA, double *GNA, double *GPA, double *GSA, float *Unsat, float *sp_yield)
	Runs the water management network.
void	Canal_Network_Init (float baseDatum, float *elev)
	Initialize the water managment network topology.
void	CanalReInit ()
	Re-initialize the depths and concentrations in canals under the Positional Analysis mode.
void	getInt (FILE *inFile, const char *lString, int *iValPtr)
	Get an integer following a specific string.
void	read_map_dims (const char *filename)
	Establish the number of rows and columns of the model.
void	write_output (int index, ViewParm *vp, void *Map, const char *filename, char Mtype, int step)
	Determine which functions to call for model output.
void	getChar (FILE *inFile, const char *lString, char *cValPtr)
	Get a character following a specific string.
void	init_pvar (VOIDP Map, UCHAR *mask, unsigned char Mtype, float iv)
	Initialize a variable to a value.
int	read_map_file (const char *filename, VOIDP Map, unsigned char Mtype, float scale_value, float offset_value)
	Get the file and read/convert the data of map (array).
int	scan_forward (FILE *infile, const char *tstring)
	Scan forward until a particular string is found.
VOIDP	nalloc (unsigned mem_size, const char var_name[])
	Allocate memory for a variable.
float	FMOD (float x, float y)
	Modulus of a pair of (double) arguments.
void	PTSL_ReadLists (PTSeriesList *thisStruct, const char *ptsFileName, int index, float *timeStep, int *nPtTS, int col)
	Point Time Series interpolation (unused): read raw point data.
void	PTSL_CreatePointMap (PTSeriesList *pList, void *Map, unsigned char Mtype, int step, float scale)
	Point Time Series interpolation (unused): generate interpolated spatial (map) data.
void	stats (int step)
	Calling function for budget and summary stats.
void	alloc_mem_stats (void)
	Allocate memory for the BIR-based and cell-based stats variables.
void	BIRinit (void)
	Set up the Basin & Indicator Region (BIR) linkages/inheritances.
void	BIRoutfiles (void)
	Open files and create headers for BIR output.
void	BIRstats_reset (void)
	Reset BIR (non-budget) statistics summations to zero.
void	BIRbudg_reset (void)
	Reset BIR budget summations to zero.
void	Cell_reset_avg (void)
	Zero the arrays holding selected variable averages in cells (after printing)/.
void	Cell_reset_hydper (void)
	Zero the array holding hydroperiod data in cells (after printing).
void	Flux_SWater (int it, float *SURFACE_WAT, float *SED_ELEV, float *HYD_MANNINGS_N, double *STUF1, double *STUF2, double *STUF3, float *SfWat_vel_day)
	Surface water horizontal flux.
void	Flux_GWater (int it, float *SatWat, float *Unsat, float *SfWat, float *rate, float *poros, float *sp_yield, float *elev, double *gwSTUF1, double *gwSTUF2, double *gwSTUF3, double *swSTUF1, double *swSTUF2, double *swSTUF3)
	Groundwater fluxing routine.
float *	get_hab_parm (char *s_parm_name, int s_parm_relval, char *parmName)
	Read the input data file to get a habitat-specfic parameter array.
float	get_global_parm (char *s_parm_name, int s_parm_relval, char *parmName)
	Read the input data file to get a global parameter.
float	get_modexperim_parm (char *s_parm_name, int s_parm_relval, char *parmName)
	Read the input data file to get a model experiment parameter.
int	stage_data_wmm (float *)
int	rain_data_wmm (float *)
int	evap_data_wmm (float *)
Variables
float	DAYJUL
float	LATRAD
float	SOLALPHA
float	SOLALTCORR
float	SOLBETA
float	SOLCOSDEC
float	SOLDEC
float	SOLDEC1
float	SOLELEV_SINE
float	SOLRADATMOS
float	SOLRISSET_HA
float	SOLRISSET_HA1
float	dispParm_scaled
float	GP_BC_SfWat_add
float	GP_BC_SfWat_addHi
float	GP_BC_SatWat_add
float	GP_BC_SfWat_targ
int	GP_BC_InputRow
float	GP_BC_Pconc
float	GP_BC_Sconc
float	g7 [11][2]
float	g8 [11][2]
int	CalMonOut
PTSeriesList *	pTSList6
PTSeriesList *	pTSList5
PTSeriesList *	pTSList4
PTSeriesList *	pTSList3
PTSeriesList *	pTSList2
float	Timestep0 = 1.0
float	TMod0 = 0
int	NPtTS0 = 0
int	TIndex0 = 0
float	Timestep1 = 1.0
float	TMod1 = 0
int	NPtTS1 = 0
int	TIndex1 = 0
float	Timestep2 = 1.0
float	TMod2 = 0
int	NPtTS2 = 0
int	TIndex2 = 0
float	Timestep3 = 1.0
float	TMod3 = 0
int	NPtTS3 = 0
int	TIndex3 = 0
float	Timestep4 = 1.0
float	TMod4 = 0
int	NPtTS4 = 0
int	TIndex4 = 0
float	Timestep5 = 1.0
float	TMod5 = 0
int	NPtTS5 = 0
int	TIndex5 = 0
float	Timestep6 = 1.0
float	TMod6 = 0
int	NPtTS6 = 0
int	TIndex6 = 0
basnDef **	basn_list
basnDef *	basins
int	WatMgmtOn
int	ESPmodeON
int	HabSwitchOn
int	avgPrint
char *	OutputPath
char *	ProjName

---

Detailed Description

Header file for the ecological Unit Model.

This defines or declares variables & functions that are global to Unit_Mod.c.

Note: documented with Doxygen, which expects specific syntax within special comments.

The Everglades Landscape Model (ELM).
last updated: Oct 2007

Definition in file unitmod.h.

---

Function Documentation

int call_cell_dyn	(	int	sector,
		int	step
	)

Calling function for the cell_dyn** dynamic ecological modules.

This function calls the cell_dyn dynamic modules as defined in the Driver.parm data file. Normal order for calling ELM modules(Sectors): 1 0 7 10 9 2 8 4 12 99.

S#0 hydro: cell-cell horiz (&canals if WaterManagement is on)
S#1 global forcings
S#2 algae/periphyton
S#4 DOM/DOP
S#7 hydro: vertical
S#8 macrophytes
S#9 phosphorus
S#10 salt
S#12 FLOC
S#13 TP net settling
S#99 mass balance, budget, avg, hydroperiod, etc calculations

Returns:

rv (=1)

Parameters:

	sector	The number of the cell_dyn** module being called
	step	The current iteration number

Definition at line 150 of file UnitMod.c.

References cell_dyn1(), cell_dyn10(), cell_dyn12(), cell_dyn13(), cell_dyn2(), cell_dyn4(), cell_dyn7(), cell_dyn8(), cell_dyn9(), horizFlow(), and stats().

 {
  int rv=0;

  switch(sector) {

    case 99: { stats(step); rv=1; } break;
    case 0: { horizFlow(step); rv=1; } break;
    case 1: { cell_dyn1(step); rv=1; } break;
    case 2: { cell_dyn2(step); rv=1; } break;
    case 4: { cell_dyn4(step); rv=1; } break;
    case 7: { cell_dyn7(step); rv=1; } break;
    case 8: { cell_dyn8(step); rv=1; } break;
    case 9: { cell_dyn9(step); rv=1; } break;
    case 10: { cell_dyn10(step); rv=1; } break;
    case 12: { cell_dyn12(step); rv=1; } break;
    case 13: { cell_dyn13(step); rv=1; } break;
            default:  printf("Warning, undefined sector number:%d\n",sector);
  }
  return rv;
}

Here is the call graph for this function:

void cell_dyn1

(

int

step

)

Global dynamics and forcings.

Includes interpolation-generators, gridIO spatial data input, and habitat switching. This module is reduced in scope from v2.1 & previous, now basically only used to read coarse-grid gridIO input data OR on-the-fly interpolators, and call the habitat succession function.

Parameters:

step

The current iteration number

Definition at line 193 of file UnitMod.c.

References Arctan, BCmodel_sfwat, boundcond_depth, boundcond_ETp, boundcond_rain, Cos, DAYJUL, debug, DT, evap_data_wmm(), Exp, FIREdummy, FMOD(), GP_ALTIT, HAB, HabSwitch(), HabSwitchOn, HP_HYD_POROSITY, HydRelDepPosNeg, HydTotHd, isPTSL, IsSubstituteModel, LATRAD, Max, msgStr, NPtTS2, NPtTS3, ON_MAP, OutputPath, PI, ProjName, PTSL_CreatePointMap(), pTSList2, pTSList3, rain_data_wmm(), s0, s1, SAL_SF_WT, SAT_WATER, SAT_WT_HEAD, SED_ELEV, SimTime, Sin, SOLALTCORR, SOLCOSDEC, SOLDEC, SOLDEC1, SOLELEV_SINE, SOLRADATMOS, SOLRISSET_HA, SOLRISSET_HA1, stage_data_wmm(), SURFACE_WAT, T, Tan, simTime::TIME, Timestep2, Timestep3, TPtoSOIL, UNSAT_DEPTH, UNSAT_WATER, and WriteMsg().

Referenced by call_cell_dyn().

{
   int fail = -1;
   int ix, iy, cellLoc, stat=1; 
   float fTemp;
   extern IsSubstituteModel; /* from generic_driver.h */
   
   /* v2.5 may be temporary? */
   FILE *boundaryFile; 
   char filename[40];

     /* SimTime.TIME is a (float) julian day counter since initialization (calc'd in main function, Generic_Driver.c source).  
         (SimTime.TIME includes fractions of days if the vertical DT<1.0, but it is
         unlikely that the vertical DT will deviate from 1 day). */

         if ( debug > 4 ) {
                if (SimTime.TIME>60)  printf("\nDebug level is very high - you're probably getting too much output data in %s/%s/Output/Debug/! Decrease your simulation length.\n", OutputPath, ProjName); 
                exit(-1); 
         }

/* v2.6 PTSL */
/* a choice of rainfall and pET input data routines */
    if (!isPTSL) { /* do the gridIO inputs */
        if (FMOD(SimTime.TIME,1.0) < 0.001) { /* daily re-mapping of coarse-grid input data */
                /* remap sfwmm (or other grid) rain data to ELM grid scale */
          stat=rain_data_wmm(boundcond_rain); 
          if(stat==fail)  
         { 
                  sprintf(msgStr,"Problem with rainfall data, time = %f.\n",SimTime.TIME); 
                         WriteMsg(msgStr,1); 
                         exit(fail);    
         }

     /* remap sfwmm (or other grid) potential ET data to ELM grid scale */
                  stat=evap_data_wmm(boundcond_ETp); 
                  if(stat==-1)
                 {
                   sprintf(msgStr,"Problem with ETp data, time = %f.\n",SimTime.TIME);
                   WriteMsg(msgStr,1);
                   exit(fail);
                          } 

     /* remap sfwmm (or other grid) stage/water depth data to ELM grid scale */
      stat=stage_data_wmm(boundcond_depth);  
     if(stat==-1)
     {
       sprintf(msgStr,"Problem with stage data, time = %f.\n",SimTime.TIME);
       WriteMsg(msgStr,1);
       exit(fail);
     } 
     

         for ( ix = 1; ix <= s0 ; ix++ ) 
            for ( iy = 1 ; iy <= s1 ; iy++ )
                {
                        cellLoc= T(ix,iy);

    /* v2.7.1 assign the external boundary condition model's depths to an ELM variable within the rectangular 
    ELM domain (i.e., on-map and off-map), for output only (this variable not used in any calcs) */
                        if (IsSubstituteModel == 0) BCmodel_sfwat[cellLoc] = (boundcond_depth[cellLoc] > 0.0) ? (boundcond_depth[cellLoc]) : (0.0) ;
                        
                        else { /* IsSubstituteModel is true */
                                if(ON_MAP[cellLoc])  {
       /* v2.8 - added feature to replace all ELM hydrologic calcs, substituting the Boundary Condition Model's
                        "stage_minus_landElevation" variable into ELM hydro variables.
                        This was done in order to post-process the SFWMM or NSM using the same procedures as ELM 
                        At initial setup, it was determined whether the user is requesting to only run cell_dyn1 (and stats, case #99) in UnitMod.c,
                        which would make the IsSubstituteModel flag True */

                                SURFACE_WAT[cellLoc] = (boundcond_depth[cellLoc] > 0.0) ? (boundcond_depth[cellLoc]) : (0.0) ;
                                SAT_WT_HEAD[cellLoc] = (boundcond_depth[cellLoc] <= 0.0) ? (SED_ELEV[cellLoc] + boundcond_depth[cellLoc]) : (SED_ELEV[cellLoc]) ;
                                HydTotHd[cellLoc]  = SAT_WT_HEAD[cellLoc]+SURFACE_WAT[cellLoc];
                                SAT_WATER[cellLoc] = SAT_WT_HEAD[cellLoc] * HP_HYD_POROSITY[HAB[cellLoc]];  /* this isn't needed for current purposes, but may be of interest later */
                                UNSAT_DEPTH[cellLoc] = Max(SED_ELEV[cellLoc]-SAT_WT_HEAD[cellLoc],0.0);
                                UNSAT_WATER[cellLoc] = UNSAT_DEPTH[cellLoc] * HP_HYD_POROSITY[HAB[cellLoc]] * 0.0; /* assume there is no moisture in pore spaces, thus never any unsat storage */
              /* v2.8.2 new variable, for reporting purposes only: positive/negative water depth relative to land elevation (stage minus land elevation) */
                        HydRelDepPosNeg[cellLoc] =  HydTotHd[cellLoc] - SED_ELEV[cellLoc];
                        }
                        }
                                
                        }   



    } /* end of mapping multi-grid, gridIO data */
    } /* end of !isPTSL */
    
    else { /* instead of gridIO spatial data, calculate on-the-fly spatial interpolations of rain and pET point time series data  */
                /* NOTE that this option does not use gridIO stage/depth boundary condition data, and thus should be used in conjunction
                with the ModExperimParms_NOM synthetic boundary condition data */
        fTemp = FMOD(SimTime.TIME,Timestep2*NPtTS2);
                PTSL_CreatePointMap(pTSList2,boundcond_rain,'f',(int)(fTemp/Timestep2),1.0);
        fTemp = FMOD(SimTime.TIME,Timestep3*NPtTS3);
                PTSL_CreatePointMap(pTSList3,boundcond_ETp,'f',(int)(fTemp/Timestep3),1.0);
    }


            
    /* the "julian" day counter within a 365 day "year"  */
    DAYJUL = ( FMOD(SimTime.TIME,365.0) >0.0 ) ? ( FMOD(SimTime.TIME,365.0) ) : ( 365.0);
    /* DAYLENGTH is not used */
    /* DAYLENGTH = AMPL*Sin((DAYJUL-79.0)*0.01721)+12.0; */ /* length of daylight (hours) */

                
/*  Nikolov & Zeller (1992) solar radiation algorithm 
   the algorithm and all parameters are published in the (Ecol. Mod., 61:149-168) manuscript,
   and the only modifiable parameters (in ELM database system) are local latitude and altitude */
    SOLDEC1 = 0.39785*Sin(4.868961+0.017203*DAYJUL   
                          +0.033446*Sin(6.224111+0.017202*DAYJUL));
    SOLCOSDEC = sqrt(1.0-SOLDEC1*SOLDEC1);
    SOLELEV_SINE = Sin(LATRAD)*SOLDEC1+Cos(LATRAD)*SOLCOSDEC;
    SOLALTCORR = (1.0-Exp(-0.014*(GP_ALTIT-274.0)/(SOLELEV_SINE*274.0)));
    SOLDEC = Arctan(SOLDEC1/sqrt(1.0-SOLDEC1*SOLDEC1));
    SOLRISSET_HA1 = -Tan(LATRAD)*Tan(SOLDEC);
    SOLRISSET_HA = ( (SOLRISSET_HA1==0.0) ) ? ( PI*0.5 ) : (   ( (SOLRISSET_HA1<0.0) ) ? 
                                                               ( PI+Arctan(sqrt(1.0-SOLRISSET_HA1*SOLRISSET_HA1)/SOLRISSET_HA1)  ) : 
                                                               (    Arctan(sqrt(1.0-SOLRISSET_HA1*SOLRISSET_HA1)/SOLRISSET_HA1)));
    SOLRADATMOS = 458.37*2.0*(1.0+0.033*Cos(360.0/365.0*PI/180.0*DAYJUL))
        * ( Cos(LATRAD)*Cos(SOLDEC)*Sin(SOLRISSET_HA) 
            + SOLRISSET_HA*180.0/(57.296*PI)*Sin(LATRAD)*Sin(SOLDEC));
            
  
        /* daily habitat switching */
    if ( (SimTime.TIME - (int)SimTime.TIME) < DT/2 && HabSwitchOn ) /* HabSwitchOn flag to invoke switching */
        for(ix=1; ix<=s0; ix++)  
            for(iy=1; iy<=s1; iy++)  
                if(ON_MAP[cellLoc= T(ix,iy)]) { /* TPtoSoil == kg/kg */
                    HAB [cellLoc] = HabSwitch (ix, iy, SURFACE_WAT, TPtoSOIL, (int*)FIREdummy, SAL_SF_WT, HAB); 
                } 
}

Here is the call graph for this function:

void cell_dyn2

(

int

step

)

Algae/periphyton (vertical) dynamics.

Temporal dynamics of carbon and phosphorus of two communities of periphyton.

Parameters:

step

The current iteration number

Definition at line 344 of file UnitMod.c.

References ALG_INCID_LIGHT, ALG_LIGHT_CF, ALG_LIGHT_EXTINCT, ALG_REFUGE, ALG_SAT, ALG_TEMP_CF, ALG_TOT, ALG_WAT_CF, C_ALG, C_ALG_AVAIL_MORT, C_ALG_GPP, C_ALG_GPP_P, C_ALG_MORT, C_ALG_MORT_P, C_ALG_MORT_POT, C_ALG_NPP, C_ALG_NUT_CF, C_ALG_P, C_ALG_PC, C_ALG_PCrep, C_ALG_PROD_CF, C_ALG_RESP, C_ALG_RESP_POT, CELL_SIZE, conv_kgTOg, conv_kgTOmg, debug, DT, dynERRORnum, Exp, GP_alg_alkP_min, GP_alg_light_ext_coef, GP_ALG_LIGHT_SAT, GP_ALG_PC, GP_alg_R_accel, GP_ALG_RC_MORT, GP_ALG_RC_MORT_DRY, GP_ALG_RC_PROD, GP_ALG_RC_RESP, GP_ALG_REF_MULT, GP_ALG_SHADE_FACTOR, GP_ALG_TEMP_OPT, GP_alg_uptake_coef, GP_AlgComp, GP_algMortDepth, GP_C_ALG_KS_P, GP_C_ALG_threshTP, GP_MinCheck, GP_NC_ALG_KS_P, GP_PO4toTP, GP_PO4toTPint, GP_WQualMonitZ, H2O_TEMP, HAB, HP_ALG_MAX, MAC_LAI, Max, Min, msgStr, NC_ALG, NC_ALG_AVAIL_MORT, NC_ALG_GPP, NC_ALG_GPP_P, NC_ALG_MORT, NC_ALG_MORT_P, NC_ALG_MORT_POT, NC_ALG_NPP, NC_ALG_NUT_CF, NC_ALG_P, NC_ALG_PC, NC_ALG_PCrep, NC_ALG_PROD_CF, NC_ALG_RESP, NC_ALG_RESP_POT, ON_MAP, ramp, s0, s1, SFWT_VOL, SimTime, SOLRADGRD, SURFACE_WAT, T, tempCF(), simTime::TIME, TP_SF_WT, TP_SFWT_CONC, TP_SFWT_CONC_MG, TP_SFWT_UPTAK, True, UNSAT_DEPTH, and WriteMsg().

Referenced by call_cell_dyn().

 {
 int ix, iy, cellLoc; 
 float reduc, min_litTemp,I_ISat, Z_extinct; 
 double PO4Pconc, PO4P;
 float C_ALG_thresh_CF, mortPot;
 
  for(ix=1; ix<=s0; ix++) {
  for(iy=1; iy<=s1; iy++) {

    if(ON_MAP[cellLoc= T(ix,iy)])  {

/* these thresholds need updating when a habitat type of a grid cell changes */
     ALG_REFUGE[cellLoc] = HP_ALG_MAX[HAB[cellLoc]]*GP_ALG_REF_MULT;
     ALG_SAT[cellLoc] = HP_ALG_MAX[HAB[cellLoc]]*0.9;

     NC_ALG_AVAIL_MORT[cellLoc]  = Max(NC_ALG[cellLoc]-ALG_REFUGE[cellLoc],0);
     C_ALG_AVAIL_MORT[cellLoc]  = Max(C_ALG[cellLoc]-ALG_REFUGE[cellLoc],0);
/* bio-avail P (PO4) is calc'd from TP, using pre-processed regression for predicting PO4 from TP */
/* assume that periphyton (microbial) alkaline phosphotase activity keeps PO4 at least 10% of TP conc */
     PO4Pconc = Max(TP_SFWT_CONC_MG[cellLoc]*GP_PO4toTP + GP_PO4toTPint,
                                0.10 * TP_SFWT_CONC_MG[cellLoc]); /* mg/L */

/* light, water, temperature controls apply to both calc and non-calc */
     ALG_LIGHT_EXTINCT[cellLoc]  = GP_alg_light_ext_coef; 
                     /* algal self-shading implicit in density-dependent constraint function later */
     ALG_INCID_LIGHT[cellLoc]  = SOLRADGRD[cellLoc]*Exp(-MAC_LAI[cellLoc]*GP_ALG_SHADE_FACTOR);
     Z_extinct = SURFACE_WAT[cellLoc]*ALG_LIGHT_EXTINCT[cellLoc];
     I_ISat = ALG_INCID_LIGHT[cellLoc]/GP_ALG_LIGHT_SAT;
                     /* averaged over whole water column (based on Steele '65) */
     ALG_LIGHT_CF[cellLoc]  = ( Z_extinct > 0.0 ) ? 
                     ( 2.718/Z_extinct * (Exp(-I_ISat * Exp(-Z_extinct)) - Exp(-I_ISat)) ) :
                     (I_ISat*Exp(1.0-I_ISat));
                     /* low-water growth constraint ready for something better based on data */
     ALG_WAT_CF[cellLoc]  = ( SURFACE_WAT[cellLoc]>0.0 ) ? ( 1.0 ) : ( 0.0);
     ALG_TEMP_CF[cellLoc]  = tempCF(0, 0.20, GP_ALG_TEMP_OPT, 5.0, 40.0, H2O_TEMP[cellLoc]);

      min_litTemp = Min(ALG_LIGHT_CF[cellLoc],ALG_TEMP_CF[cellLoc]);

/* the 2 communities have same form of growth response to avail phosphorus */
     NC_ALG_NUT_CF[cellLoc]  =
                     Exp(-GP_alg_uptake_coef * Max(GP_NC_ALG_KS_P-PO4Pconc, 0.0)/GP_NC_ALG_KS_P) ; /* mg/L */
     C_ALG_NUT_CF[cellLoc]  =
                     Exp(-GP_alg_uptake_coef * Max(GP_C_ALG_KS_P-PO4Pconc, 0.0)/GP_C_ALG_KS_P) ; /* mg/L */

         /* the form of the control function assumes that at very low
             P conc, the alkaline phosphotase activity of the microbial assemblage scavenges P, maintaining a minimum nutrient availability to community */
     NC_ALG_PROD_CF[cellLoc]  = Min(min_litTemp,ALG_WAT_CF[cellLoc])*Max(NC_ALG_NUT_CF[cellLoc], GP_alg_alkP_min);
     C_ALG_PROD_CF[cellLoc]   = Min(min_litTemp,ALG_WAT_CF[cellLoc])*Max(C_ALG_NUT_CF[cellLoc], GP_alg_alkP_min);

     NC_ALG_RESP_POT[cellLoc]  = 
         ( UNSAT_DEPTH[cellLoc]>GP_algMortDepth ) ? 
         ( 0.0) :
         ( GP_ALG_RC_RESP*ALG_TEMP_CF[cellLoc]*NC_ALG_AVAIL_MORT[cellLoc] ); 
     C_ALG_RESP_POT[cellLoc]  = 
         ( UNSAT_DEPTH[cellLoc]>GP_algMortDepth ) ? 
         ( 0.0) :
         ( GP_ALG_RC_RESP*ALG_TEMP_CF[cellLoc] *C_ALG_AVAIL_MORT[cellLoc] ); 

     NC_ALG_RESP[cellLoc]  =  
         ( NC_ALG_RESP_POT[cellLoc]*DT>NC_ALG_AVAIL_MORT[cellLoc] ) ? 
         ( NC_ALG_AVAIL_MORT[cellLoc]/DT ) : 
         ( NC_ALG_RESP_POT[cellLoc]);
     C_ALG_RESP[cellLoc]  =  
         ( C_ALG_RESP_POT[cellLoc]*DT>C_ALG_AVAIL_MORT[cellLoc] ) ? 
         ( C_ALG_AVAIL_MORT[cellLoc]/DT ) : 
         ( C_ALG_RESP_POT[cellLoc]);
                 
          /* this is the threshold control function that increases
              calcareous/native periph mortality (likely due to loss of calcareous sheath) as P conc. increases */
     C_ALG_thresh_CF = Min(exp(GP_alg_R_accel*Max( TP_SFWT_CONC_MG[cellLoc]-GP_C_ALG_threshTP,0.0)/GP_C_ALG_threshTP), 100.0);

     NC_ALG_MORT_POT[cellLoc]  = 
         ( UNSAT_DEPTH[cellLoc]>GP_algMortDepth ) ? 
         ( NC_ALG_AVAIL_MORT[cellLoc]*GP_ALG_RC_MORT_DRY ) : 
         ( NC_ALG_AVAIL_MORT[cellLoc]*GP_ALG_RC_MORT);
     C_ALG_MORT_POT[cellLoc]  = 
         ( UNSAT_DEPTH[cellLoc]>GP_algMortDepth ) ? 
         ( C_ALG_AVAIL_MORT[cellLoc]*GP_ALG_RC_MORT_DRY ) : 
         ( C_ALG_thresh_CF * C_ALG_AVAIL_MORT[cellLoc]*GP_ALG_RC_MORT);

     NC_ALG_MORT[cellLoc]  = 
         ( (NC_ALG_MORT_POT[cellLoc]+NC_ALG_RESP[cellLoc])*DT>NC_ALG_AVAIL_MORT[cellLoc] ) ? 
         ( (NC_ALG_AVAIL_MORT[cellLoc]-NC_ALG_RESP[cellLoc]*DT)/DT ) : 
         ( NC_ALG_MORT_POT[cellLoc]);
     C_ALG_MORT[cellLoc]  = 
         ( (C_ALG_MORT_POT[cellLoc]+C_ALG_RESP[cellLoc])*DT>C_ALG_AVAIL_MORT[cellLoc] ) ? 
         ( (C_ALG_AVAIL_MORT[cellLoc]-C_ALG_RESP[cellLoc]*DT)/DT ) : 
         ( C_ALG_MORT_POT[cellLoc]);
                 
/* gross production of the 2 communities (gC/m2/d, NOT kgC/m2/d) */
/* density constraint on both noncalc and calc, competition effect accentuated by calc algae */

     NC_ALG_GPP[cellLoc]  =  NC_ALG_PROD_CF[cellLoc]*GP_ALG_RC_PROD*NC_ALG[cellLoc]       
             *Max( (1.0-(GP_AlgComp*C_ALG[cellLoc]+NC_ALG[cellLoc])/HP_ALG_MAX[HAB[cellLoc]]),0.0);
     C_ALG_GPP[cellLoc]  =  C_ALG_PROD_CF[cellLoc]*GP_ALG_RC_PROD*C_ALG[cellLoc] 
       *Max( (1.0-(        C_ALG[cellLoc]+NC_ALG[cellLoc])/HP_ALG_MAX[HAB[cellLoc]]),0.0);
       
                     
/* P uptake is dependent on available P and is relative to a maximum P:C ratio for the tissue
   (g C/m^2/d * P:Cmax * dimless * dimless = gP/m2/d (NOT kg) )*/
     NC_ALG_GPP_P[cellLoc] = NC_ALG_GPP[cellLoc] *GP_ALG_PC * NC_ALG_NUT_CF[cellLoc]
                     * Max(1.0-NC_ALG_PC[cellLoc]/GP_ALG_PC, 0.0); 
     C_ALG_GPP_P[cellLoc] = C_ALG_GPP[cellLoc] * GP_ALG_PC * C_ALG_NUT_CF[cellLoc]
                     * Max(1.0-C_ALG_PC[cellLoc]/GP_ALG_PC, 0.0); 
                 
/* check for available P mass (the nutCF does not) */
     PO4P = ramp(Min(PO4Pconc * SFWT_VOL[cellLoc],  conv_kgTOg*TP_SF_WT[cellLoc]) ); /*g P available; v2.5 put in ramp (constrain non-neg) */
     reduc = ( (NC_ALG_GPP_P[cellLoc]+C_ALG_GPP_P[cellLoc]) > 0) ? 
                     (PO4P / ( (NC_ALG_GPP_P[cellLoc]+C_ALG_GPP_P[cellLoc])*CELL_SIZE*DT) ) :
                     (1.0);
    /* can have high conc, but low mass of P avail, in presence of high peri biomass and high demand */
    /* reduce the production proportionally if excess demand is found */
    if (reduc < 1.0) {
                     NC_ALG_GPP[cellLoc] *= reduc;   
                     NC_ALG_GPP_P[cellLoc] *= reduc;   
                     C_ALG_GPP[cellLoc] *= reduc; 
                     C_ALG_GPP_P[cellLoc] *= reduc; 
                 }

/* state variables calc'd (gC/m2, NOT kgC/m2) */
     NC_ALG[cellLoc] =  NC_ALG[cellLoc] 
         + (NC_ALG_GPP[cellLoc]
          - NC_ALG_RESP[cellLoc] - NC_ALG_MORT[cellLoc]) * DT;

     C_ALG[cellLoc] =  C_ALG[cellLoc] 
         + (C_ALG_GPP[cellLoc] 
         - C_ALG_RESP[cellLoc]  - C_ALG_MORT[cellLoc]) * DT;

/* carbon NPP not currently used elsewhere, only for output */
     NC_ALG_NPP[cellLoc]  = NC_ALG_GPP[cellLoc]-NC_ALG_RESP[cellLoc]; 
     C_ALG_NPP[cellLoc]  = C_ALG_GPP[cellLoc]-C_ALG_RESP[cellLoc];                 
/* carbon total biomass of both communities, not currently used elsewhere, only for output */
     ALG_TOT[cellLoc] = NC_ALG[cellLoc] + C_ALG[cellLoc];
                 
                 
/*  now calc the P  associated with the C fluxes (GPP_P already calc'd) */
     mortPot = (double) NC_ALG_MORT[cellLoc] * NC_ALG_PC[cellLoc];
     NC_ALG_MORT_P[cellLoc] = (mortPot*DT>NC_ALG_P[cellLoc]) ?
                     (NC_ALG_P[cellLoc]/DT) :
                     (mortPot);
     mortPot = (double) C_ALG_MORT[cellLoc] * C_ALG_PC[cellLoc];
     C_ALG_MORT_P[cellLoc] = (mortPot*DT>C_ALG_P[cellLoc]) ?
                     (C_ALG_P[cellLoc]/DT) :
                     (mortPot);
                 

/* state variables calc'd (gP/m2, NOT kgP/m2) */
     NC_ALG_P[cellLoc] =  NC_ALG_P[cellLoc] 
         + (NC_ALG_GPP_P[cellLoc] - NC_ALG_MORT_P[cellLoc]) * DT;

     C_ALG_P[cellLoc] =  C_ALG_P[cellLoc] 
         + (C_ALG_GPP_P[cellLoc] - C_ALG_MORT_P[cellLoc]) * DT;

     NC_ALG_PC[cellLoc] = (NC_ALG[cellLoc]>0.0) ?
                     (NC_ALG_P[cellLoc]/ NC_ALG[cellLoc]) :
                     ( GP_ALG_PC * 0.03); /* default to 3% of  max P:C */
     C_ALG_PC[cellLoc] = (C_ALG[cellLoc]>0.0) ?
                     (C_ALG_P[cellLoc]/ C_ALG[cellLoc]) :
                     ( GP_ALG_PC * 0.03 ); /* default to 3% of max P:C */
     NC_ALG_PCrep[cellLoc] = (float)NC_ALG_PC[cellLoc] * conv_kgTOmg; /* variable for output _rep-orting only */
     C_ALG_PCrep[cellLoc] = (float)C_ALG_PC[cellLoc] * conv_kgTOmg; /* variable for output _rep-orting only */

     if (debug > 0 && NC_ALG[cellLoc] < -GP_MinCheck) { sprintf(msgStr,"Day %6.1f: ERROR - neg NC_ALG C biomass (%f g/m2) in cell (%d,%d)!", 
                              SimTime.TIME, NC_ALG[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}
                 if (debug > 0 && C_ALG[cellLoc] < -GP_MinCheck)  { sprintf(msgStr,"Day %6.1f: ERROR - neg C_ALG C biomass (%f g/m2) in cell (%d,%d)!", 
                              SimTime.TIME, C_ALG[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}
                 if (debug > 0 && NC_ALG_P[cellLoc] < -GP_MinCheck) { sprintf(msgStr,"Day %6.1f: ERROR - neg NC_ALG_P P biomass (%f g/m2) in cell (%d,%d)!", 
                              SimTime.TIME, NC_ALG_P[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}
                 if (debug > 0 && C_ALG_P[cellLoc] < -GP_MinCheck)  { sprintf(msgStr,"Day %6.1f: ERROR - neg C_ALG_P P biomass (%f g/m2) in cell (%d,%d)!", 
                              SimTime.TIME, C_ALG_P[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}

                     
     TP_SFWT_UPTAK[cellLoc]  = (NC_ALG_GPP_P[cellLoc]+C_ALG_GPP_P[cellLoc])
                     *0.001*CELL_SIZE; /* gP/m2 => kg P */
/* recalc P in surface water state variable (kg P) */
     TP_SF_WT[cellLoc] = TP_SF_WT[cellLoc] - TP_SFWT_UPTAK[cellLoc] * DT;
     TP_SFWT_CONC[cellLoc]  = 
         ( SFWT_VOL[cellLoc] > 0.0 ) ? 
         ( TP_SF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
         ( 0.0); /* used in P fluxes for mass balance */
     TP_SFWT_CONC_MG[cellLoc]  = 
         ( SURFACE_WAT[cellLoc] > GP_WQualMonitZ ) ? 
         (TP_SFWT_CONC[cellLoc]*conv_kgTOg) : 
         (0.0); /* (g/m3==mg/L) used for reporting and other modules to evaluate P conc when water is present */

          }
  }
  }
}

Here is the call graph for this function:

void cell_dyn4

(

int

step

)

Organic Soil (vertical) dynamics.

Temporal dynamics of Deposited Organic Matter and Deposited Organic Phosphorus.

Parameters:

step

The current iteration number

Definition at line 553 of file UnitMod.c.

References C_ALG_P, CELL_SIZE, conv_kgTOg, conv_kgTOmg, DEPOS_ORG_MAT, DIM, DOM_BD, DOM_DECOMP, DOM_DECOMP_POT, DOM_FR_FLOC, DOM_fr_nphBio, DOM_P_OM, DOM_QUALITY_CF, DOM_SED_AEROB_Z, DOM_SED_ANAEROB_Z, DOM_TEMP_CF, DOM_Z, DOP, DOP_DECOMP, DOP_FLOC, DOP_nphBio, DT, Exp, FLOC_DEPO, FlocP, FlocP_DEPO, GP_calibDecomp, GP_DOM_decomp_coef, GP_DOM_DECOMP_POPT, GP_DOM_DECOMP_TOPT, GP_DOM_DECOMPRED, GP_DOM_RCDECOMP, GP_WQualMonitZ, H2O_TEMP, HAB, HP_DOM_AEROBTHIN, HP_DOM_MAXDEPTH, HP_TP_CONC_GRAD, HYD_DOM_ACTWAT_PRES, HYD_DOM_ACTWAT_VOL, HYD_SED_WAT_VOL, Inorg_Z, mac_nph_P, mac_ph_P, Max, Min, NC_ALG_P, nphbio_mort_OM, nphbio_mort_P, ON_MAP, P_SUM_CELL, s0, s1, SED_ELEV, SED_INACT_Z, SFWT_VOL, soil_MOIST_CF, SURFACE_WAT, T, tempCF(), TP_Act_to_Tot, TP_Act_to_TotRep, TP_SED_CONC, TP_SED_WT, TP_SED_WT_AZ, TP_SEDWT_CONCACT, TP_SEDWT_CONCACTMG, TP_SF_WT, TP_SFWT_CONC, TP_SFWT_CONC_MG, TP_SORB, TPtoSOIL, TPtoSOIL_rep, TPtoVOL, TPtoVOL_rep, and UNSAT_DEPTH.

Referenced by call_cell_dyn().

 {
int ix, iy, cellLoc;
 float TPsoil, TP_sedMin, TP_sfMin;
  
 

  for(ix=1; ix<=s0; ix++) {
  for(iy=1; iy<=s1; iy++) {

    if(ON_MAP[cellLoc= T(ix,iy)])  {


/* inputs of organic matter (kg OM/m2)*/
     DOM_fr_nphBio[cellLoc] = nphbio_mort_OM[cellLoc];
     DOM_FR_FLOC[cellLoc]  =  FLOC_DEPO[cellLoc] ; 

/* losses of organic matter (kg OM/m2) */

     DOM_QUALITY_CF[cellLoc]  =
          Min(Exp(-GP_DOM_decomp_coef * Max(GP_DOM_DECOMP_POPT-TP_SEDWT_CONCACTMG[cellLoc], 0.0)
          /GP_DOM_DECOMP_POPT),1.0) ; /* mg/L */
          DOM_TEMP_CF[cellLoc] = tempCF(0, 0.20, GP_DOM_DECOMP_TOPT, 5.0, 40.0, H2O_TEMP[cellLoc]);
     DOM_SED_AEROB_Z[cellLoc]  = Min(Max(UNSAT_DEPTH[cellLoc],HP_DOM_AEROBTHIN[HAB[cellLoc]]),HP_DOM_MAXDEPTH[HAB[cellLoc]]);
     DOM_SED_ANAEROB_Z[cellLoc]  = HP_DOM_MAXDEPTH[HAB[cellLoc]]-DOM_SED_AEROB_Z[cellLoc];

                     /* GP_calibDecomp is an adjustable calib parm  */
     DOM_DECOMP_POT[cellLoc]  = (double) GP_calibDecomp*GP_DOM_RCDECOMP*DOM_QUALITY_CF[cellLoc]*DOM_TEMP_CF[cellLoc]*DEPOS_ORG_MAT[cellLoc]
         *(Min(DOM_SED_AEROB_Z[cellLoc]/HP_DOM_MAXDEPTH[HAB[cellLoc]],1.0)*soil_MOIST_CF[cellLoc]
         +GP_DOM_DECOMPRED*Min(DOM_SED_ANAEROB_Z[cellLoc]/HP_DOM_MAXDEPTH[HAB[cellLoc]],1.0) );
     DOM_DECOMP[cellLoc]  =  
         ( (DOM_DECOMP_POT[cellLoc])*DT>DEPOS_ORG_MAT[cellLoc] ) ? 
         ( (DEPOS_ORG_MAT[cellLoc])/DT ) : 
         ( DOM_DECOMP_POT[cellLoc]);
/* calc state var (kg OM/m2) */
     DEPOS_ORG_MAT[cellLoc] =  DEPOS_ORG_MAT[cellLoc] + 
         ( DOM_fr_nphBio[cellLoc] + DOM_FR_FLOC[cellLoc] 
         - DOM_DECOMP[cellLoc] ) * DT;

/* soil elevation */
     DOM_Z[cellLoc] = (double) DEPOS_ORG_MAT[cellLoc] / DOM_BD[cellLoc] ; /* (m) organic depth  */
     SED_ELEV[cellLoc]  = DOM_Z[cellLoc]+Inorg_Z[cellLoc]+SED_INACT_Z[cellLoc];  /* total land surface elevation, including model GP_DATUM_DISTANCE below zero of land elev datum (NGVD/NAVD) (m) */

/* P DOM stoich (kg P /m2) */
     DOP_nphBio[cellLoc] = nphbio_mort_P[cellLoc];    
     DOP_FLOC[cellLoc] = FlocP_DEPO[cellLoc]; 

     DOP_DECOMP[cellLoc] = (double) DOM_DECOMP[cellLoc] * DOM_P_OM[cellLoc]; 

/* calc state var of total "organic" P in soil (NOT including dissolved in pore water or sorbed) (kgP/m2) */
     DOP[cellLoc] =  DOP[cellLoc]  
         + ( DOP_nphBio[cellLoc]  + DOP_FLOC[cellLoc] 
         - DOP_DECOMP[cellLoc]) * DT; /* kgP/m2 */

/* now the P ratio */
     DOM_P_OM[cellLoc] = (DEPOS_ORG_MAT[cellLoc]>0.0) ? ( DOP[cellLoc] / DEPOS_ORG_MAT[cellLoc]) : (0.0); /* kgP/kgOM */
     TPsoil = DOP[cellLoc]*CELL_SIZE + TP_SORB[cellLoc]; /* kg TP in soil */
     TPtoSOIL[cellLoc] = ((DEPOS_ORG_MAT[cellLoc]*CELL_SIZE + DIM[cellLoc])>0.0) ?
         (  TPsoil / (DEPOS_ORG_MAT[cellLoc]*CELL_SIZE + DIM[cellLoc]) ) : (0.0); /* kgP/kgsoil */
     TPtoVOL[cellLoc] =  (CELL_SIZE * DOM_Z[cellLoc]>0.0) ?
         (TPsoil / (CELL_SIZE * DOM_Z[cellLoc]) ) :
         (0.0); /* kgP/m3 soil */
         
     TPtoSOIL_rep[cellLoc] = TPtoSOIL[cellLoc] * conv_kgTOmg; /* reporting purposes only (kg/kg->mg/kg) */
     TPtoVOL_rep[cellLoc] = TPtoVOL[cellLoc] * conv_kgTOg; /* reporting purposes only (kg/m3->g/m3 == ug/cm3) */

/* now the P gain in sed water with decomp
 a small proportion goes into surface water P (below) */
     TP_sedMin  =  (1.0 - HP_DOM_AEROBTHIN[HAB[cellLoc]]  / HP_DOM_MAXDEPTH[HAB[cellLoc]] )
          * DOP_DECOMP[cellLoc] * CELL_SIZE;
                 
/* calc P in sed water state variables (kg P) */
     TP_SED_WT[cellLoc] =  TP_SED_WT[cellLoc] + TP_sedMin * DT;
             /* this is the active zone, where uptake, sorption, and mineralization take place */
     TP_SED_WT_AZ[cellLoc] =  TP_SED_WT_AZ[cellLoc] + TP_sedMin * DT;

     TP_SED_CONC[cellLoc] = (HYD_SED_WAT_VOL[cellLoc]>0.0) ?
          (TP_SED_WT[cellLoc] / HYD_SED_WAT_VOL[cellLoc]) :
          (0.0);
     TP_SEDWT_CONCACT[cellLoc] = ( HYD_DOM_ACTWAT_PRES[cellLoc] > 0.0) ?
          ( TP_SED_WT_AZ[cellLoc]/HYD_DOM_ACTWAT_VOL[cellLoc] ) :
          (TP_SED_CONC[cellLoc]); /* g/L */
     TP_SEDWT_CONCACTMG[cellLoc]  = TP_SEDWT_CONCACT[cellLoc]*conv_kgTOg; /* g/m3==mg/L */
              
/* now store the ratio of the conc in the active zone relative to total, prior to horiz fluxes
***** very simple constant, code in transition **** */              
     TP_Act_to_Tot[cellLoc] = 1.0 / HP_TP_CONC_GRAD[HAB[cellLoc]];
     TP_Act_to_TotRep[cellLoc] =  (float) TP_Act_to_Tot[cellLoc];
                 
/* now the P gain in surface water with decomp in the very thin upper layer of the soil */
                     /* if there is no surface water present, assume that this
                        relative contribution will be an additional sorbed component that
                        is introduced to surface water column immediately upon hydration
                        with surface water */
     TP_sfMin  =  HP_DOM_AEROBTHIN[HAB[cellLoc]] / HP_DOM_MAXDEPTH[HAB[cellLoc]]
           * DOP_DECOMP[cellLoc] * CELL_SIZE;
                 
/* calc P in surface water state variable (kg P) */
     TP_SF_WT[cellLoc] = TP_SF_WT[cellLoc] + TP_sfMin * DT;
     TP_SFWT_CONC[cellLoc]  = 
           ( SFWT_VOL[cellLoc] > 0.0 ) ? 
           ( TP_SF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
           ( 0.0); /* used in P fluxes for mass balance */
     TP_SFWT_CONC_MG[cellLoc]  = 
           ( SURFACE_WAT[cellLoc] > GP_WQualMonitZ ) ? 
           (TP_SFWT_CONC[cellLoc]*conv_kgTOg) : 
           (0.0); /* (g/m3==mg/L) used for reporting and other modules to evaluate P conc when water is present */

/* for reporting only: calc sum of all P storages in grid cells (budget calcs do same for Basin/Indicator-Regions) (g P /m^2) */
     P_SUM_CELL[cellLoc] = ( (C_ALG_P[cellLoc] + NC_ALG_P[cellLoc]) * 0.001 * CELL_SIZE + /* gP/m2 => kgP */
           (mac_nph_P[cellLoc] + mac_ph_P[cellLoc] )* CELL_SIZE + /* kgP/m2 => kgP */
           TP_SORB[cellLoc] +
           ( FlocP[cellLoc] + DOP[cellLoc]  ) * CELL_SIZE + /* kgP/m2 => kgP */
           TP_SED_WT[cellLoc] + TP_SF_WT[cellLoc] ) /* kgP */
           /CELL_SIZE * conv_kgTOg; /* kg P/m^2 => g P/m^2 */
                 
    }
  }
  }
}

Here is the call graph for this function:

void horizFlow

(

int

step

)

Horizontal raster fluxes.

Flows of water and dissolved/suspended constituents (phosphorus, salt/tracer) among cells and in water management network.

Parameters:

step

The current iteration number

Definition at line 682 of file UnitMod.c.

References DINdummy, Flux_GWater(), Flux_SWater(), HP_HYD_POROSITY, HP_HYD_SPEC_YIELD, hyd_iter, HYD_MANNINGS_N, HYD_RCCONDUCT, msgStr, ON_MAP, Run_Canal_Network(), s0, s1, SALT_SED_WT, SALT_SURF_WT, SAT_WATER, SED_ELEV, SF_WT_VEL_mag, SURFACE_WAT, T, TP_SED_WT, TP_SF_WT, UNSAT_WATER, usrErr0(), and WatMgmtOn.

Referenced by call_cell_dyn().

{
  int it;
  int ix, iy; 
 
  /* v2.7.0 adding velocity output capabilities */
  for(ix=1; ix<=s0; ix++) {
    for(iy=1; iy<=s1; iy++) {
      if(ON_MAP[T(ix,iy)])  SF_WT_VEL_mag[T(ix,iy)]=0.0; 
    }
  }

  for ( it = 0; it < hyd_iter; it++ )
  {
    sprintf(msgStr,"\b\b\b%3d",it); 
    usrErr0(msgStr);
       
    /* horizontal raster-vector canal fluxes and water management functions
       Water Management switch set at runtime in Driver.parm
       this routine also integrates surface, unsaturated, and saturated exchanges
     */
    /* Nitrogen (DINdummy) argument is dummy argument placeholder */
        if (WatMgmtOn  ) {
      Run_Canal_Network(SURFACE_WAT,SED_ELEV,HYD_MANNINGS_N,SAT_WATER,HP_HYD_POROSITY,
                        HYD_RCCONDUCT, DINdummy,TP_SF_WT,SALT_SURF_WT,DINdummy,TP_SED_WT,SALT_SED_WT,
                        UNSAT_WATER,HP_HYD_SPEC_YIELD ); 
    }
    

    /* Function for horiz fluxing of surface water, no exchange with sat/unsat water */
    /* if the order of the solute is changed, be sure to change the mass bal info in FluxSWstuff fcn */
    /* Nitrogen (DINdummy) argument is dummy argument placeholder */
    Flux_SWater(it,SURFACE_WAT,SED_ELEV,HYD_MANNINGS_N,SALT_SURF_WT,DINdummy,TP_SF_WT,SF_WT_VEL_mag);       
  
    /* Function for horiz fluxing of ground water and its vertical itegration with unsat and surface water 
       It is only called every other hyd_iter iteration, and passes the realized number of gwat iterations to the function.  
       If the order of the solutes is changed, be sure to change the mass bal info in FluxGWstuff fcn 
     */
    /* Nitrogen (DINdummy) argument is dummy argument placeholder */
    if ( it%2 ) 
      Flux_GWater((it-1)/2, SAT_WATER, UNSAT_WATER, SURFACE_WAT, HYD_RCCONDUCT, HP_HYD_POROSITY,
                   HP_HYD_SPEC_YIELD, SED_ELEV, SALT_SED_WT, DINdummy, TP_SED_WT, SALT_SURF_WT, DINdummy, TP_SF_WT);  

  }  /* end of hyd_iter */  
  
   /* v2.7.0 adding velocity output capabilities */
  for(ix=1; ix<=s0; ix++) {
    for(iy=1; iy<=s1; iy++) {
       SF_WT_VEL_mag[T(ix,iy)]= SF_WT_VEL_mag[T(ix,iy)] / hyd_iter / 2.0; /* v2.8.4 - no changes, but explored the /hyd_iter/2.0 etc */
     }
  }

}

Here is the call graph for this function:

void cell_dyn7

(

int

step

)

Hydrologic (vertical) dynamics.

Temporal dynamics of water storages (not including horizontal flows).

Parameters:

step

The current iteration number

Remarks:

The horizontal solutions (in horizFlow function) makes other vertical calcs to integrate the three vertical zones of water storage.

Definition at line 758 of file UnitMod.c.

References Abs, AIR_TEMP, boundcond_ETp, boundcond_rain, CELL_SIZE, debug, DT, dynERRORnum, Exp, GP_calibET, GP_DetentZ, GP_HYD_RCRECHG, GP_mann_height_coef, GP_SOLOMEGA, graph7(), graph8(), H2O_TEMP, HAB, HP_DOM_MAXDEPTH, HP_HYD_POROSITY, HP_HYD_RCINFILT, HP_HYD_SPEC_YIELD, HP_MAC_MAXROUGH, HP_MAC_MINROUGH, HP_NPHBIO_ROOTDEPTH, HYD_DOM_ACTWAT_PRES, HYD_DOM_ACTWAT_VOL, HYD_ET, HYD_EVAP_CALC, HYD_MANNINGS_N, HYD_SAT_POT_TRANS, HYD_SED_WAT_VOL, HYD_TOT_POT_TRANSP, HYD_TRANSP, HYD_UNSAT_POT_TRANS, HYD_WATER_AVAIL, HydRelDepPosNeg, HydTotHd, LAI_eff, MAC_HEIGHT, MAC_LAI, MAC_REL_BIOM, MAC_WATER_AVAIL_CF, Max, Min, msgStr, ON_MAP, s0, s1, SAT_TO_UNSAT_FL, SAT_VS_UNSAT, SAT_WATER, SAT_WT_HEAD, SAT_WT_RECHG, SAT_WT_TRANSP, SED_ELEV, SF_WT_EVAP, SF_WT_FROM_RAIN, SF_WT_INFILTRATION, SF_WT_POT_INF, SF_WT_TO_SAT_DOWNFLOW, SFWT_VOL, SimTime, SOLALPHA, SOLALTCORR, SOLBETA, SOLRAD274, SOLRADATMOS, SOLRADGRD, SURFACE_WAT, T, simTime::TIME, True, UNSAT_AVAIL, UNSAT_CAP, UNSAT_DEPTH, UNSAT_HYD_COND_CF, UNSAT_MOIST_PRP, UNSAT_PERC, UNSAT_TO_SAT_FL, UNSAT_TRANSP, UNSAT_WATER, UNSAT_WT_POT, and WriteMsg().

Referenced by call_cell_dyn().

 {
    int ix, iy, cellLoc; 
    float SatWat_Root_CF, field_cap; 
    float mann_height, N_density, f_LAI_eff, sfwat_pr1;
    float cloudy=0.0;
    
/* the horizontal raster and vector fluxes are always called before this cell_dyn */
    for(ix=1; ix<=s0; ix++) {
        for(iy=1; iy<=s1; iy++) {
            if(ON_MAP[cellLoc= T(ix,iy)])  {

              if (debug > 3) { /* these are old, relatively coarse checks - surface-ground water integration occurs in Fluxes.c */
                  if (SAT_WT_HEAD[cellLoc] - 0.01 > SED_ELEV[cellLoc] ) {
                      sprintf(msgStr,"Day %6.1f. Warning - SAT_WT_HEAD exceeds elev in cell (%d,%d) by %f.", 
                              SimTime.TIME, ix,iy,(SAT_WT_HEAD[cellLoc] - SED_ELEV[cellLoc]) ); 
                      WriteMsg( msgStr,True ); }
                  if (SURFACE_WAT[cellLoc] > 0.2 && UNSAT_DEPTH[cellLoc] > 0.1 ) {
                      sprintf(msgStr,"Day: %6.1f.  Warning - large sfwat depth (%5.2f m) in presence of unsat= %5.2f m, %4.2f %% moist, in cell (%d,%d).", 
                              SimTime.TIME, SURFACE_WAT[cellLoc], UNSAT_DEPTH[cellLoc],UNSAT_MOIST_PRP[cellLoc], ix,iy ); 
                      WriteMsg( msgStr,True );  }
                  if (SAT_WATER[cellLoc] < -0.01) { /* this seems unnecessary but... */
                      sprintf(msgStr,"Day %6.1f: capacityERR - neg SAT_WATER (%f m) in cell (%d,%d) before cell_dyn7!", 
                              SimTime.TIME, SAT_WATER[cellLoc], ix,iy ); 
                      WriteMsg( msgStr,True );  dynERRORnum++; }
                  if (SURFACE_WAT[cellLoc] < -0.01) {
                      sprintf(msgStr,"Day %6.1f: capacityERR - neg SURFACE_WAT (%f m) in cell (%d,%d) before cell_dyn7!", 
                              SimTime.TIME, SURFACE_WAT[cellLoc], ix,iy ); 
                      WriteMsg( msgStr,True );  dynERRORnum++; }
              }

/*  note that rainfall during a time step is added to surface water storage and available */
/* for runoff (horizFlow) before the calc of infiltration & ET associated with that new input */
/* (infiltration/ET etc will be of avail water the next time step after a rainfall event and horiz flows) */
                  /* NSM/SFWMM rainfall input data, created in cell_dyn1, convert here from tenths of mm to meters */
              SF_WT_FROM_RAIN[cellLoc] = boundcond_rain[cellLoc]*0.0001;  /*  tenths of mm *0.0001 = m */

              /* solar radiation at altitude of 274m in atmosphere cal/cm2/d) */
              /* v2.2+, CLOUDY (cloudiness) spatiotemporal data "temporarily" unavailable, is constant in space and time, local var "cloudy" */
              SOLRAD274[cellLoc] = SOLRADATMOS*(SOLBETA-GP_SOLOMEGA* ( ( cloudy>0.0 ) ? ( cloudy ) : ( 0.0) ) ) -SOLALPHA;
              SOLRADGRD[cellLoc] = SOLRAD274[cellLoc]+((SOLRADATMOS+1.0)-SOLRAD274[cellLoc])*SOLALTCORR;
              H2O_TEMP[cellLoc] = AIR_TEMP[cellLoc]; /* v2.2+, temperature data "temporarily" unavailable, is constant in space and time */
              
/******** determine new unsat potentials */
              SAT_WT_HEAD[cellLoc]  = SAT_WATER[cellLoc]/HP_HYD_POROSITY[HAB[cellLoc]];
              UNSAT_DEPTH[cellLoc]  = SED_ELEV[cellLoc]-SAT_WT_HEAD[cellLoc];
              UNSAT_CAP[cellLoc]  =  UNSAT_DEPTH[cellLoc]*HP_HYD_POROSITY[HAB[cellLoc]];
          
              UNSAT_MOIST_PRP[cellLoc]  = 
                  ( UNSAT_CAP[cellLoc]>0.0 ) ? 
                  ( Min(UNSAT_WATER[cellLoc]/UNSAT_CAP[cellLoc],1.0) ) : 
                  ( 1.0); 
                  /* determining the pathway of flow of surface water depending on depth
                     of an unsat zone relative to the surface water  */ 
              SAT_VS_UNSAT[cellLoc]  = 1/Exp(100.0*Max((SURFACE_WAT[cellLoc]-UNSAT_DEPTH[cellLoc]),0.0)); 
     /* empirical data of a (0-1) control function, the proportion of maximum vertical water infiltration rate through soil (dependent var) as a function of soil moisture proportion (0-1)  (independent var) */
              UNSAT_HYD_COND_CF[cellLoc]  = graph7(0x0,UNSAT_MOIST_PRP[cellLoc] ); 
                     /* field capacity = porosity - specific yield; spec yield== proportion of total soil vol
                            that represents water that can be moved by gravity */
              field_cap = (HP_HYD_POROSITY[HAB[cellLoc]]-HP_HYD_SPEC_YIELD[HAB[cellLoc]]);
                  /* unsat_avail is proportion of water in pore space available for gravitational flow (above field capacity) */
                  /* e.g., when moisture prop in pore space <= field_cap/pore_space, no percolation */
                  /* using old moisture proportion (hasn't changed unless unsat zone was replaced by sat water) */
              UNSAT_AVAIL[cellLoc]  = Max(UNSAT_MOIST_PRP[cellLoc]
                                          -(field_cap)/HP_HYD_POROSITY[HAB[cellLoc]],0.0);
              UNSAT_WT_POT[cellLoc]  = Max(UNSAT_CAP[cellLoc]-UNSAT_WATER[cellLoc],0.0);

/******** now determine the potential total transpiration and evaporation  */
/* Potential ET is input data used in SFWMM v5.4 */
/* GP_calibET is an adjustable calibration parameter (close to 1.0, adjusted in global parameter input file)  */
             HYD_EVAP_CALC[cellLoc]  =  boundcond_ETp[cellLoc] * 0.0001*GP_calibET;  /*  tenths of mm *0.0001 = m */

    /*  Leaf Area Index (LAI) of emergent macrophytes: this effective LAI estimates leaf area index that is above ponded surface water  */
              LAI_eff[cellLoc] =  
                  (MAC_HEIGHT[cellLoc]>0.0) ? 
                  (Max(1.0 - SURFACE_WAT[cellLoc]/MAC_HEIGHT[cellLoc], 0.0)*MAC_LAI[cellLoc]) : 
                  (0.0)  ;
 
          /* control function (0-1) of relative magnitude of the effective Leaf Area Index  */
              f_LAI_eff = exp(-LAI_eff[cellLoc]); 
              
              
              HYD_TOT_POT_TRANSP[cellLoc]  = HYD_EVAP_CALC[cellLoc] * (1.0-f_LAI_eff); 

     /* 0-1 control function of saturated water available to roots - capillary draw when roots don't quite reach down to water table */
              SatWat_Root_CF =  Exp(-10.0* Max(UNSAT_DEPTH[cellLoc]-HP_NPHBIO_ROOTDEPTH[HAB[cellLoc]],0.0) ); 
     /*  HYDrologic, control function (0-1) of proportion of WATer in upper soil profile that is AVAILable for plant uptake, including unsaturated storage withdrawal, and small capillary withdrawal from saturated storage, depending on relative depths */
              HYD_WATER_AVAIL[cellLoc]  = (UNSAT_DEPTH[cellLoc] > HP_NPHBIO_ROOTDEPTH[HAB[cellLoc]] ) ? 
                  ( Max(UNSAT_MOIST_PRP[cellLoc], SatWat_Root_CF) ) :
                  ( 1.0 ); 
    /* empirical data of a (0-1) control function, the proportion of water available to plants (dependent var) as a function of proportion (0-1) of water available upper soil profile (independent var) (generally, simply 1:1 relationship) */
              MAC_WATER_AVAIL_CF[cellLoc]  = graph8(0x0,HYD_WATER_AVAIL[cellLoc]); 

/******** next calc the potential and actual flows */
/* unsatLoss(1) unsat to sat percolation */
  /*unsat to sat flow here only includes percolation (rising water table accomodated in update after horiz fluxes) */ 
              UNSAT_PERC[cellLoc]  = Min(HP_HYD_RCINFILT[HAB[cellLoc]]*UNSAT_HYD_COND_CF[cellLoc],UNSAT_AVAIL[cellLoc]*UNSAT_WATER[cellLoc]);
              UNSAT_TO_SAT_FL[cellLoc]  =  
                  ( (UNSAT_PERC[cellLoc])*DT > UNSAT_WATER[cellLoc] ) ? 
                  ( UNSAT_WATER[cellLoc]/DT ) : 
                  ( UNSAT_PERC[cellLoc]);
/* unsatLoss(2) unsat to atmosph transpiration */
              HYD_UNSAT_POT_TRANS[cellLoc]  = (UNSAT_DEPTH[cellLoc] > HP_NPHBIO_ROOTDEPTH[HAB[cellLoc]] ) ?
                  ( HYD_TOT_POT_TRANSP[cellLoc]*MAC_WATER_AVAIL_CF[cellLoc] ) :
                  (0.0); /* no unsat transp if roots are in saturated zone */
              UNSAT_TRANSP[cellLoc]  = 
                  ( (HYD_UNSAT_POT_TRANS[cellLoc]+UNSAT_TO_SAT_FL[cellLoc])*DT>UNSAT_WATER[cellLoc] ) ? 
                  ( (UNSAT_WATER[cellLoc]-UNSAT_TO_SAT_FL[cellLoc]*DT)/DT ) : 
                  ( HYD_UNSAT_POT_TRANS[cellLoc]);

/* satLoss(1) sat to deep aquifer recharge **RATE parameter IS ALWAYS SET to ZERO  *****/
              SAT_WT_RECHG[cellLoc]  = 
                  ( GP_HYD_RCRECHG*HP_HYD_SPEC_YIELD[HAB[cellLoc]]/HP_HYD_POROSITY[HAB[cellLoc]]*DT>SAT_WATER[cellLoc] ) ? 
                  ( SAT_WATER[cellLoc]/DT ) : 
                  ( GP_HYD_RCRECHG*HP_HYD_SPEC_YIELD[HAB[cellLoc]]/HP_HYD_POROSITY[HAB[cellLoc]]); 
                 
/* sat to surf upflow  when gwater exceeds soil capacity due to lateral inflows
   accomodated in gwFluxes */

/* satLoss(2) sat to unsat with lowering water table due to recharge loss ONLY (horiz outflows accomodated in gwFluxes)
   (leaves field capacity amount in unsat zone)*/
              SAT_TO_UNSAT_FL[cellLoc]  =  
                  ( SAT_WT_RECHG[cellLoc]*field_cap/HP_HYD_POROSITY[HAB[cellLoc]]*DT > SAT_WATER[cellLoc] ) ? 
                  ( (SAT_WATER[cellLoc])/DT ) : 
                  ( SAT_WT_RECHG[cellLoc]*field_cap/HP_HYD_POROSITY[HAB[cellLoc]]) ;
/* satLoss(3) sat to atmosph */
              HYD_SAT_POT_TRANS[cellLoc]  = HYD_TOT_POT_TRANSP[cellLoc]*SatWat_Root_CF; 
              SAT_WT_TRANSP[cellLoc]  =  
                  ( (HYD_SAT_POT_TRANS[cellLoc]+SAT_TO_UNSAT_FL[cellLoc])*DT > SAT_WATER[cellLoc] ) ? 
                  ( (SAT_WATER[cellLoc]-SAT_TO_UNSAT_FL[cellLoc]*DT)/DT ) : 
                  ( HYD_SAT_POT_TRANS[cellLoc]);

/* sfwatLoss(1) sf to sat */
                     /* downflow to saturated assumed to occur in situations with small
                        unsat layer overlain by significant surface water (SAT_VS_UNSAT very small),
                        with immediate hydraulic connectivity betweent the two storages */
              SF_WT_TO_SAT_DOWNFLOW[cellLoc]  = 
                  ( (1.0-SAT_VS_UNSAT[cellLoc])*UNSAT_WT_POT[cellLoc]*DT>SURFACE_WAT[cellLoc] ) ? 
                  ( SURFACE_WAT[cellLoc]/DT ) : 
                  ( (1.0-SAT_VS_UNSAT[cellLoc])*UNSAT_WT_POT[cellLoc]); 
/* sfwatLoss(2) sf to unsat infiltration (sat_vs_unsat splits these losses to groundwater, but downflow to sat is given priority) */
              SF_WT_POT_INF[cellLoc]  = 
                  ( (SAT_VS_UNSAT[cellLoc]*HP_HYD_RCINFILT[HAB[cellLoc]]+SF_WT_TO_SAT_DOWNFLOW[cellLoc])*DT>SURFACE_WAT[cellLoc] ) ? 
                  ( (SURFACE_WAT[cellLoc]-SF_WT_TO_SAT_DOWNFLOW[cellLoc]*DT)/DT ) : 
                  ( SAT_VS_UNSAT[cellLoc]*HP_HYD_RCINFILT[HAB[cellLoc]]);
              SF_WT_INFILTRATION[cellLoc]  = 
                  ( SF_WT_POT_INF[cellLoc]*DT > (UNSAT_WT_POT[cellLoc]-SF_WT_TO_SAT_DOWNFLOW[cellLoc]*DT) ) ? 
                  ((UNSAT_WT_POT[cellLoc]-SF_WT_TO_SAT_DOWNFLOW[cellLoc]*DT)/DT ) : 
                  ( SF_WT_POT_INF[cellLoc]);
              sfwat_pr1 = SF_WT_INFILTRATION[cellLoc]+SF_WT_TO_SAT_DOWNFLOW[cellLoc];
/* sfwatLoss(3) sf to atmosph */
              SF_WT_EVAP[cellLoc]  =  
                  ( (f_LAI_eff*HYD_EVAP_CALC[cellLoc]+sfwat_pr1 )*DT>SURFACE_WAT[cellLoc] ) ? 
                  ( (SURFACE_WAT[cellLoc]-sfwat_pr1*DT)/DT ) : 
                  ( f_LAI_eff*HYD_EVAP_CALC[cellLoc]); 


/******** then update the state variable storages */

/* unsat loss priority:  percolation,  transpiration */
/* calc unsaturated storage state var (m) */
              UNSAT_WATER[cellLoc] = UNSAT_WATER[cellLoc] 
                  + (SAT_TO_UNSAT_FL[cellLoc] + SF_WT_INFILTRATION[cellLoc] 
                     - UNSAT_TO_SAT_FL[cellLoc] - UNSAT_TRANSP[cellLoc]) * DT;

/* sat loss priority:  recharge to deep aquifer, re-assign to unsat with lowered water table, transpiration */
/* calc saturated storage state var (m) */
              SAT_WATER[cellLoc] =  SAT_WATER[cellLoc] 
                  + (UNSAT_TO_SAT_FL[cellLoc] + SF_WT_TO_SAT_DOWNFLOW[cellLoc] 
                     - SAT_WT_TRANSP[cellLoc] - SAT_TO_UNSAT_FL[cellLoc] - SAT_WT_RECHG[cellLoc]) * DT;

/* sfwat loss priority: downflow to replace groundwater loss, infiltration to unsat, evaporation */
/* calc surface storage state var (m) */
              SURFACE_WAT[cellLoc] = SURFACE_WAT[cellLoc] 
                  + (SF_WT_FROM_RAIN[cellLoc]  
                     - SF_WT_EVAP[cellLoc] - SF_WT_INFILTRATION[cellLoc] - SF_WT_TO_SAT_DOWNFLOW[cellLoc]) * DT;

/******** lastly, update of head calcs, unsat capacity, moisture proportion, etc.
 in order to calc water in diff storages for solute concentrations */
              SAT_WT_HEAD[cellLoc]  = SAT_WATER[cellLoc]/HP_HYD_POROSITY[HAB[cellLoc]];
              UNSAT_DEPTH[cellLoc]  = Max(SED_ELEV[cellLoc]-SAT_WT_HEAD[cellLoc],0.0);
              UNSAT_CAP[cellLoc]  =  UNSAT_DEPTH[cellLoc]*HP_HYD_POROSITY[HAB[cellLoc]];

              UNSAT_MOIST_PRP[cellLoc]  = 
                  ( UNSAT_CAP[cellLoc]>0.0 ) ? 
                  ( Min(UNSAT_WATER[cellLoc]/UNSAT_CAP[cellLoc],1.0) ) : 
                  ( 1.0); 
              HYD_DOM_ACTWAT_VOL[cellLoc]  = ( Min(HP_DOM_MAXDEPTH[HAB[cellLoc]],UNSAT_DEPTH[cellLoc])*UNSAT_MOIST_PRP[cellLoc] +
                                               Max(HP_DOM_MAXDEPTH[HAB[cellLoc]]-UNSAT_DEPTH[cellLoc], 0.0)*HP_HYD_POROSITY[HAB[cellLoc]] )
                  *CELL_SIZE; 
                  /* flag for presence of small amount of water storage in the active zone must be present */ 
              HYD_DOM_ACTWAT_PRES[cellLoc]  = 
                  ( HYD_DOM_ACTWAT_VOL[cellLoc] > CELL_SIZE*GP_DetentZ ) ? 
                  ( 1.0 ) : ( 0.0); 
              HYD_SED_WAT_VOL[cellLoc]  = (SAT_WATER[cellLoc]+UNSAT_WATER[cellLoc])*CELL_SIZE;
              SFWT_VOL[cellLoc]  = SURFACE_WAT[cellLoc]*CELL_SIZE;

              HydTotHd[cellLoc]  = SAT_WT_HEAD[cellLoc]+SURFACE_WAT[cellLoc]; /* only used for reporting purposes */
              /* v2.8.2 new variable, for reporting purposes only: positive/negative water depth relative to land elevation (stage minus land elevation) */
              HydRelDepPosNeg[cellLoc] =  HydTotHd[cellLoc] - SED_ELEV[cellLoc];
              
                  /* at the square of xx% of the macrophyte's height, the manning's n
                     calc will indicate the macrophyte *starting* to bend over,
                     starting to offer increasingly less resistance */
              mann_height = (GP_mann_height_coef*MAC_HEIGHT[cellLoc])*(GP_mann_height_coef*MAC_HEIGHT[cellLoc]); 
              N_density = Max(HP_MAC_MAXROUGH[HAB[cellLoc]] * MAC_REL_BIOM[cellLoc], HP_MAC_MINROUGH[HAB[cellLoc]] );
                  /* manning's n for overland (horiz) flow */
              mann_height = Max(mann_height,0.01); /* ensure that even in absence of veg, there is  miniscule (1 cm in model grid cell) height related to some form of veg */   
              HYD_MANNINGS_N[cellLoc]  = Max(-Abs((N_density-HP_MAC_MINROUGH[HAB[cellLoc]])
                                                  *(pow(2.0,(1.0-SURFACE_WAT[cellLoc]/mann_height))-1.0) ) 
                                             + N_density,HP_MAC_MINROUGH[HAB[cellLoc]]);

                  /* sum of transpiration for output only */
              HYD_TRANSP[cellLoc]  = UNSAT_TRANSP[cellLoc]+SAT_WT_TRANSP[cellLoc];
              HYD_ET[cellLoc]  = HYD_TRANSP[cellLoc]+SF_WT_EVAP[cellLoc];

            }
  }
    }
 }

Here is the call graph for this function:

void cell_dyn8

(

int

step

)

Macrophyte (vertical) dynamics.

Temporal dynamics of carbon and phosphorus including growth, mortality, etc of macrophyte community

Parameters:

step

The current iteration number

Definition at line 1002 of file UnitMod.c.

References AIR_TEMP, CELL_SIZE, conv_kgTOg, conv_kgTOmg, debug, DT, dynERRORnum, Exp, GP_MAC_REFUG_MULT, GP_mac_uptake_coef, GP_MinCheck, HAB, HP_MAC_KSP, HP_MAC_LIGHTSAT, HP_MAC_MAXHT, HP_MAC_MAXLAI, HP_MAC_SALIN_THRESH, HP_MAC_TEMPOPT, HP_MAC_TRANSLOC_RC, HP_MAC_WAT_TOLER, HP_NPHBIO_IC_CTOOM, HP_NPHBIO_IC_PC, HP_NPHBIO_MAX, HP_PHBIO_IC_CTOOM, HP_PHBIO_IC_PC, HP_PHBIO_MAX, HP_PHBIO_RCMORT, HP_PHBIO_RCNPP, HYD_DOM_ACTWAT_PRES, HYD_DOM_ACTWAT_VOL, HYD_SED_WAT_VOL, MAC_HEIGHT, MAC_LAI, MAC_LIGHT_CF, MAC_MAX_BIO, MAC_NOPH_BIOMAS, mac_nph_CtoOM, mac_nph_OM, mac_nph_P, mac_nph_PC, mac_nph_PC_rep, MAC_NUT_CF, MAC_PH_BIOMAS, mac_ph_CtoOM, mac_ph_OM, mac_ph_P, mac_ph_PC, mac_ph_PC_rep, MAC_PROD_CF, MAC_REL_BIOM, MAC_SALT_CF, MAC_TEMP_CF, MAC_TOT_BIOM, MAC_WATER_AVAIL_CF, MAC_WATER_CF, Max, Min, msgStr, NPHBIO_AVAIL, NPHBIO_MORT, nphbio_mort_OM, nphbio_mort_P, NPHBIO_MORT_POT, NPHBIO_REFUGE, NPHBIO_SAT, nphbio_transl_OM, nphbio_transl_P, NPHBIO_TRANSLOC, NPHBIO_TRANSLOC_POT, ON_MAP, PHBIO_AVAIL, PHBIO_MORT, phbio_mort_OM, phbio_mort_P, PHBIO_MORT_POT, PHBIO_NPP, phbio_npp_OM, phbio_npp_P, PHBIO_REFUGE, PHBIO_SAT, phbio_transl_OM, phbio_transl_P, PHBIO_TRANSLOC, PHBIO_TRANSLOC_POT, s0, s1, SAL_SED_WT, SAL_SF_WT, salinLow, SimTime, SOLRADGRD, SURFACE_WAT, T, tempCF(), simTime::TIME, TP_SED_CONC, TP_SED_WT, TP_SED_WT_AZ, TP_SEDWT_CONCACT, TP_SEDWT_CONCACTMG, TP_SEDWT_UPTAKE, True, and WriteMsg().

Referenced by call_cell_dyn().

 {
int ix, iy, cellLoc; 
float reduc, NPP_P, min_litTemp, nphbio_ddep, phbio_ddep, MAC_PHtoNPH, MAC_PHtoNPH_Init;
float Sal_Mean;
#define salinLow 0.1 /* v2.8.5 minimal salinity value (mg/L=ppt), below which growth isn't really affected for any macrophyre species */


  for(ix=1; ix<=s0; ix++) {
  for(iy=1; iy<=s1; iy++) {

    if(ON_MAP[cellLoc= T(ix,iy)])  { 
              
/* these thresholds need updating when a habitat type of a grid cell changes */
      MAC_MAX_BIO[cellLoc] = HP_NPHBIO_MAX[HAB[cellLoc]]+HP_PHBIO_MAX[HAB[cellLoc]];
      NPHBIO_REFUGE[cellLoc] = HP_NPHBIO_MAX[HAB[cellLoc]]*GP_MAC_REFUG_MULT;
      NPHBIO_SAT[cellLoc] = HP_NPHBIO_MAX[HAB[cellLoc]]*0.9;
      PHBIO_REFUGE[cellLoc] = HP_PHBIO_MAX[HAB[cellLoc]]*GP_MAC_REFUG_MULT;
      PHBIO_SAT[cellLoc] = HP_PHBIO_MAX[HAB[cellLoc]]*0.9;
/* various control functions for production calc */
     MAC_LIGHT_CF[cellLoc]  = SOLRADGRD[cellLoc]/HP_MAC_LIGHTSAT[HAB[cellLoc]]
         *Exp(1.0-SOLRADGRD[cellLoc]/HP_MAC_LIGHTSAT[HAB[cellLoc]]);
     MAC_TEMP_CF[cellLoc]  = tempCF(0, 0.20, HP_MAC_TEMPOPT[HAB[cellLoc]], 5.0, 40.0, AIR_TEMP[cellLoc]);
     HP_MAC_WAT_TOLER[HAB[cellLoc]] = Max(HP_MAC_WAT_TOLER[HAB[cellLoc]],0.005); /* water tolerance is supposed to be non-zero; set to 5mm if user input a 0 */
     MAC_WATER_CF[cellLoc]  = Min(MAC_WATER_AVAIL_CF[cellLoc], 
         Max(1.0-Max( (SURFACE_WAT[cellLoc]-HP_MAC_WAT_TOLER[HAB[cellLoc]])
         /HP_MAC_WAT_TOLER[HAB[cellLoc]],0.0),0.0));
     MAC_NUT_CF[cellLoc]  = 
                     Exp(-GP_mac_uptake_coef * Max(HP_MAC_KSP[HAB[cellLoc]]-TP_SEDWT_CONCACTMG[cellLoc], 0.0)
                         /HP_MAC_KSP[HAB[cellLoc]]) ; /* mg/L */
/* v2.8.5, re-instituted use of salinity control on mac production */
/* NOTE the placeholder salinity CF here !!! */
     Sal_Mean  = (SAL_SED_WT[cellLoc]+SAL_SF_WT[cellLoc])/2.0; 
     MAC_SALT_CF[cellLoc]  =  (Sal_Mean > HP_MAC_SALIN_THRESH[HAB[cellLoc]]) ? (Max(1.0-0.1*Sal_Mean/HP_MAC_SALIN_THRESH[HAB[cellLoc]],0.0) ) : (1.0);
     Max( 1.0-Max(Sal_Mean-(HP_MAC_SALIN_THRESH[HAB[cellLoc]]+salinLow),0.0)/(HP_MAC_SALIN_THRESH[HAB[cellLoc]]+salinLow), 0.0)  ; 

     min_litTemp = Min(MAC_LIGHT_CF[cellLoc], MAC_TEMP_CF[cellLoc]);
     MAC_PROD_CF[cellLoc]  = Min(min_litTemp,MAC_WATER_CF[cellLoc])
          *MAC_NUT_CF[cellLoc] *MAC_SALT_CF[cellLoc];
/* net primary production, kg C/m2/d */
     PHBIO_NPP[cellLoc]  = HP_PHBIO_RCNPP[HAB[cellLoc]]*MAC_PROD_CF[cellLoc]*MAC_PH_BIOMAS[cellLoc]
         * Max( (1.0-MAC_TOT_BIOM[cellLoc]/MAC_MAX_BIO[cellLoc]), 0.0);
/* P uptake is dependent on available P and relative to a maximum P:C ratio for the tissue (kg C/m^2/d * P:Cmax * dimless = kgP/m2/d ) */
     NPP_P = PHBIO_NPP[cellLoc]  * HP_PHBIO_IC_PC[HAB[cellLoc]]  * Max(MAC_NUT_CF[cellLoc]*2.0,1.0)
                     * Max(1.0-mac_ph_PC[cellLoc]/HP_PHBIO_IC_PC[HAB[cellLoc]], 0.0);
/* check for available P mass that will be taken up from sed water in active zone (nutCF does not); v2.5 constrained TP_SED_WT_AZ to pos */
     reduc = (NPP_P > 0.0) ? 
                     (Max(TP_SED_WT_AZ[cellLoc],0.0) / ( NPP_P*CELL_SIZE*DT) ) : /* within-plant variable stoichiometry */
                     (1.0);
    /* reduce the production proportionally if excess demand is found */
                /* can have high conc, but low mass of P avail, in presence of high plant biomass and high demand */
     if (reduc < 1.0) {
                     PHBIO_NPP[cellLoc] *= reduc;
                     NPP_P *= reduc;
                 }
                 
/* losses from photobio */
     phbio_ddep = Max(1.0-Max( (PHBIO_SAT[cellLoc]-MAC_PH_BIOMAS[cellLoc]) 
                                           /(PHBIO_SAT[cellLoc]-PHBIO_REFUGE[cellLoc]),0.0),0.0);
     PHBIO_AVAIL[cellLoc]  = MAC_PH_BIOMAS[cellLoc]*phbio_ddep;
     MAC_PHtoNPH_Init = HP_PHBIO_MAX[HAB[cellLoc]] / HP_NPHBIO_MAX[HAB[cellLoc]] ; /*if habitat type changes */
     MAC_PHtoNPH = (MAC_NOPH_BIOMAS[cellLoc]>0.0) ? ( MAC_PH_BIOMAS[cellLoc] / MAC_NOPH_BIOMAS[cellLoc]) : (MAC_PHtoNPH_Init);
                 
     NPHBIO_TRANSLOC_POT[cellLoc]  = (MAC_PHtoNPH>MAC_PHtoNPH_Init) ?
                     (exp(HP_MAC_TRANSLOC_RC[HAB[cellLoc]] *(MAC_PHtoNPH-MAC_PHtoNPH_Init)) - 1.0) :
                     (0.0); 
     NPHBIO_TRANSLOC[cellLoc]  =  
         ( (NPHBIO_TRANSLOC_POT[cellLoc])*DT >PHBIO_AVAIL[cellLoc] ) ? 
         ( (PHBIO_AVAIL[cellLoc])/DT ) : 
         ( NPHBIO_TRANSLOC_POT[cellLoc]);

     PHBIO_MORT_POT[cellLoc]  = HP_PHBIO_RCMORT[HAB[cellLoc]] *PHBIO_AVAIL[cellLoc] 
         *(1.0 + (1.0-MAC_WATER_AVAIL_CF[cellLoc]) )/2.0;
     PHBIO_MORT[cellLoc]  =
                                ( (PHBIO_MORT_POT[cellLoc]+NPHBIO_TRANSLOC[cellLoc])*DT>PHBIO_AVAIL[cellLoc] ) ? 
         ( (PHBIO_AVAIL[cellLoc]-NPHBIO_TRANSLOC[cellLoc]*DT)/DT ) : 
         ( PHBIO_MORT_POT[cellLoc]);


/* losses from non-photobio  */
     nphbio_ddep = Max(1.0-Max((NPHBIO_SAT[cellLoc]-MAC_NOPH_BIOMAS[cellLoc])
                                          /(NPHBIO_SAT[cellLoc]-NPHBIO_REFUGE[cellLoc]),0.0),0.0);
     NPHBIO_AVAIL[cellLoc]  = MAC_NOPH_BIOMAS[cellLoc]*nphbio_ddep; 

                 PHBIO_TRANSLOC_POT[cellLoc]  = (MAC_PHtoNPH<MAC_PHtoNPH_Init) ?
                     (exp(HP_MAC_TRANSLOC_RC[HAB[cellLoc]] *(MAC_PHtoNPH_Init-MAC_PHtoNPH)) - 1.0) :
                     (0.0); 
     PHBIO_TRANSLOC[cellLoc]  =  
         ( (PHBIO_TRANSLOC_POT[cellLoc])*DT >NPHBIO_AVAIL[cellLoc] ) ? 
         ( (NPHBIO_AVAIL[cellLoc])/DT ) : 
         ( PHBIO_TRANSLOC_POT[cellLoc]);
     NPHBIO_MORT_POT[cellLoc]  = NPHBIO_AVAIL[cellLoc]*HP_PHBIO_RCMORT[HAB[cellLoc]]
                     * (1.0 + Max(1.0-MAC_PH_BIOMAS[cellLoc]/HP_PHBIO_MAX[HAB[cellLoc]],0.0) )/2.0; /* decreased mort w/ increasing photobio */
     NPHBIO_MORT[cellLoc]  =
                                ( (PHBIO_TRANSLOC[cellLoc]+NPHBIO_MORT_POT[cellLoc])*DT>NPHBIO_AVAIL[cellLoc] ) ? 
         ( (NPHBIO_AVAIL[cellLoc]-PHBIO_TRANSLOC[cellLoc]*DT)/DT ) : 
         ( NPHBIO_MORT_POT[cellLoc]);
                 

/* calc nonphotosynthetic biomass state var (kgC/m2) */
     MAC_NOPH_BIOMAS[cellLoc] =  MAC_NOPH_BIOMAS[cellLoc] 
                     + (NPHBIO_TRANSLOC[cellLoc] - NPHBIO_MORT[cellLoc] 
                        - PHBIO_TRANSLOC[cellLoc]  ) * DT;
                 
/* calc nonphotosynthetic biomass state var (kgC/m2) */
     MAC_PH_BIOMAS[cellLoc] = MAC_PH_BIOMAS[cellLoc] 
         + (PHBIO_TRANSLOC[cellLoc] + PHBIO_NPP[cellLoc] 
           - PHBIO_MORT[cellLoc] - NPHBIO_TRANSLOC[cellLoc]) * DT;

/* total biomass */
     MAC_TOT_BIOM[cellLoc]  = MAC_PH_BIOMAS[cellLoc]+MAC_NOPH_BIOMAS[cellLoc];
/* book-keeping calcs used in other modules */
     MAC_REL_BIOM[cellLoc]  = 
         ( MAC_TOT_BIOM[cellLoc] > 0.0 ) ? 
         MAC_TOT_BIOM[cellLoc]/MAC_MAX_BIO[cellLoc] : 
         0.0001;
     MAC_HEIGHT[cellLoc]  = pow(MAC_REL_BIOM[cellLoc],0.33)*HP_MAC_MAXHT[HAB[cellLoc]];
     MAC_LAI[cellLoc]  = MAC_REL_BIOM[cellLoc]*HP_MAC_MAXLAI[HAB[cellLoc]];
/* note that an "effective" LAI that accounts for water depth is calc'd in hydro module */

/*  now calc the P and organic matter associated with the C fluxes */
                 phbio_npp_P[cellLoc] = NPP_P;     /* within-plant variable stoichiometry */
                 phbio_npp_OM[cellLoc] = PHBIO_NPP[cellLoc] / HP_PHBIO_IC_CTOOM[HAB[cellLoc]]; /* habitat-specfic stoichiometry */

                 phbio_mort_P[cellLoc] = PHBIO_MORT[cellLoc] * mac_ph_PC[cellLoc];
                 phbio_mort_OM[cellLoc] = PHBIO_MORT[cellLoc] / mac_ph_CtoOM[cellLoc];

                 phbio_transl_P[cellLoc] = PHBIO_TRANSLOC[cellLoc] * mac_nph_PC[cellLoc];
                 phbio_transl_OM[cellLoc] = PHBIO_TRANSLOC[cellLoc] / mac_nph_CtoOM[cellLoc];

                 nphbio_transl_P[cellLoc] = NPHBIO_TRANSLOC[cellLoc] * mac_ph_PC[cellLoc];
                 nphbio_transl_OM[cellLoc] = NPHBIO_TRANSLOC[cellLoc] / mac_ph_CtoOM[cellLoc];
                 
                 nphbio_mort_P[cellLoc] = NPHBIO_MORT[cellLoc] * mac_nph_PC[cellLoc];
                 nphbio_mort_OM[cellLoc] = NPHBIO_MORT[cellLoc] / mac_nph_CtoOM[cellLoc];


/* state vars: now calc the P and OM associated with those C state vars */
                 mac_nph_P[cellLoc] = mac_nph_P[cellLoc]
                     + (nphbio_transl_P[cellLoc] - nphbio_mort_P[cellLoc]
                        - phbio_transl_P[cellLoc]  ) * DT;
                 mac_nph_PC[cellLoc] = ( (MAC_NOPH_BIOMAS[cellLoc] > 0.0) && (mac_nph_P[cellLoc] > 0.0)) ?
                     (mac_nph_P[cellLoc] / MAC_NOPH_BIOMAS[cellLoc]) : /* these second mass checks not needed */
                     0.3 * HP_NPHBIO_IC_PC[HAB[cellLoc]]; /* default to 0.3 of max for habitat */
                 mac_nph_PC_rep[cellLoc] = (float)mac_nph_PC[cellLoc] * conv_kgTOmg; /* variable for output _rep-orting only */
                 

                 mac_nph_OM[cellLoc] = mac_nph_OM[cellLoc]
                     + (nphbio_transl_OM[cellLoc] - nphbio_mort_OM[cellLoc]
                        - phbio_transl_OM[cellLoc] ) * DT;
                 mac_nph_CtoOM[cellLoc] = ( (mac_nph_OM[cellLoc] > 0.0) && (MAC_NOPH_BIOMAS[cellLoc]>0.0)) ?
                     (MAC_NOPH_BIOMAS[cellLoc] / mac_nph_OM[cellLoc]) :
                     HP_NPHBIO_IC_CTOOM[HAB[cellLoc]];

                 mac_ph_P[cellLoc] = mac_ph_P[cellLoc]
                     + (phbio_transl_P[cellLoc] + phbio_npp_P[cellLoc] - phbio_mort_P[cellLoc]
                        - nphbio_transl_P[cellLoc] ) * DT;
                 mac_ph_PC[cellLoc] = ( (MAC_PH_BIOMAS[cellLoc] > 0.0) && (mac_ph_P[cellLoc]>0.0)) ?
                     (mac_ph_P[cellLoc] / MAC_PH_BIOMAS[cellLoc]) :
                     0.3 * HP_PHBIO_IC_PC[HAB[cellLoc]]; /* default to 0.3 of max for habitat */
                 mac_ph_PC_rep[cellLoc] = (float)mac_ph_PC[cellLoc] * conv_kgTOmg; /* variable for output _rep-orting only */

                 mac_ph_OM[cellLoc] = mac_ph_OM[cellLoc]
                     + (phbio_transl_OM[cellLoc] + phbio_npp_OM[cellLoc] - phbio_mort_OM[cellLoc]
                        - nphbio_transl_OM[cellLoc]  ) * DT;
                 mac_ph_CtoOM[cellLoc] = ( (mac_ph_OM[cellLoc] > 0.0) && (MAC_PH_BIOMAS[cellLoc]>0.0)) ?
                     (MAC_PH_BIOMAS[cellLoc] / mac_ph_OM[cellLoc]) :
                     HP_PHBIO_IC_CTOOM[HAB[cellLoc]];

                 if (debug > 0 && MAC_NOPH_BIOMAS[cellLoc] < -GP_MinCheck) { sprintf(msgStr,"Day %6.1f: ERROR - neg NPhoto C biomass (%f kg) in cell (%d,%d)!", 
                              SimTime.TIME, MAC_NOPH_BIOMAS[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}
                 if (debug > 0 && MAC_PH_BIOMAS[cellLoc] < -GP_MinCheck)  { sprintf(msgStr,"Day %6.1f: ERROR - neg Photo C biomass (%f kg) in cell (%d,%d)!", 
                              SimTime.TIME, MAC_PH_BIOMAS[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}
                 if (debug > 0 && mac_nph_P[cellLoc] < -GP_MinCheck) { sprintf(msgStr,"Day %6.1f: ERROR - neg NPhoto P biomass (%f kg) in cell (%d,%d)!", 
                              SimTime.TIME, mac_nph_P[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}
                 if (debug > 0 && mac_ph_P[cellLoc] < -GP_MinCheck)  { sprintf(msgStr,"Day %6.1f: ERROR - neg Photo P biomass (%f kg) in cell (%d,%d)!", 
                              SimTime.TIME, mac_ph_P[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}


/******** phosphorus removed from water here *************/
     TP_SEDWT_UPTAKE[cellLoc]  = phbio_npp_P[cellLoc]*CELL_SIZE; 
/* recalc P in sed water state variable (kg P) */
     TP_SED_WT[cellLoc] =  TP_SED_WT[cellLoc] - (TP_SEDWT_UPTAKE[cellLoc]) * DT;
     TP_SED_CONC[cellLoc] = (HYD_SED_WAT_VOL[cellLoc]>0.0) ?
                     (TP_SED_WT[cellLoc] / HYD_SED_WAT_VOL[cellLoc]) :
                  (0.0);
                 
                      /* this is the active zone, where uptake, sorption, and mineralization take place */
                TP_SED_WT_AZ[cellLoc] =  TP_SED_WT_AZ[cellLoc] - (TP_SEDWT_UPTAKE[cellLoc]) * DT;
                 TP_SEDWT_CONCACT[cellLoc] = ( HYD_DOM_ACTWAT_PRES[cellLoc] > 0.0) ?
                     ( TP_SED_WT_AZ[cellLoc]/HYD_DOM_ACTWAT_VOL[cellLoc] ) :
                     (TP_SED_CONC[cellLoc]); /* g/L */
                 TP_SEDWT_CONCACTMG[cellLoc]  = TP_SEDWT_CONCACT[cellLoc]*conv_kgTOg; /* g/m3==mg/L */
              
          }
  }
  }
}

Here is the call graph for this function:

void cell_dyn9

(

int

step

)

Phosphorus (vertical) dynamics.

Temporal dynamics of phosphorus in water and sorbed to soil.

Parameters:

step

The current iteration number

Definition at line 1218 of file UnitMod.c.

References CELL_SIZE, conv_gTOmg, conv_kgTOg, debug, DEPOS_ORG_MAT, DIM, DT, dynERRORnum, GP_DetentZ, GP_MinCheck, GP_PO4toTP, GP_PO4toTPint, GP_settlVel, GP_TP_DIFFCOEF, GP_TP_DIFFDEPTH, GP_TP_IN_RAIN, GP_TP_K_INTER, GP_TP_K_SLOPE, GP_TPpart_thresh, GP_WQualMonitZ, HYD_DOM_ACTWAT_PRES, HYD_DOM_ACTWAT_VOL, HYD_SED_WAT_VOL, Max, msgStr, ON_MAP, s0, s1, SF_WT_FROM_RAIN, SF_WT_INFILTRATION, SF_WT_TO_SAT_DOWNFLOW, SFWT_VOL, SimTime, SURFACE_WAT, T, simTime::TIME, TP_Act_to_Tot, TP_Atm_Depos, TP_AtmosDepos, TP_DNFLOW, TP_DNFLOW_POT, TP_K, TP_SED_CONC, TP_SED_WT, TP_SED_WT_AZ, TP_SEDWT_CONCACT, TP_SEDWT_CONCACTMG, TP_settl, TP_SF_WT, TP_SFWT_CONC, TP_SFWT_CONC_MG, TP_SORB, TP_SORB_POT, TP_SORBCONC, TP_SORBCONC_rep, TP_SORBTION, TP_UPFLOW, TP_UPFLOW_POT, True, usrErr(), and WriteMsg().

Referenced by call_cell_dyn().

 {
 int ix, iy, cellLoc; 
 float TPpartic, TPsettlRat, TP_settl_pot;
 double PO4Pconc, nonPO4Pconc;
 
  for(ix=1; ix<=s0; ix++) {
  for(iy=1; iy<=s1; iy++) {

    if(ON_MAP[cellLoc= T(ix,iy)])  {
/* calc concentrations after horiz fluxes */
              TP_SFWT_CONC[cellLoc]  = 
                  ( SFWT_VOL[cellLoc] > 0.0 ) ? 
                  ( TP_SF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
                  ( 0.0); /* used in P fluxes for mass balance */
             /* using regression for predicting PO4 from TP */
              PO4Pconc =  Max( TP_SFWT_CONC[cellLoc]*GP_PO4toTP + 0.001*GP_PO4toTPint,0.0);  /* g/l  (note that intercept may be <0)*/
      /* after spatial (horiz) fluxes, recalc the active zone P mass based on old active/total ratio */
              TP_SED_CONC[cellLoc] = (HYD_SED_WAT_VOL[cellLoc]>0.0) ?
                  (TP_SED_WT[cellLoc] / HYD_SED_WAT_VOL[cellLoc]) :
                  (0.0);
            /* this is the active zone, where uptake, sorption, and mineralization take place */
             TP_SED_WT_AZ[cellLoc] = TP_SED_CONC[cellLoc] * TP_Act_to_Tot[cellLoc] * HYD_DOM_ACTWAT_VOL[cellLoc];
              TP_SEDWT_CONCACT[cellLoc] =(HYD_DOM_ACTWAT_PRES[cellLoc] > 0.0) ?
                  ( TP_SED_WT_AZ[cellLoc]/HYD_DOM_ACTWAT_VOL[cellLoc] ) :
                  ( TP_SED_CONC[cellLoc]);

/* inputs to surf  P (kg P)  */
              /* v2.6, using negative-parameter switch in v2.8:
                - either use rainfall-based P deposition (parameter >= 0.0), 
                or spatially varying, temporally constant, daily rate of total deposition (used if conc parameter is negative)*/
              /* TODO - investigate methods/data for wet and dry deposition */
              TP_Atm_Depos[cellLoc]  = (GP_TP_IN_RAIN < 0.0) ? (TP_AtmosDepos[cellLoc]) : (SF_WT_FROM_RAIN[cellLoc]*CELL_SIZE*GP_TP_IN_RAIN*0.001) ; /* P deposition, kgP/day */

/* calc various loss and/or vertical exchange potentials (kg P) */
              /* diffusive flux */
              TP_UPFLOW_POT[cellLoc]  = /*  advective upflow has been handled in surf-ground integration in fluxes.c  */
                  Max((TP_SEDWT_CONCACT[cellLoc]-PO4Pconc)
                        *GP_TP_DIFFCOEF*8.64/GP_TP_DIFFDEPTH*CELL_SIZE,0.0); /* document this diffusion constant multiplier (involving conversion from sec/day) */
              TP_UPFLOW[cellLoc]  = 
                  ( (TP_UPFLOW_POT[cellLoc])*DT>TP_SED_WT_AZ[cellLoc] ) ? 
                  ( (TP_SED_WT_AZ[cellLoc])/DT ) : 
                  ( TP_UPFLOW_POT[cellLoc]);
                  /* units = mgP/L */
              TP_K[cellLoc]  = Max(GP_TP_K_SLOPE*TP_SORBCONC[cellLoc]+GP_TP_K_INTER,0.0);
/*fix rate */
              TP_SORB_POT[cellLoc]  = 
                  ( HYD_DOM_ACTWAT_PRES[cellLoc]>0.0 ) ? 
                  ( (double) 0.001 
                    *(TP_K[cellLoc]*(pow(Max(TP_SEDWT_CONCACT[cellLoc],0.0),0.8) )
                      *0.001*(DEPOS_ORG_MAT[cellLoc]*CELL_SIZE+DIM[cellLoc])-TP_SORB[cellLoc] ) ) : 
                  ( 0.0);
              if (TP_SORB_POT[cellLoc]>0.0) {
                  TP_SORBTION[cellLoc]  =  
                      ( (TP_SORB_POT[cellLoc]+TP_UPFLOW[cellLoc])*DT>TP_SED_WT_AZ[cellLoc] ) ? 
                      ( (TP_SED_WT_AZ[cellLoc]-TP_UPFLOW[cellLoc]*DT)/DT ) : 
                      ( TP_SORB_POT[cellLoc]);
              }
              else { /* neg sorption, loss from sorb variable*/
                  TP_SORBTION[cellLoc]  =  
                      ( (-TP_SORB_POT[cellLoc])*DT>TP_SORB[cellLoc] ) ? 
                      ( (-TP_SORB[cellLoc])/DT ) : 
                      ( TP_SORB_POT[cellLoc]);
              }
              
              /* diffusive + advective flux */
              TP_DNFLOW_POT[cellLoc]  = (SF_WT_INFILTRATION[cellLoc]+SF_WT_TO_SAT_DOWNFLOW[cellLoc])
                  *CELL_SIZE*TP_SFWT_CONC[cellLoc]   
                  + Max((PO4Pconc-TP_SEDWT_CONCACT[cellLoc])
                        *GP_TP_DIFFCOEF*8.64/GP_TP_DIFFDEPTH*CELL_SIZE,0.0) ;
              TP_DNFLOW[cellLoc]  =  
                  ( ( TP_DNFLOW_POT[cellLoc])*DT > TP_SF_WT[cellLoc] ) ? 
                  ( ( TP_SF_WT[cellLoc])/DT ) : 
                  ( TP_DNFLOW_POT[cellLoc]);
/* calc P in sed water state variables (kg P) */
              TP_SED_WT[cellLoc] =  TP_SED_WT[cellLoc] +
                  ( TP_DNFLOW[cellLoc] - TP_UPFLOW[cellLoc] - TP_SORBTION[cellLoc]) * DT;
             /* this is the active zone, where uptake, sorption, and mineralization take place */
              TP_SED_WT_AZ[cellLoc] =  TP_SED_WT_AZ[cellLoc] +
                  (TP_DNFLOW[cellLoc] - TP_UPFLOW[cellLoc] - TP_SORBTION[cellLoc]) * DT;

/* calc P in surface water state variable (kg P) */
              TP_SF_WT[cellLoc] = TP_SF_WT[cellLoc] + 
                  (TP_UPFLOW[cellLoc] + TP_Atm_Depos[cellLoc] 
                   - TP_DNFLOW[cellLoc]) * DT;

/* calc P sorbed-to-soil state variable (kg P) */
              TP_SORB[cellLoc] = TP_SORB[cellLoc] + (TP_SORBTION[cellLoc]) * DT;

              TP_SED_CONC[cellLoc] = (HYD_SED_WAT_VOL[cellLoc]>0.0) ?
                  (TP_SED_WT[cellLoc] / HYD_SED_WAT_VOL[cellLoc]) :
                  (0.0); /* g/L */
              TP_SEDWT_CONCACT[cellLoc] = ( HYD_DOM_ACTWAT_PRES[cellLoc] > 0.0) ?
                  ( TP_SED_WT_AZ[cellLoc]/HYD_DOM_ACTWAT_VOL[cellLoc] ) :
                  (TP_SED_CONC[cellLoc]); /* g/L */
              TP_SEDWT_CONCACTMG[cellLoc]  = TP_SEDWT_CONCACT[cellLoc]*conv_kgTOg; /* g/m^3==mg/L */

              TP_SORBCONC[cellLoc] = ((DEPOS_ORG_MAT[cellLoc]*CELL_SIZE + DIM[cellLoc])>0.0) ?
                  ( (double) TP_SORB[cellLoc]*conv_kgTOg / (DEPOS_ORG_MAT[cellLoc]*CELL_SIZE + DIM[cellLoc]) ) :
                  (0.0); /* gP/kgsoil */

              TP_SORBCONC_rep[cellLoc] = TP_SORBCONC[cellLoc] * conv_gTOmg; /* reporting purposes only (g/kg->mg/kg)*/

              TP_SFWT_CONC[cellLoc]  = 
                  ( SFWT_VOL[cellLoc] > 0.0 ) ? 
                  ( TP_SF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
                  ( 0.0); /* g/L used in P fluxes for mass balance */
              TP_SFWT_CONC_MG[cellLoc]  = 
                  ( SURFACE_WAT[cellLoc] > GP_WQualMonitZ ) ? 
                  (TP_SFWT_CONC[cellLoc]*conv_kgTOg) : 
                  (0.0); /* g/m^3==mg/L used for reporting and other modules to evaluate P conc when water is present */

/* the following is an empirical method to calculate settling of particulate P out of the water column
   into the sediments.  It uses the fixed ratio of PO4 to TP, but allows for a decreasing proportion of
   TP to be in (large) particulate form as TP concentration drops below a chosen threshold - the sum of
   the TP is considered to be dissolved plus large particulate plus small particulate (that cannot settle out) */
                  /* mass (kg) of particulate fraction of TP, available for settling to sediments */
                  /* using regression for predicting PO4 from TP */
              PO4Pconc =  Max(TP_SFWT_CONC_MG[cellLoc]*GP_PO4toTP + GP_PO4toTPint,0.0);  /* mg/l (note that intercept may be <0)*/
              nonPO4Pconc = Max(TP_SFWT_CONC_MG[cellLoc]-PO4Pconc,0.0); /* non-PO4 conc, mg/l */
              TPpartic = nonPO4Pconc * (1.0-exp(-nonPO4Pconc/GP_TPpart_thresh)) *0.001 * SFWT_VOL[cellLoc] ; /* kg particulate P */


                  /* settling rate, 1/d */
              TPsettlRat = ( SURFACE_WAT[cellLoc] > GP_DetentZ ) ?
                  (GP_settlVel/SURFACE_WAT[cellLoc]) :
                  0.0;
              
                  /* potential settling of particulate TP (kg/d) */
              TP_settl_pot = TPsettlRat * TPpartic;
              TP_settl[cellLoc]  =  
                  ( ( TP_settl_pot)*DT > TPpartic ) ? 
                  ( (TPpartic)/DT ) : 
                  ( TP_settl_pot);
/* calc P in surface water state variable (kg P) */
              TP_SF_WT[cellLoc] = TP_SF_WT[cellLoc] - TP_settl[cellLoc] * DT;

/* various book-keeping calcs used in other modules */
/* conc surf and sed wat = kgP/m3==gP/L, another var calc for mg/L */
              TP_SFWT_CONC[cellLoc]  = 
                  ( SFWT_VOL[cellLoc] > 0.0 ) ? 
                  ( TP_SF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
                  ( 0.0); /* used in P fluxes for mass balance */
              TP_SFWT_CONC_MG[cellLoc]  = 
                  ( SURFACE_WAT[cellLoc] > GP_WQualMonitZ ) ? 
                  (TP_SFWT_CONC[cellLoc]*conv_kgTOg) : 
                  (0.0); /* g/m3==mg/L used for reporting and other modules to evaluate P conc when water is present */
              
              if (debug > 0 && TP_SF_WT[cellLoc] < -GP_MinCheck) { sprintf(msgStr,"Day %6.1f: ERROR - neg TP_SF_WT (%f kg) in cell (%d,%d)!", 
                                                                    SimTime.TIME, TP_SF_WT[cellLoc], ix,iy ); WriteMsg( msgStr,True ); usrErr( msgStr ); dynERRORnum++; }
              if (debug > 0 && TP_SED_WT_AZ[cellLoc] < -GP_MinCheck)  { sprintf(msgStr,"Day %6.1f: ERROR - neg TP_SED_WT_AZ (%f kg) in cell (%d,%d)!", 
                                                                      SimTime.TIME, TP_SED_WT_AZ[cellLoc], ix,iy ); WriteMsg( msgStr,True ); usrErr( msgStr ); dynERRORnum++; }

    }
  }
  }
}

Here is the call graph for this function:

void cell_dyn10

(

int

step

)

Salt/tracer (vertical) dynamics.

This module can be used as a conservative tracer if salinity is not important to objectives; replicate this module if salinity and an independent, conservative tracer, are both desired.

Parameters:

step

The current iteration number

Definition at line 1473 of file UnitMod.c.

References CELL_SIZE, DT, GP_CL_IN_RAIN, GP_TP_DIFFCOEF, GP_TP_DIFFDEPTH, GP_WQualMonitZ, HYD_SED_WAT_VOL, Max, ON_MAP, s0, s1, SAL_SED_WT, SAL_SF_WT, SAL_SF_WT_mb, SALT_Atm_Depos, SALT_AtmosDepos, SALT_SED_TO_SF_FLOW, SALT_SED_WT, SALT_SFWAT_DOWNFL, SALT_SFWAT_DOWNFL_POT, SALT_SURF_WT, SF_WT_FROM_RAIN, SF_WT_INFILTRATION, SF_WT_TO_SAT_DOWNFLOW, SFWT_VOL, SURFACE_WAT, and T.

Referenced by call_cell_dyn().

 {
int ix, iy, cellLoc;
 double SALT_SED_TO_SF_FLOW_pot;
 

  for(ix=1; ix<=s0; ix++) {
  for(iy=1; iy<=s1; iy++) {

    if(ON_MAP[cellLoc= T(ix,iy)])  {
     SAL_SF_WT_mb[cellLoc]  = 
                     ( SFWT_VOL[cellLoc] > 0.0 ) ? 
                     ( SALT_SURF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
                     ( 0.0); /* used in salt fluxes for mass balance */
     SAL_SED_WT[cellLoc]  = 
                     ( HYD_SED_WAT_VOL[cellLoc]>0.0 ) ? 
                     ( SALT_SED_WT[cellLoc]/HYD_SED_WAT_VOL[cellLoc] ) : 
                     ( 0.0);
      /* v2.8:
         - either use rainfall-based salt (Cl) deposition (parameter >= 0.0), 
           or spatially varying, temporally constant, daily rate of total deposition (used if conc parameter is negative)*/
      /* TODO - investigate methods/data for wet and dry deposition */
              SALT_Atm_Depos[cellLoc]  = (GP_CL_IN_RAIN < 0.0) ? (SALT_AtmosDepos[cellLoc]) : (SF_WT_FROM_RAIN[cellLoc]*CELL_SIZE*GP_CL_IN_RAIN*0.001) ; /* chloride deposition, kgCl/day */

              /* diffusive + advective flux */ 
                 SALT_SFWAT_DOWNFL_POT[cellLoc]  = (SF_WT_INFILTRATION[cellLoc] + SF_WT_TO_SAT_DOWNFLOW[cellLoc])
                     * CELL_SIZE*SAL_SF_WT_mb[cellLoc]
                     + Max((SAL_SF_WT_mb[cellLoc]-SAL_SED_WT[cellLoc])
                           * GP_TP_DIFFCOEF*8.64/GP_TP_DIFFDEPTH*CELL_SIZE,0.0)  ; /* TODO: get cl diffusion parm; diffusion parms same as P */
     SALT_SFWAT_DOWNFL[cellLoc]  =  
                     ( SALT_SFWAT_DOWNFL_POT[cellLoc]*DT>SALT_SURF_WT[cellLoc] ) ? 
                     ( SALT_SURF_WT[cellLoc]/DT ) : 
                     ( SALT_SFWAT_DOWNFL_POT[cellLoc]);

              /* diffusive flux */  
                 SALT_SED_TO_SF_FLOW_pot  =  
                    /*  advective upflow has been handled in surf-ground integration in fluxes.c  */
                     Max((SAL_SED_WT[cellLoc]-SAL_SF_WT_mb[cellLoc])
                            *GP_TP_DIFFCOEF*8.64/GP_TP_DIFFDEPTH*CELL_SIZE,0.0)  ; /* TODO: get cl diffusion parm; diffusion parms same as P */
                 SALT_SED_TO_SF_FLOW[cellLoc]  =  
                     ( SALT_SED_TO_SF_FLOW_pot*DT>SALT_SED_WT[cellLoc] ) ? 
                     ( SALT_SED_WT[cellLoc]/DT ) : 
                     ( SALT_SED_TO_SF_FLOW_pot );
/* calc state vars (kg salt) */
     SALT_SED_WT[cellLoc] =  SALT_SED_WT[cellLoc]  
                     + (SALT_SFWAT_DOWNFL[cellLoc] - SALT_SED_TO_SF_FLOW[cellLoc]) * DT;

     SALT_SURF_WT[cellLoc] = SALT_SURF_WT[cellLoc] 
                     + (SALT_Atm_Depos[cellLoc] + SALT_SED_TO_SF_FLOW[cellLoc] - SALT_SFWAT_DOWNFL[cellLoc] ) * DT;

/* book-keeping concentration calcs, (kg/m3==g/L==ppt) used in other modules */
     SAL_SF_WT_mb[cellLoc]  = 
                     ( SFWT_VOL[cellLoc] > 0.0 ) ? 
                     ( SALT_SURF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
                     ( 0.0); /* used in salt fluxes for mass balance */
     SAL_SF_WT[cellLoc]  = 
                     ( SURFACE_WAT[cellLoc] > GP_WQualMonitZ ) ? 
                     ( SAL_SF_WT_mb[cellLoc]  ) : 
                     ( 0.0); /* used for reporting and other modules to evaluate salinity when water is present */
     SAL_SED_WT[cellLoc]  = 
                     ( HYD_SED_WAT_VOL[cellLoc]>0.0 ) ? 
                     ( SALT_SED_WT[cellLoc]/HYD_SED_WAT_VOL[cellLoc] ) : 
                     ( 0.0);

    }
  }
  }
                  
}

void cell_dyn12

(

int

step

)

FLOCculent organic matter (vertical) dynamics.

Temporal dynamics of carbon and phosphorus of flocculent organic matter of (top/overlying zone of) soil.

Parameters:

step

The current iteration number

Definition at line 1562 of file UnitMod.c.

References C_ALG_MORT, C_ALG_MORT_P, CELL_SIZE, conv_kgTOg, conv_kgTOmg, debug, DOM_TEMP_CF, DT, dynERRORnum, Exp, FLOC, FLOC_DECOMP, FLOC_DECOMP_POT, FLOC_DECOMP_QUAL_CF, FLOC_DEPO, FLOC_DEPO_POT, FLOC_FR_ALGAE, Floc_fr_phBio, FLOC_Z, FlocP, FlocP_DECOMP, FlocP_DEPO, FlocP_FR_ALGAE, FlocP_OM, FlocP_OMrep, FlocP_PhBio, GP_ALG_C_TO_OM, GP_calibDecomp, GP_DetentZ, GP_DOM_decomp_coef, GP_DOM_DECOMP_POPT, GP_DOM_RCDECOMP, GP_Floc_BD, GP_Floc_rcSoil, GP_FlocMax, GP_MinCheck, GP_TP_P_OM, GP_WQualMonitZ, HAB, HP_DOM_AEROBTHIN, HYD_DOM_ACTWAT_PRES, HYD_DOM_ACTWAT_VOL, HYD_SED_WAT_VOL, Max, msgStr, NC_ALG_MORT, NC_ALG_MORT_P, ON_MAP, phbio_mort_OM, phbio_mort_P, s0, s1, SFWT_VOL, SimTime, soil_MOIST_CF, SURFACE_WAT, T, simTime::TIME, TP_SED_CONC, TP_SED_MINER, TP_SED_WT, TP_SED_WT_AZ, TP_SEDWT_CONCACT, TP_SEDWT_CONCACTMG, TP_settl, TP_SF_WT, TP_SFWT_CONC, TP_SFWT_CONC_MG, TP_SFWT_MINER, True, UNSAT_DEPTH, UNSAT_MOIST_PRP, and WriteMsg().

Referenced by call_cell_dyn().

 {
 int ix, iy, cellLoc; 
 float FlocP_DECOMP_pot, FlocP_DEPO_pot, FlocP_settl, Floc_settl;
 
  for(ix=1; ix<=s0; ix++) {
  for(iy=1; iy<=s1; iy++) {

    if(ON_MAP[cellLoc= T(ix,iy)])  {
/* inputs (kg OM / m2)  */
                  /* all periphyton mortality goes to floc */
              FLOC_FR_ALGAE[cellLoc]  = (double) (C_ALG_MORT[cellLoc]+NC_ALG_MORT[cellLoc])
                  /GP_ALG_C_TO_OM*0.001 ; 
                  /* all photobiomass mortality goes to floc */
              Floc_fr_phBio[cellLoc]  = phbio_mort_OM[cellLoc];

             /* all settling from water column goes to floc */
              FlocP_settl = TP_settl[cellLoc] / CELL_SIZE; /* kg P/m2; */
                  /* the particulate P settling is assumed a fixed Redfield P:OM ratio */
              Floc_settl =   FlocP_settl / GP_TP_P_OM; 
                 
          
/* outputs (kg OM / m2) */
              FLOC_DECOMP_QUAL_CF[cellLoc]  = /* use the avg conc of sed and sf water here */
                  Exp(-GP_DOM_decomp_coef * Max(GP_DOM_DECOMP_POPT-
                                 (TP_SFWT_CONC_MG[cellLoc]+TP_SEDWT_CONCACTMG[cellLoc])/2.0, 0.0)
                      /GP_DOM_DECOMP_POPT) ; /* mg/L */
/* decomp in surface water has higher rate than in soil,
 assuming this stock is of much higer substrate quality than the total soil layer */
/* GP_calibDecomp is an adjustable calib parm */
              soil_MOIST_CF[cellLoc]  =  (UNSAT_DEPTH[cellLoc]>HP_DOM_AEROBTHIN[HAB[cellLoc]]) ?
                     ( Max(UNSAT_MOIST_PRP[cellLoc],0.0) ) :
                     ( 1.0 );
              FLOC_DECOMP_POT[cellLoc]  = GP_calibDecomp * 10.0*GP_DOM_RCDECOMP*FLOC[cellLoc]
                   *DOM_TEMP_CF[cellLoc] *FLOC_DECOMP_QUAL_CF[cellLoc] * soil_MOIST_CF[cellLoc];
              FLOC_DECOMP[cellLoc]  = 
                  ( (FLOC_DECOMP_POT[cellLoc])*DT>FLOC[cellLoc] ) ? 
                  ( (FLOC[cellLoc])/DT ) : 
                  ( FLOC_DECOMP_POT[cellLoc]);

/* the incorporation of the floc layer into the "true" soil layer occurs
   at a rate dependent on the floc depth under flooded conditions, then constant rate under dry conditions */
              FLOC_DEPO_POT[cellLoc]  = 
                  ( SURFACE_WAT[cellLoc] > GP_DetentZ ) ? 
                  ( FLOC_Z[cellLoc]/GP_FlocMax * FLOC[cellLoc]*GP_Floc_rcSoil ) : 
                  ( FLOC[cellLoc]*GP_Floc_rcSoil);
              FLOC_DEPO[cellLoc]  = 
                  ( (FLOC_DEPO_POT[cellLoc]+FLOC_DECOMP[cellLoc])*DT>FLOC[cellLoc] ) ? 
                  ( (FLOC[cellLoc]-FLOC_DECOMP[cellLoc]*DT)/DT ) : 
                  ( FLOC_DEPO_POT[cellLoc]); 
/* calc the state var (kg OM / m2) */
              FLOC[cellLoc] =  FLOC[cellLoc] 
                  + ( Floc_settl + Floc_fr_phBio[cellLoc] + FLOC_FR_ALGAE[cellLoc]
                      - FLOC_DECOMP[cellLoc] - FLOC_DEPO[cellLoc] ) * DT;

/* the depth of floc is dependent on a fixed floc bulk density */
              FLOC_Z[cellLoc] = (double) FLOC[cellLoc] / GP_Floc_BD ;
                 

/* Floc phosphorus (kg P / m2)  */
              FlocP_FR_ALGAE[cellLoc]  = (double) (NC_ALG_MORT_P[cellLoc]
                                          + C_ALG_MORT_P[cellLoc])*0.001; /* kg P/m2 */
              FlocP_PhBio[cellLoc] = phbio_mort_P[cellLoc] ;    

              FlocP_DECOMP_pot =  FLOC_DECOMP[cellLoc] * FlocP_OM[cellLoc];
              FlocP_DECOMP[cellLoc]  = 
                  ( (FlocP_DECOMP_pot)*DT>FlocP[cellLoc] ) ? 
                  ( (FlocP[cellLoc])/DT ) : 
                  ( FlocP_DECOMP_pot); 
              FlocP_DEPO_pot =  FLOC_DEPO[cellLoc] * FlocP_OM[cellLoc];
              FlocP_DEPO[cellLoc]  = 
                  ( (FlocP_DEPO_pot+FlocP_DECOMP[cellLoc])*DT>FlocP[cellLoc] ) ? 
                  ( (FlocP[cellLoc]-FlocP_DECOMP[cellLoc]*DT)/DT ) : 
                  ( FlocP_DEPO_pot); 
              
/* calc the state var (kg P / m2) */
              FlocP[cellLoc] =  FlocP[cellLoc] 
                  + ( FlocP_settl + FlocP_PhBio[cellLoc] + FlocP_FR_ALGAE[cellLoc]
                      - FlocP_DECOMP[cellLoc] - FlocP_DEPO[cellLoc] ) * DT;

              FlocP_OM[cellLoc] = ( FLOC[cellLoc]>0.0) ? (FlocP[cellLoc]/FLOC[cellLoc]) : (0.0); /* kgP/kgOM */
              FlocP_OMrep[cellLoc] = (float) FlocP_OM[cellLoc] * conv_kgTOmg; /* mgP/kgOM, variable for output _rep-orting only */
              
              if (debug > 0 && FLOC[cellLoc] < -GP_MinCheck) { sprintf(msgStr,"Day %6.1f: ERROR - neg FLOC OM biomass (%f kg/m2) in cell (%d,%d)!", 
                                                                    SimTime.TIME, FLOC[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}
              if (debug > 0 && FlocP[cellLoc] < -GP_MinCheck)  { sprintf(msgStr,"Day %6.1f: ERROR - neg FLOC P biomass (%f kg/m2) in cell (%d,%d)!", 
                                                                      SimTime.TIME, FlocP[cellLoc], ix,iy ); WriteMsg( msgStr,True ); dynERRORnum++;}

/* now the P gain in sediment pore water with decomp - 90% goes to porewater, 10% to sfwat */
              TP_SED_MINER[cellLoc]  =  0.90 * FlocP_DECOMP[cellLoc] * CELL_SIZE ; 
/* calc P in sed water state variables (kg P) */
              TP_SED_WT[cellLoc] =  TP_SED_WT[cellLoc] + 
                  (TP_SED_MINER[cellLoc]) * DT;
            /* this is the active zone, where uptake, sorption, and mineralization take place */
              TP_SED_WT_AZ[cellLoc] =  TP_SED_WT_AZ[cellLoc] + 
                  (TP_SED_MINER[cellLoc]) * DT;

              TP_SED_CONC[cellLoc] = (HYD_SED_WAT_VOL[cellLoc]>0.0) ?
                  (TP_SED_WT[cellLoc] / HYD_SED_WAT_VOL[cellLoc]) :
                  (0.0);
               TP_SEDWT_CONCACT[cellLoc] = ( HYD_DOM_ACTWAT_PRES[cellLoc] > 0.0) ?
                  ( TP_SED_WT_AZ[cellLoc]/HYD_DOM_ACTWAT_VOL[cellLoc] ) :
                  (TP_SED_CONC[cellLoc]);
              TP_SEDWT_CONCACTMG[cellLoc]  = TP_SEDWT_CONCACT[cellLoc]*conv_kgTOg; /* g/m3==mg/L */
              
              
/* now the P gain in surface water with decomp - 90% goes to porewater, 10% to sfwat */
              TP_SFWT_MINER[cellLoc]  = 0.10*FlocP_DECOMP[cellLoc] * CELL_SIZE ;  
/* calc P in surface water state variable (kg P) */
              TP_SF_WT[cellLoc] = TP_SF_WT[cellLoc] + 
                  (TP_SFWT_MINER[cellLoc]) * DT;
              TP_SFWT_CONC[cellLoc]  = 
                  ( SFWT_VOL[cellLoc] > 0.0 ) ? 
                  ( TP_SF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
                  ( 0.0); /* used in P fluxes for mass balance */
              TP_SFWT_CONC_MG[cellLoc]  = 
                  ( SURFACE_WAT[cellLoc] > GP_WQualMonitZ ) ? 
                  (TP_SFWT_CONC[cellLoc]*conv_kgTOg) : 
                  (0.0); /* g/m3==mg/L used for reporting and other modules to evaluate P conc when water is present */
    }
  }
  }
}

Here is the call graph for this function:

void cell_dyn13

(

int

step

)

Net settling of TP loss (stand-alone).

Emulates the Everglades Water Quality Model net settling rate algorithm for TP loss. The only dynamics are phosphorus input from rain and loss from settling out of water column. This should be run WITHOUT running ecological modules:
THIS SHOULD ONLY BE RUN WITH HYDROLOGY (& tracer/salt) - DO NOT RUN BIO/CHEM MODULES.

Parameters:

step

The current iteration number

Definition at line 1391 of file UnitMod.c.

References CELL_SIZE, conv_kgTOg, DT, GP_TP_IN_RAIN, GP_WQMthresh, GP_WQualMonitZ, ON_MAP, s0, s1, SF_WT_FROM_RAIN, SFWT_VOL, SURFACE_WAT, T, TP_Atm_Depos, TP_AtmosDepos, TP_settl, TP_settlDays, TP_SF_WT, TP_SFWT_CONC, TP_SFWT_CONC_MG, and WQMsettlVel.

Referenced by call_cell_dyn().

 {
 int ix, iy, cellLoc; 
 float TPsettlRat, TP_settl_pot;
 
  for(ix=1; ix<=s0; ix++) {
  for(iy=1; iy<=s1; iy++) { 

    if(ON_MAP[cellLoc= T(ix,iy)])  {
/* concentration of P in surface water used in P fluxes for mass transfer (kgP/m3==gP/L) */
              TP_SFWT_CONC[cellLoc]  = 
                  ( SFWT_VOL[cellLoc] > 0.0 ) ? 
                  ( TP_SF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
                  ( 0.0); 
/* inputs to surf  P (kg P)  */             
              /* see notes on changes, in cell_dyn9 module */
              TP_Atm_Depos[cellLoc]  = (GP_TP_IN_RAIN < 0.0) ? (TP_AtmosDepos[cellLoc]) : (SF_WT_FROM_RAIN[cellLoc]*CELL_SIZE*GP_TP_IN_RAIN*0.001) ; /* P deposition, kgP/day */

/* TP settling rate calculation (m/d) = 0 if water depth (m) less than depth threshold parm */
              if (SURFACE_WAT[cellLoc] > GP_WQMthresh ) {
                  TPsettlRat = WQMsettlVel[cellLoc];
                  TP_settlDays[cellLoc]++;
              }
              else
                  TPsettlRat = 0.0;
              
/* before we had to put in the day accumulator*/
/*               TPsettlRat = ( SURFACE_WAT[cellLoc] > GP_WQMthresh ) ?  */
/*                   (WQMsettlVel[cellLoc]) : 0.0; */
/* potential settling of particulate TP (m/d * m^2 * kg/m^3 = kg/d) */
              TP_settl_pot = TPsettlRat * CELL_SIZE * TP_SFWT_CONC[cellLoc];

/*  like EWQM, shows mass bal error when ->   TP_settl[cellLoc]  =   TP_settl_pot; */
              
/* constrain settling to be no more than kg P available in water column */
              TP_settl[cellLoc]  =   
                  ( ( TP_settl_pot)*DT > TP_SF_WT[cellLoc] ) ?  
                  ( (TP_SF_WT[cellLoc])/DT ) :  
                  ( TP_settl_pot); 
/* calc P in surface water state variable (kg P) */
              TP_SF_WT[cellLoc] = TP_SF_WT[cellLoc] +
                  ( TP_Atm_Depos[cellLoc] - TP_settl[cellLoc] ) * DT;

/* this was in EWQM!!! (mass balance error!):  if (TP_SF_WT[cellLoc]<0.0) TP_SF_WT[cellLoc]=0.0; */
              
/* concentration of P in surface water used in P fluxes for mass transfer (kgP/m3==gP/L) */
              TP_SFWT_CONC[cellLoc]  = 
                  ( SFWT_VOL[cellLoc] > 0.0 ) ? 
                  ( TP_SF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : 
                  ( 0.0); 
/* concentration used for reporting (e.g., in maps) when water is present. 
   Using a new (v2.8.4) depth parm also used for all
   concentration reporting thresholds
*/
              TP_SFWT_CONC_MG[cellLoc]  = 
                  ( SURFACE_WAT[cellLoc] > GP_WQualMonitZ ) ?  
                  (TP_SFWT_CONC[cellLoc]*conv_kgTOg) : 
                  (0.0);  /* g/m3==mg/L */
    }
  }
  }
}

float tempCF	(	int	form,
		float	c1,
		float	topt,
		float	tmin,
		float	tmax,
		float	tempC
	)

Temperature control function for biology.

Parameters:

	form	option of Lassiter or Jorgensen form of relationship
	c1	curvature parameter (Lassiter)
	topt	optimum temperature (C)
	tmin	minimum temperature (C)
	tmax	maximum temperature (C)
	tempC	current temperature (C)

Returns:

calculation of the result (dimless, 0-1)

Definition at line 1697 of file UnitMod.c.

References Abs, and Exp.

Referenced by cell_dyn2(), cell_dyn4(), cell_dyn8(), and init_eqns().

{
  if (form == 1) {
    /* Lassiter et al. 1975, where c1 = curvature parm */
    return (Exp(c1*(tempC-topt)) * pow(((tmax-tempC)/(tmax-topt)), (c1*(tmax-topt))) );
  }
  else {
    /* Jorgensen 1976 */
    return ( Exp(-2.3 * Abs((tempC-topt)/(topt-tmin))) );
  }
}

void init_static_data

(

void

)

Initialize static spatial data.

Definition at line 1710 of file UnitMod.c.

References alloc_mem_stats(), basn, BCondFlow, BIRinit(), BIRoutfiles(), ESPmodeON, ON_MAP, read_map_file(), usrErr(), usrErr0(), and WQMsettlVel.

{
  usrErr0("Acquiring static spatial data..."); /* console message */
  
  read_map_file("ModArea",ON_MAP,'c',4.0,0.0);            /* defines model area, dimless unsigned char attributes, value 1 set to 4, 0=0 */
  read_map_file("BoundCond",BCondFlow,'d',1.0,0.0);       /* boundary condition flow restrictions, dimless integer attributes */
            /* ONLY when running the EWQM settling rate version of ELM */
  if (ESPmodeON) read_map_file("basinSetVel",WQMsettlVel,'f',0.0001,0.0);       /* basin-based settling rates (data in tenths mm/d, converted to m/d) */
  read_map_file("basins",basn,'d',1.0,0.0);               /* Basins/Indicator-Region map, dimless integer attributes  */

  alloc_mem_stats (); /* allocate memory for budget & stats arrays (need to have read the Basin/Indicator-Region map first) */
  BIRinit(); /* Set up the Basin/Indicator-Region (BIR) linkages/inheritances */
  BIRoutfiles(); /* Basin/Indicator-Region output files */
  
  usrErr("Done.");
} 

Here is the call graph for this function:

void init_dynam_data

(

void

)

Initialize dynamic spatial data.

Definition at line 1729 of file UnitMod.c.

References Bathymetry, BulkD, DOM_BD, ELEVATION, HAB, HYD_RCCONDUCT, MAC_TOT_BIOM, read_map_file(), SURFACE_WAT, TP_AtmosDepos, TP_SEDWT_CONCACT, TPtoSOIL, UNSAT_DEPTH, usrErr(), and usrErr0().

{
  usrErr0("Acquiring dynamic spatial data..."); /* console message */
  
  read_map_file("Elevation",ELEVATION,'f',0.01,0.0);      /*  positive elevation relative to zero of vertical datum; input data in cm, converted to m; (prior to ELMv2.8, datum was always NGVD 1929; some apps in v2.8+ are in NAVD88; datum is independent of source code ) */
  read_map_file("HAB",HAB,'c',1.0,0.0);                   /* habitat (veg classifications, dimless unsigned char attributes) */
  read_map_file("icMacBio",MAC_TOT_BIOM,'f',0.015,0.0);      /* initial total biomass of macrophytes (data in xyz, converted to kg C/m2) */
  read_map_file("icSfWt",SURFACE_WAT,'f',0.01,0.0);       /* initial ponded surface water (data in cm, converted to m) */
  read_map_file("icUnsat",UNSAT_DEPTH,'f',0.01,0.0);      /* initial depth of unsaturated zone (data in cm, converted to m) */
  read_map_file("soilTP",TPtoSOIL,'f',0.000001,0.0);  /* soil TP map (data in mgP/kgSoil, converted to kgP/kgSoil) */
  read_map_file("soilBD",BulkD,'f',1.0,0.0);         /* soil bulk dens map (data in mgSoil/cm3 == kgSoil/m3)  */
  read_map_file("soil_orgBD",DOM_BD,'f',1.0,0.0);    /* organic soil bulk dens map (data in mgOM/cm3 == kgOM/m3)  */
  read_map_file("soilTPpore",TP_SEDWT_CONCACT,'f',0.000001,0.0);    /* porewater TP concentration map (data in ug/L, converted to g/L == kg/m3)  */
  read_map_file("AtmosPdepos",TP_AtmosDepos,'f',1.0,0.0);    /* rate of atmospheric deposition of total phosphorus (data in mgP/m^2/yr, convert units later with eqn inits)  */

  /* 2 static mapps need to be here for re-initialing w/ a multiplier (sensitivity analysis) */ 
  read_map_file("HydrCond",HYD_RCCONDUCT,'f',1.0,0.0);   /* hydraulic conductivity (no conversion, data in m/d)  */
  read_map_file("Bathymetry",Bathymetry,'f',0.01,0.0);      /* positive bathymetry (depth) relative to zero of vertical datum used in land elevation surveys (i.e., positive depth below NGVD29 or NAVD88); all positive depth data in cm, converted to m) */

  usrErr("Done."); /* console message */
} 

Here is the call graph for this function:

void init_eqns

(

void

)

Initialization of the model equations.

This calculates initial values of state variables, and which also provides constant values of pertinent flux equations if their corresponding cell_dyn module is not executed.

Definition at line 1757 of file UnitMod.c.

References Abs, AIR_TEMP, ALG_INCID_LIGHT, ALG_LIGHT_CF, ALG_LIGHT_EXTINCT, ALG_REFUGE, ALG_SAT, ALG_TEMP_CF, ALG_WAT_CF, Arctan, Bathymetry, boundcond_depth, boundcond_ETp, boundcond_rain, BulkD, C_ALG, C_ALG_AVAIL_MORT, C_ALG_GPP, C_ALG_MORT, C_ALG_MORT_POT, C_ALG_NPP, C_ALG_NUT_CF, C_ALG_P, C_ALG_PC, C_ALG_PROD_CF, C_ALG_RESP, C_ALG_RESP_POT, CELL_SIZE, conv_gTOmg, conv_kgTOg, conv_mgTOg, conv_mgTOkg, Cos, DAYJUL, DEPOS_ORG_MAT, DIM, DOM_BD, DOM_DECOMP, DOM_DECOMP_POT, DOM_P_OM, DOM_QUALITY_CF, DOM_SED_AEROB_Z, DOM_SED_ANAEROB_Z, DOM_TEMP_CF, DOM_Z, DOP, DOP_DECOMP, DT, ELEVATION, Exp, FLOC, FLOC_DECOMP, FLOC_DECOMP_POT, FLOC_DECOMP_QUAL_CF, FLOC_DEPO, FLOC_DEPO_POT, FLOC_Z, FlocP, FMOD(), GP_ALG_IC_MULT, GP_ALG_LIGHT_SAT, GP_ALG_PC, GP_ALG_RC_MORT, GP_ALG_RC_MORT_DRY, GP_ALG_RC_PROD, GP_ALG_RC_RESP, GP_ALG_REF_MULT, GP_ALG_SHADE_FACTOR, GP_ALG_TEMP_OPT, GP_AlgComp, GP_ALTIT, GP_C_ALG_KS_P, GP_calibGWat, GP_DATUM_DISTANCE, GP_DetentZ, GP_DOM_DECOMP_POPT, GP_DOM_DECOMP_TOPT, GP_DOM_DECOMPRED, GP_DOM_RCDECOMP, GP_Floc_BD, GP_HYD_IC_SFWAT_ADD, GP_HYD_IC_UNSAT_ADD, GP_HYD_ICUNSATMOIST, GP_HYD_RCRECHG, GP_IC_BATHY_MULT, GP_IC_BulkD_MULT, GP_IC_DOM_BD_MULT, GP_IC_ELEV_MULT, GP_IC_TPtoSOIL_MULT, GP_LATDEG, GP_MAC_IC_MULT, GP_MAC_REFUG_MULT, GP_NC_ALG_KS_P, GP_PO4toTP, GP_PO4toTPint, GP_SOLOMEGA, GP_sorbToTP, GP_TP_ICSFWAT, GP_WQualMonitZ, graph8(), H2O_TEMP, HAB, HP_ALG_MAX, HP_DOM_AEROBTHIN, HP_DOM_MAXDEPTH, HP_FLOC_IC, HP_FLOC_IC_CTOOM, HP_FLOC_IC_PC, HP_HYD_POROSITY, HP_HYD_RCINFILT, HP_MAC_KSP, HP_MAC_LIGHTSAT, HP_MAC_MAXHT, HP_MAC_MAXLAI, HP_MAC_MAXROUGH, HP_MAC_MINROUGH, HP_MAC_SALIN_THRESH, HP_MAC_TEMPOPT, HP_MAC_WAT_TOLER, HP_NPHBIO_IC_CTOOM, HP_NPHBIO_IC_PC, HP_NPHBIO_MAX, HP_NPHBIO_ROOTDEPTH, HP_PHBIO_IC_CTOOM, HP_PHBIO_IC_PC, HP_PHBIO_MAX, HP_PHBIO_RCMORT, HP_PHBIO_RCNPP, HP_SALT_ICSEDWAT, HP_SALT_ICSFWAT, HP_TP_CONC_GRAD, HYD_DOM_ACTWAT_PRES, HYD_DOM_ACTWAT_VOL, HYD_MANNINGS_N, HYD_RCCONDUCT, HYD_SED_WAT_VOL, HYD_WATER_AVAIL, Inorg_Z, LAI_eff, LATRAD, MAC_HEIGHT, MAC_LAI, MAC_LIGHT_CF, MAC_MAX_BIO, MAC_NOPH_BIOMAS, mac_nph_CtoOM, mac_nph_OM, mac_nph_P, mac_nph_PC, MAC_NUT_CF, MAC_PH_BIOMAS, mac_ph_CtoOM, mac_ph_OM, mac_ph_P, mac_ph_PC, MAC_PROD_CF, MAC_REL_BIOM, MAC_SALT_CF, MAC_TEMP_CF, MAC_TOT_BIOM, MAC_WATER_AVAIL_CF, MAC_WATER_CF, Max, Min, NC_ALG, NC_ALG_AVAIL_MORT, NC_ALG_GPP, NC_ALG_MORT, NC_ALG_MORT_POT, NC_ALG_NPP, NC_ALG_NUT_CF, NC_ALG_P, NC_ALG_PC, NC_ALG_PROD_CF, NC_ALG_RESP, NC_ALG_RESP_POT, NPHBIO_AVAIL, NPHBIO_MORT, nphbio_mort_OM, nphbio_mort_P, NPHBIO_MORT_POT, NPHBIO_REFUGE, NPHBIO_SAT, nphbio_transl_OM, nphbio_transl_P, NPHBIO_TRANSLOC, NPHBIO_TRANSLOC_POT, PHBIO_AVAIL, PHBIO_MORT, phbio_mort_OM, phbio_mort_P, PHBIO_MORT_POT, PHBIO_NPP, phbio_npp_OM, phbio_npp_P, PHBIO_REFUGE, PHBIO_SAT, phbio_transl_OM, phbio_transl_P, PHBIO_TRANSLOC, PHBIO_TRANSLOC_POT, PI, s0, s1, SAL_SED_WT, SAL_SF_WT, SALT_SED_WT, SALT_SURF_WT, SAT_VS_UNSAT, SAT_WATER, SAT_WT_HEAD, SAT_WT_RECHG, satDensity, SED_ELEV, SED_INACT_Z, SF_WT_FROM_RAIN, SF_WT_INFILTRATION, SF_WT_POT_INF, SF_WT_TO_SAT_DOWNFLOW, SFWT_VOL, SimTime, Sin, soil_MOIST_CF, SOLALPHA, SOLALTCORR, SOLBETA, SOLCOSDEC, SOLDEC, SOLDEC1, SOLELEV_SINE, SOLRAD274, SOLRADATMOS, SOLRADGRD, SOLRISSET_HA, SOLRISSET_HA1, SURFACE_WAT, T, Tan, tempCF(), simTime::TIME, TP_Act_to_Tot, TP_AtmosDepos, TP_SED_CONC, TP_SED_WT, TP_SED_WT_AZ, TP_SEDWT_CONCACT, TP_SEDWT_CONCACTMG, TP_SF_WT, TP_SFWT_CONC, TP_SFWT_CONC_MG, TP_SORB, TPtoSOIL, UNSAT_CAP, UNSAT_DEPTH, UNSAT_MOIST_PRP, UNSAT_WATER, UNSAT_WT_POT, usrErr(), and usrErr0().

 {
int ix,iy, cellLoc;
float tmp; /* used in checking nutrient availability for MichMent kinetics */
float min_litTemp; /* used to determine min of temper, light cf's for alg and macs */
float I_ISat, Z_extinct, PO4Pconc, PO4P;
float MAC_PHtoNPH, MAC_PHtoNPH_Init;
double soil_propOrg; 
#define satDensity 0.9 /* assign the relative proportion (0 - 1) of a population maximum to be the saturation density for a population */

  usrErr0("Initializing unit model equations..."); /* console message */
  
  SimTime.TIME = 0;
  DAYJUL = ( FMOD(SimTime.TIME,365.0) >0.0 ) ? ( FMOD(SimTime.TIME,365.0) ) : ( 365.0);
  LATRAD = ((int)(GP_LATDEG)+(GP_LATDEG-(int)(GP_LATDEG))*5.0/3.0)*PI/180.0;
  /* AMPL = Exp(7.42+0.045*LATRAD*180.0/PI)/3600.0; */
  /* DAYLENGTH = AMPL*Sin((DAYJUL-79.0)*0.01721)+12.0; */
  SOLALPHA = 32.9835-64.884*(1.0-1.3614*Cos(LATRAD));
  SOLDEC1 = 0.39785*Sin(4.868961+0.017203*DAYJUL   +0.033446*Sin(6.224111+0.017202*DAYJUL));
  SOLCOSDEC = sqrt(1.0-pow(SOLDEC1,2.0));
  SOLELEV_SINE = Sin(LATRAD)*SOLDEC1+Cos(LATRAD)*SOLCOSDEC;
  SOLALTCORR = (1.0-Exp(-0.014*(GP_ALTIT-274.0)/(SOLELEV_SINE*274.0)));
  SOLBETA = 0.715-0.3183*(1.0-1.3614*Cos(LATRAD));
  SOLDEC = Arctan(SOLDEC1/sqrt(1.0-pow(SOLDEC1,2.0)));
  SOLRISSET_HA1 = -Tan(LATRAD)*Tan(SOLDEC);
  SOLRISSET_HA = ( (SOLRISSET_HA1==0.0) ) ? ( PI*0.5 ) : (   ( (SOLRISSET_HA1<0.0) ) ? ( PI+Arctan(sqrt(1.0-pow(SOLRISSET_HA1,2.0))/SOLRISSET_HA1)  ) : (      Arctan(sqrt(1.0-pow(SOLRISSET_HA1,2.0))/SOLRISSET_HA1)));
  SOLRADATMOS = 458.37*2.0*(1.0+0.033*Cos(360.0/365.0*PI/180.0*DAYJUL))* (Cos(LATRAD)*Cos(SOLDEC)*Sin(SOLRISSET_HA) + SOLRISSET_HA*180.0/(57.296*PI)*Sin(LATRAD)*Sin(SOLDEC));
        
        for(ix=0; ix<=s0+1; ix++) {
            for(iy=0; iy<=s1+1; iy++) { 
                  cellLoc = T(ix,iy);
                  
                  AIR_TEMP[cellLoc] = 25.0;  /* spatial time series unavailable after 1995; globally constant in v2.2+ */
/* rainfall read from sfwmm data, remapped to ELM resolution */
                  boundcond_rain[cellLoc] =  SF_WT_FROM_RAIN[cellLoc] = boundcond_ETp[cellLoc] = boundcond_depth[cellLoc] = 0.0;
       
                                /* used to have cloudiness influence on GP_SOLOMEGA, now 0 */
                 SOLRAD274[cellLoc] = SOLRADATMOS*(SOLBETA-GP_SOLOMEGA*0.0 )-SOLALPHA;
                 SOLRADGRD[cellLoc] = SOLRAD274[cellLoc]+((SOLRADATMOS+1.0)-SOLRAD274[cellLoc])*SOLALTCORR;
                 H2O_TEMP[cellLoc] = AIR_TEMP[cellLoc];
         
                 ALG_REFUGE[cellLoc] = HP_ALG_MAX[HAB[cellLoc]]*GP_ALG_REF_MULT;
                 ALG_SAT[cellLoc] = HP_ALG_MAX[HAB[cellLoc]]*0.9;

              /* v2.3: with southern everglades topo, put bathymetry back into the model */
                 ELEVATION[cellLoc] = ELEVATION[cellLoc] * GP_IC_ELEV_MULT;
                 Bathymetry[cellLoc] = Bathymetry[cellLoc] * GP_IC_BATHY_MULT;
                 SED_ELEV[cellLoc] =  ELEVATION[cellLoc] - Bathymetry[cellLoc] + GP_DATUM_DISTANCE; 
                 SED_INACT_Z[cellLoc] = SED_ELEV[cellLoc]-HP_DOM_MAXDEPTH[HAB[cellLoc]]; 

                 MAC_MAX_BIO[cellLoc] = HP_NPHBIO_MAX[HAB[cellLoc]]+HP_PHBIO_MAX[HAB[cellLoc]];
                 NPHBIO_REFUGE[cellLoc] = HP_NPHBIO_MAX[HAB[cellLoc]]*GP_MAC_REFUG_MULT;
                 NPHBIO_SAT[cellLoc] = HP_NPHBIO_MAX[HAB[cellLoc]] * satDensity;
                 PHBIO_REFUGE[cellLoc] = HP_PHBIO_MAX[HAB[cellLoc]]*GP_MAC_REFUG_MULT;
                 PHBIO_SAT[cellLoc] = HP_PHBIO_MAX[HAB[cellLoc]] * satDensity;
            }
        }
        for(ix=1; ix<s0+1; ix++) {
            for(iy=1; iy<s1+1; iy++) { cellLoc = T(ix,iy);
/*initialization of major state variables */

              /* hydro */
                 HYD_RCCONDUCT[cellLoc] = HYD_RCCONDUCT[cellLoc] * GP_calibGWat;

/* map */        UNSAT_DEPTH[cellLoc] = Max(UNSAT_DEPTH[cellLoc] + GP_HYD_IC_UNSAT_ADD,0.0); /* m */
                 SAT_WT_HEAD[cellLoc] = SED_ELEV[cellLoc]- UNSAT_DEPTH[cellLoc]; /* m */
                 SAT_WATER[cellLoc] = SAT_WT_HEAD[cellLoc] * HP_HYD_POROSITY[HAB[cellLoc]]; /* m */

                 UNSAT_WATER[cellLoc] = HP_HYD_POROSITY[HAB[cellLoc]]*UNSAT_DEPTH[cellLoc] *GP_HYD_ICUNSATMOIST; /* m */
                 UNSAT_CAP[cellLoc] = UNSAT_DEPTH[cellLoc]*HP_HYD_POROSITY[HAB[cellLoc]]; /* m */
                 UNSAT_MOIST_PRP[cellLoc]  =  /* dimless proportion, 0-1 */
                     ( UNSAT_CAP[cellLoc]>0.0 ) ? 
                     ( Min(UNSAT_WATER[cellLoc]/UNSAT_CAP[cellLoc],1.0) ) : 
                     ( 1.0); 

/* map */        SURFACE_WAT[cellLoc] =  Max(SURFACE_WAT[cellLoc] + GP_HYD_IC_SFWAT_ADD, 0.0); /* m */
                 SFWT_VOL[cellLoc] = SURFACE_WAT[cellLoc]*CELL_SIZE;

                 HYD_DOM_ACTWAT_VOL[cellLoc] = Max(HP_DOM_MAXDEPTH[HAB[cellLoc]]-UNSAT_DEPTH[cellLoc]*
                                                   (1.0-UNSAT_MOIST_PRP[cellLoc]),0.0)*HP_HYD_POROSITY[HAB[cellLoc]]*CELL_SIZE;
                 HYD_SED_WAT_VOL[cellLoc] = (SAT_WATER[cellLoc]+UNSAT_WATER[cellLoc])*CELL_SIZE;
                 
              /* soil */
/* map */        DOM_BD[cellLoc] = DOM_BD[cellLoc] * GP_IC_DOM_BD_MULT; /* kg/m3 */
/* map */        BulkD[cellLoc] = BulkD[cellLoc] * GP_IC_BulkD_MULT;    /* kgOM/m3 */

                 soil_propOrg = (double) DOM_BD[cellLoc] / BulkD[cellLoc];
                 DIM[cellLoc] =   (1.0 - soil_propOrg) * BulkD[cellLoc] * HP_DOM_MAXDEPTH[HAB[cellLoc]] * CELL_SIZE; /* kg inorganic matter */
                 DEPOS_ORG_MAT[cellLoc] = soil_propOrg * BulkD[cellLoc] * HP_DOM_MAXDEPTH[HAB[cellLoc]] ; /* kg organic matter/m2 */
//                 DEPOS_ORG_MAT[cellLoc] = soil_propOrg * BulkD[cellLoc] * HP_DOM_MAXDEPTH[HAB[cellLoc]] ; /* kg organic matter/m2 */
/* v2.8.4 new DEPOS_ORG_MAT init */

//                 Inorg_Z[cellLoc] = (1.0 - soil_propOrg) * HP_DOM_MAXDEPTH[HAB[cellLoc]]; /*  fixed inorganic depth (m) */
//                 DOM_Z[cellLoc] =   HP_DOM_MAXDEPTH[HAB[cellLoc]] - Inorg_Z[cellLoc]; /* m */
                 Inorg_Z[cellLoc] = DIM[cellLoc] / BulkD[cellLoc] * (1.0-soil_propOrg)  / CELL_SIZE ; /*  kgInorg / kgSoil/m3 * proprInorg / m2 == fixed inorganic depth (m) */
                 DOM_Z[cellLoc] =   HP_DOM_MAXDEPTH[HAB[cellLoc]] - Inorg_Z[cellLoc]; /* m */

// v2.8.4                 DEPOS_ORG_MAT[cellLoc] = DOM_BD[cellLoc]*DOM_Z[cellLoc]; /* (mgOM/cm3 ==> kgOM/m3) * m = kgOM/m2 */

                 DOM_SED_AEROB_Z[cellLoc] = Min(UNSAT_DEPTH[cellLoc]+HP_DOM_AEROBTHIN[HAB[cellLoc]],HP_DOM_MAXDEPTH[HAB[cellLoc]]); /* m */
                 DOM_SED_ANAEROB_Z[cellLoc] = HP_DOM_MAXDEPTH[HAB[cellLoc]]-DOM_SED_AEROB_Z[cellLoc]; /* m */

/* map */        TPtoSOIL[cellLoc] = TPtoSOIL[cellLoc] * GP_IC_TPtoSOIL_MULT; /* kgP/kgSoil */
                 DOP[cellLoc] =  (double) (1.0-GP_sorbToTP) * TPtoSOIL[cellLoc] * BulkD[cellLoc] * HP_DOM_MAXDEPTH[HAB[cellLoc]] ; /* kgP/kg_soil * kg_soil/m3 * m == kgP/m2 */

                 TP_SORB[cellLoc] =   (double)  GP_sorbToTP * TPtoSOIL[cellLoc] * BulkD[cellLoc] * HP_DOM_MAXDEPTH[HAB[cellLoc]] * CELL_SIZE; /* dimless * kgP/kg_soil * kg_soil/m3 * m * m^2 == kgP */

              /* floc layer of soil */
                 FLOC[cellLoc] = HP_FLOC_IC[HAB[cellLoc]]; /* kg OM/m2  */
                 FlocP[cellLoc] = FLOC[cellLoc]*HP_FLOC_IC_PC[HAB[cellLoc]]*HP_FLOC_IC_CTOOM[HAB[cellLoc]]; /* kg P /m2 */
                 FLOC_Z[cellLoc] = (double) FLOC[cellLoc] / GP_Floc_BD ; /* m */

              /* phosphorus */
                 TP_AtmosDepos[cellLoc]  = (double)TP_AtmosDepos[cellLoc] * conv_mgTOkg * CELL_SIZE / 365.0; /* P deposition, mgP/m2/yr * kg/mg * m2 / daysPerYear = kgP/day */
/* v2.4.4 */       TP_SFWT_CONC[cellLoc]  = GP_TP_ICSFWAT * conv_mgTOg; /* mg/L * g/mg  => g/L */
                 TP_SF_WT[cellLoc] =TP_SFWT_CONC[cellLoc] * SFWT_VOL[cellLoc]; /* kg P */
                 TP_SFWT_CONC_MG[cellLoc] = TP_SFWT_CONC[cellLoc] * conv_gTOmg; /* mg/L */
                      /* using regression for predicting PO4 from TP */
                 PO4Pconc = Max(TP_SFWT_CONC_MG[cellLoc]*GP_PO4toTP + GP_PO4toTPint, 0.10 * TP_SFWT_CONC_MG[cellLoc]); /* mg/L */
                 PO4P = PO4Pconc * SFWT_VOL[cellLoc] /conv_kgTOg; /*kg P available (from conc. in mg/l) */

/* v2.4.4 */ //      TP_SED_CONC[cellLoc] = GP_TP_ICSEDWAT * conv_mgTOg; /* mg/L * g/mg => g/L */
//                 TP_SED_WT[cellLoc] = TP_SED_CONC[cellLoc] * HYD_SED_WAT_VOL[cellLoc]; /* kg P */
//                      /* this is the active zone, where uptake, sorption, and mineralization take place */
//                  TP_Act_to_Tot[cellLoc] = 1.0 / HP_TP_CONC_GRAD[HAB[cellLoc]]; /* ratio of TP conc in active zone relative to total */
//                  TP_SED_WT_AZ[cellLoc] = TP_SED_CONC[cellLoc] * TP_Act_to_Tot[cellLoc] * HYD_DOM_ACTWAT_VOL[cellLoc]; /* kg P */
//                  TP_SEDWT_CONCACT[cellLoc] =(HYD_DOM_ACTWAT_VOL[cellLoc] > 0.0) ?
//                      ( TP_SED_WT_AZ[cellLoc]/HYD_DOM_ACTWAT_VOL[cellLoc] ) :
//                      ( TP_SED_CONC[cellLoc]); /* g/L */
//                  TP_SEDWT_CONCACTMG[cellLoc] = TP_SEDWT_CONCACT[cellLoc]*conv_gTOmg; /* mg/L */

/* v2.8.4 concentration in Active Zone (TP_SEDWT_CONCACT) is initialed by map (data here are g/L) */
                 TP_Act_to_Tot[cellLoc] = 1.0 / HP_TP_CONC_GRAD[HAB[cellLoc]]; /* ratio of TP conc in active zone relative to total */
                                 TP_SED_CONC[cellLoc] = (TP_Act_to_Tot[cellLoc]>0.0) ? (TP_SEDWT_CONCACT[cellLoc] / TP_Act_to_Tot[cellLoc]) : (0.0);
/* map */        TP_SEDWT_CONCACT[cellLoc] =(HYD_DOM_ACTWAT_VOL[cellLoc] > 0.0) ?
                     ( TP_SEDWT_CONCACT[cellLoc] ) :
                     ( 0.0 ); /* g/L */
                 TP_SEDWT_CONCACTMG[cellLoc] = TP_SEDWT_CONCACT[cellLoc]*conv_gTOmg; /* mg/L */
                 TP_SED_WT[cellLoc] = TP_SED_CONC[cellLoc] * HYD_SED_WAT_VOL[cellLoc]; /* kg P */
                 TP_SED_WT_AZ[cellLoc] = TP_SEDWT_CONCACT[cellLoc] * HYD_DOM_ACTWAT_VOL[cellLoc]; /* kg P */


              /* salt */
                 SALT_SED_WT[cellLoc] = HYD_SED_WAT_VOL[cellLoc]*HP_SALT_ICSEDWAT[HAB[cellLoc]];
                 SAL_SED_WT[cellLoc] = ( HYD_SED_WAT_VOL[cellLoc]>0.0 ) ? ( SALT_SED_WT[cellLoc]/HYD_SED_WAT_VOL[cellLoc] ) : ( 0.0);
                 SALT_SURF_WT[cellLoc] = SFWT_VOL[cellLoc]*HP_SALT_ICSFWAT[HAB[cellLoc]];
                 SAL_SF_WT[cellLoc] = ( SURFACE_WAT[cellLoc] > GP_WQualMonitZ ) ? ( SALT_SURF_WT[cellLoc]/SFWT_VOL[cellLoc] ) : ( 0.0);

              /* periphyton */
/* 2.4.4 */       NC_ALG[cellLoc] = HP_ALG_MAX[HAB[cellLoc]] * GP_ALG_IC_MULT * GP_ALG_REF_MULT ; /* start w/ low, refuge-level of non-calcareous (eutrophic) periphyton, g C/m2 */
/* 2.4.4 */       C_ALG[cellLoc]  = HP_ALG_MAX[HAB[cellLoc]] * GP_ALG_IC_MULT * (1.0 - GP_ALG_REF_MULT); /* g C/m2 */
                 /* ic PC of periph in oligotrophic area is 3% of max P:C, varies across space via (0.1->1.0) map */
/* 2.4.4 */       NC_ALG_PC[cellLoc] = GP_ALG_PC; /* gP/ gC */
/* 2.4.4 */       C_ALG_PC[cellLoc]  = GP_ALG_PC; /* gP/ gC */

                 NC_ALG_P[cellLoc] = NC_ALG[cellLoc]*NC_ALG_PC[cellLoc];   /* g P/m2 */
                 C_ALG_P[cellLoc] = C_ALG[cellLoc]*C_ALG_PC[cellLoc];  /* g P/m2 */  

              /* macrophytes */
/* 2.4.4 */       MAC_PH_BIOMAS[cellLoc] = MAC_TOT_BIOM[cellLoc] * GP_MAC_IC_MULT * HP_PHBIO_MAX[HAB[cellLoc]]/MAC_MAX_BIO[cellLoc]; /* kg C/m2 */
                   /*  now calc the P and OM associated with that C */
/* 2.4.4 */       mac_ph_PC[cellLoc] = HP_PHBIO_IC_PC[HAB[cellLoc]]; 
                 mac_ph_P[cellLoc] = MAC_PH_BIOMAS[cellLoc] * mac_ph_PC[cellLoc]; /* kg P/m2 */
                 mac_ph_OM[cellLoc] = MAC_PH_BIOMAS[cellLoc] / HP_PHBIO_IC_CTOOM[HAB[cellLoc]];
                 mac_ph_CtoOM[cellLoc] = HP_PHBIO_IC_CTOOM[HAB[cellLoc]];
                 PHBIO_AVAIL[cellLoc] = MAC_PH_BIOMAS[cellLoc]*Max(1.0-Max((PHBIO_SAT[cellLoc]-MAC_PH_BIOMAS[cellLoc]) /(PHBIO_SAT[cellLoc]-PHBIO_REFUGE[cellLoc]),0.0),0.0);

/* 2.4.4 */       MAC_NOPH_BIOMAS[cellLoc] = MAC_TOT_BIOM[cellLoc] * GP_MAC_IC_MULT * HP_NPHBIO_MAX[HAB[cellLoc]]/MAC_MAX_BIO[cellLoc]; /* kg C/m2 */
                   /*  now calc the P and OM associated with that C */
/* 2.4.4 */       mac_nph_PC[cellLoc] = HP_NPHBIO_IC_PC[HAB[cellLoc]]; 
                 mac_nph_P[cellLoc] = MAC_NOPH_BIOMAS[cellLoc] * mac_nph_PC[cellLoc];  /* kg P/m2 */
                 mac_nph_OM[cellLoc] = MAC_NOPH_BIOMAS[cellLoc] / HP_NPHBIO_IC_CTOOM[HAB[cellLoc]];
                 mac_nph_CtoOM[cellLoc] = HP_NPHBIO_IC_CTOOM[HAB[cellLoc]];
                 NPHBIO_AVAIL[cellLoc] = MAC_NOPH_BIOMAS[cellLoc]*Max(1.0-Max((NPHBIO_SAT[cellLoc]-MAC_NOPH_BIOMAS[cellLoc])/(NPHBIO_SAT[cellLoc]-NPHBIO_REFUGE[cellLoc]),0.0),0.0);

                 MAC_REL_BIOM[cellLoc] = ( MAC_TOT_BIOM[cellLoc] > 0 ) ? MAC_TOT_BIOM[cellLoc]/MAC_MAX_BIO[cellLoc] : 0.0;
                 MAC_LAI[cellLoc] = MAC_REL_BIOM[cellLoc]*HP_MAC_MAXLAI[HAB[cellLoc]];
                 MAC_HEIGHT[cellLoc] = MAC_REL_BIOM[cellLoc]*HP_MAC_MAXHT[HAB[cellLoc]];
                 LAI_eff[cellLoc] =  (MAC_HEIGHT[cellLoc]>0.0) ? (Max(1.0 - SURFACE_WAT[cellLoc]/MAC_HEIGHT[cellLoc], 0.0)*MAC_LAI[cellLoc]) : (0.0)  ;                 

/* end of initialization of major state variables */
                 
/* *************************** */
/* These are the multiple calculations used if particular modules are turned off. \n
 NOTE: THIS section (of init_eqns() ) is not fully updated for properly
 turning off individual **interacting** *biological/chemical* modules.  
 If one *biological/chemical* module is turned off, 
 they all need to be turned off. (Note that cell_dyn's 3,5,6 should always be off). \n

 *** \n
 The following *biological/chemical* modules must be ON or OFF as a group:
 (cell_dyn2 + cell_dyn4 + cell_dyn8 + cell_dyn9  + cell_dyn12)
 cell_dyn13, the net settling rate module, can be turned on only when above module group is off
 *** \n
 
 In particular, the budget will
 not properly reflect actual dynamics if those 
 modules are not treated as a group.
*/
     NC_ALG_MORT_POT[cellLoc] = ( UNSAT_DEPTH[cellLoc]>0.05 ) ? ( NC_ALG[cellLoc]*GP_ALG_RC_MORT_DRY ) : ( NC_ALG[cellLoc]*GP_ALG_RC_MORT);
                     /* calcareous periphyton */
     C_ALG_MORT_POT[cellLoc] = ( UNSAT_DEPTH[cellLoc]>0.05 ) ? ( C_ALG[cellLoc]*GP_ALG_RC_MORT_DRY ) : ( C_ALG[cellLoc]*GP_ALG_RC_MORT);
                 ALG_TEMP_CF[cellLoc]  = tempCF(0, 0.20, GP_ALG_TEMP_OPT, 5.0, 40.0, H2O_TEMP[cellLoc]);
     NC_ALG_RESP_POT[cellLoc]  = 
         ( UNSAT_DEPTH[cellLoc]<0.05 ) ? 
         ( GP_ALG_RC_RESP*ALG_TEMP_CF[cellLoc]*NC_ALG[cellLoc] ) : 
         ( 0.0);
     NC_ALG_RESP[cellLoc]  =  
         ( NC_ALG_RESP_POT[cellLoc]*DT>NC_ALG[cellLoc] ) ? 
         ( NC_ALG[cellLoc]/DT ) : 
         ( NC_ALG_RESP_POT[cellLoc]);
                     /* calcareous periphyton */
     C_ALG_RESP_POT[cellLoc]  = 
         ( UNSAT_DEPTH[cellLoc]<0.05 ) ? 
         ( GP_ALG_RC_RESP*ALG_TEMP_CF[cellLoc]*C_ALG[cellLoc] ) : 
         ( 0.0);
     C_ALG_RESP[cellLoc]  =  
         ( C_ALG_RESP_POT[cellLoc]*DT>C_ALG[cellLoc] ) ? 
         ( C_ALG[cellLoc]/DT ) : 
         ( C_ALG_RESP_POT[cellLoc]);

     NC_ALG_AVAIL_MORT[cellLoc] = NC_ALG[cellLoc]-ALG_REFUGE[cellLoc];
     NC_ALG_MORT[cellLoc] = ( (NC_ALG_MORT_POT[cellLoc])*DT>NC_ALG_AVAIL_MORT[cellLoc] ) ? ( (NC_ALG_AVAIL_MORT[cellLoc])/DT ) : ( NC_ALG_MORT_POT[cellLoc]);
                     /* calcareous periphyton */
     C_ALG_AVAIL_MORT[cellLoc]  = C_ALG[cellLoc]-ALG_REFUGE[cellLoc];
     C_ALG_MORT[cellLoc]  = ( (C_ALG_MORT_POT[cellLoc])*DT>C_ALG_AVAIL_MORT[cellLoc] ) ? ( (C_ALG_AVAIL_MORT[cellLoc])/DT ) : ( C_ALG_MORT_POT[cellLoc]);

/* light, water, temperature controls apply to calc and non-calc periphyton */
     ALG_LIGHT_EXTINCT[cellLoc]  =  0.01; /* light extinction coef */
                     /* algal self-shading implicit in density-dependent constraint function later */
     ALG_INCID_LIGHT[cellLoc]  = SOLRADGRD[cellLoc]*Exp(-MAC_LAI[cellLoc]*GP_ALG_SHADE_FACTOR);
                 Z_extinct = SURFACE_WAT[cellLoc]*ALG_LIGHT_EXTINCT[cellLoc];
     I_ISat = ALG_INCID_LIGHT[cellLoc]/GP_ALG_LIGHT_SAT;
                     /*  averaged over whole water column (based on Steele '65) */
     ALG_LIGHT_CF[cellLoc]  = ( Z_extinct > 0.0 ) ? 
         ( 2.718/Z_extinct * (Exp(-I_ISat * Exp(-Z_extinct)) - Exp(-I_ISat)) ) :
                (I_ISat*Exp(1.0-I_ISat));
                     /*  low-water growth constraint ready for something better based on data */
     ALG_WAT_CF[cellLoc]  = ( SURFACE_WAT[cellLoc]>0.0 ) ? ( 1.0 ) : ( 0.0);
/* the 2 communities have same growth response to avail phosphorus - avail P is roughly calc'd from TP */
     NC_ALG_NUT_CF[cellLoc]  =  PO4Pconc/(PO4Pconc+GP_NC_ALG_KS_P) ;
     C_ALG_NUT_CF[cellLoc]  = PO4Pconc/(PO4Pconc+GP_C_ALG_KS_P); 
      min_litTemp = Min(ALG_LIGHT_CF[cellLoc],ALG_TEMP_CF[cellLoc]);
      NC_ALG_PROD_CF[cellLoc]  = Min(min_litTemp,ALG_WAT_CF[cellLoc])*NC_ALG_NUT_CF[cellLoc];
      C_ALG_PROD_CF[cellLoc]   = Min(min_litTemp,ALG_WAT_CF[cellLoc])*C_ALG_NUT_CF[cellLoc];
/* gross production of the 2 communities (gC/m2, NOT kgC/m2) */
                     /* density constraint contains both noncalc and calc, competition effect accentuated by calc algae */
                     /* used to increase calc growth by factor of 10 */
      NC_ALG_GPP[cellLoc]  =  NC_ALG_PROD_CF[cellLoc]*GP_ALG_RC_PROD*NC_ALG[cellLoc]       
             *Max( (1.0-(GP_AlgComp*C_ALG[cellLoc]+NC_ALG[cellLoc])/HP_ALG_MAX[HAB[cellLoc]]),0.0);
     C_ALG_GPP[cellLoc]  =  C_ALG_PROD_CF[cellLoc]*GP_ALG_RC_PROD*C_ALG[cellLoc] 
       *Max( (1.0-(    C_ALG[cellLoc]+NC_ALG[cellLoc])/HP_ALG_MAX[HAB[cellLoc]]),0.0);
/* check for available P mass (the MichMent kinetics nutCF do not) */
     tmp = ( (NC_ALG_GPP[cellLoc]+C_ALG_GPP[cellLoc]) > 0) ? 
         PO4P / ( (NC_ALG_GPP[cellLoc]+C_ALG_GPP[cellLoc]) 
         * 0.001*GP_ALG_PC*CELL_SIZE*DT) :
         1.0;
     if (tmp < 1.0) {
         NC_ALG_GPP[cellLoc] *= tmp;   
         C_ALG_GPP[cellLoc] *= tmp; 
    /* can have high conc, but low mass of P avail, in presence of high peri biomass and high demand */
    /* reduce the production proportionally if excess demand is found */
       }
/* total of calc and noncalc algae available and their total NPP */
     NC_ALG_NPP[cellLoc]  = NC_ALG_GPP[cellLoc]-NC_ALG_RESP[cellLoc]; 
     C_ALG_NPP[cellLoc]  = C_ALG_GPP[cellLoc]-C_ALG_RESP[cellLoc]; 


     DOM_QUALITY_CF[cellLoc]  = (Max(TP_SFWT_CONC_MG[cellLoc],TP_SEDWT_CONCACTMG[cellLoc]))
         /GP_DOM_DECOMP_POPT; /* mg/L */
     DOM_TEMP_CF[cellLoc] = Exp(0.20*(H2O_TEMP[cellLoc]-GP_DOM_DECOMP_TOPT))*pow(((40.0-H2O_TEMP[cellLoc])/(40.0-GP_DOM_DECOMP_TOPT)),(0.20*(40.0-GP_DOM_DECOMP_TOPT)));
     soil_MOIST_CF[cellLoc] = pow(Max(UNSAT_MOIST_PRP[cellLoc],0.0),0.75);
     DOM_DECOMP_POT[cellLoc] = GP_DOM_RCDECOMP*DOM_QUALITY_CF[cellLoc]*DOM_TEMP_CF[cellLoc]*DEPOS_ORG_MAT[cellLoc]*(Min(DOM_SED_AEROB_Z[cellLoc]/HP_DOM_MAXDEPTH[HAB[cellLoc]],1.0)*soil_MOIST_CF[cellLoc]+GP_DOM_DECOMPRED*Min(DOM_SED_ANAEROB_Z[cellLoc]/HP_DOM_MAXDEPTH[HAB[cellLoc]],1.0));
     DOM_DECOMP[cellLoc] =  ( (DOM_DECOMP_POT[cellLoc])*DT>DEPOS_ORG_MAT[cellLoc] ) ? ( (DEPOS_ORG_MAT[cellLoc])/DT ) : ( DOM_DECOMP_POT[cellLoc]);
/* added for P DOM stoich */
     DOP_DECOMP[cellLoc] = DOM_DECOMP[cellLoc] * DOM_P_OM[cellLoc]; 

     SAT_VS_UNSAT[cellLoc] = 1/Exp(100.0*Max((SURFACE_WAT[cellLoc]-UNSAT_DEPTH[cellLoc]),0.0));
     UNSAT_WT_POT[cellLoc] = Max(UNSAT_CAP[cellLoc]-UNSAT_WATER[cellLoc],0.0);
         SF_WT_TO_SAT_DOWNFLOW[cellLoc]  = ( (1.0-SAT_VS_UNSAT[cellLoc])*UNSAT_WT_POT[cellLoc]*DT>SURFACE_WAT[cellLoc] ) ? ( SURFACE_WAT[cellLoc]/DT ) : ( (1.0-SAT_VS_UNSAT[cellLoc])*UNSAT_WT_POT[cellLoc]); 
     SAT_WT_RECHG[cellLoc] = ( GP_HYD_RCRECHG*DT>SAT_WATER[cellLoc] ) ? ( SAT_WATER[cellLoc]/DT ) : ( GP_HYD_RCRECHG);
     SF_WT_POT_INF[cellLoc] = ( (SURFACE_WAT[cellLoc]<HP_HYD_RCINFILT[HAB[cellLoc]]*DT) ) ? ( SURFACE_WAT[cellLoc]/DT ) : ( HP_HYD_RCINFILT[HAB[cellLoc]]);
     SF_WT_INFILTRATION[cellLoc] = ( SF_WT_POT_INF[cellLoc]*SAT_VS_UNSAT[cellLoc]*DT>UNSAT_WT_POT[cellLoc] ) ? ( (UNSAT_WT_POT[cellLoc])/DT ) : ( SF_WT_POT_INF[cellLoc]*SAT_VS_UNSAT[cellLoc]);
     HYD_DOM_ACTWAT_PRES[cellLoc] = ( HYD_DOM_ACTWAT_VOL[cellLoc] > 0.01 ) ? ( 1.0 ) : ( 0.0);
     HYD_WATER_AVAIL[cellLoc] = Min(1.0, UNSAT_MOIST_PRP[cellLoc]+Exp(-10.0*Max(UNSAT_DEPTH[cellLoc]-HP_NPHBIO_ROOTDEPTH[HAB[cellLoc]],0.0)));

     MAC_LIGHT_CF[cellLoc] = SOLRADGRD[cellLoc]/HP_MAC_LIGHTSAT[HAB[cellLoc]]*Exp(1.0-SOLRADGRD[cellLoc]/HP_MAC_LIGHTSAT[HAB[cellLoc]]);
     MAC_TEMP_CF[cellLoc] = Exp(0.20*(AIR_TEMP[cellLoc]-HP_MAC_TEMPOPT[HAB[cellLoc]])) *pow(((40.0-AIR_TEMP[cellLoc])/(40.0-HP_MAC_TEMPOPT[HAB[cellLoc]])),(0.20*(40.0-HP_MAC_TEMPOPT[HAB[cellLoc]])));
     MAC_WATER_AVAIL_CF[cellLoc] = graph8(0x0,HYD_WATER_AVAIL[cellLoc]);
     MAC_WATER_CF[cellLoc] = Min(MAC_WATER_AVAIL_CF[cellLoc], Max(1.0-Max((SURFACE_WAT[cellLoc]-HP_MAC_WAT_TOLER[HAB[cellLoc]])/HP_MAC_WAT_TOLER[HAB[cellLoc]],0.0),0.0));
     MAC_NUT_CF[cellLoc] =  TP_SEDWT_CONCACT[cellLoc]/(TP_SEDWT_CONCACT[cellLoc]+HP_MAC_KSP[HAB[cellLoc]]*0.001) ;

     MAC_SALT_CF[cellLoc] = ( HP_MAC_SALIN_THRESH[HAB[cellLoc]]>0.0 ) ? (  Max( 1.0-Max(SAL_SED_WT[cellLoc]-HP_MAC_SALIN_THRESH[HAB[cellLoc]],0.0)/HP_MAC_SALIN_THRESH[HAB[cellLoc]],0.0) ) : ( Max(1.0-SAL_SED_WT[cellLoc],0.0));
     min_litTemp = Min(MAC_LIGHT_CF[cellLoc], MAC_TEMP_CF[cellLoc]);
     MAC_PROD_CF[cellLoc]  = Min(min_litTemp,MAC_WATER_CF[cellLoc])
         *MAC_NUT_CF[cellLoc]*MAC_SALT_CF[cellLoc];
     PHBIO_NPP[cellLoc] = HP_PHBIO_RCNPP[HAB[cellLoc]]*MAC_PROD_CF[cellLoc]*MAC_PH_BIOMAS[cellLoc]* Max( (1.0-MAC_TOT_BIOM[cellLoc]/MAC_MAX_BIO[cellLoc]), 0.0);
/* check for available P mass that will be taken up (MichMent kinetics in nutCF does not) */
     tmp = (PHBIO_NPP[cellLoc] > 0) ? 
         TP_SED_WT[cellLoc] / ( PHBIO_NPP[cellLoc] * HP_NPHBIO_IC_PC[HAB[cellLoc]]*CELL_SIZE*DT) :
         1.0;
     if (tmp < 1.0) PHBIO_NPP[cellLoc] *= tmp;   
    /* reduce the production proportionally if excess demand is found */
    /* can have high conc, but low mass of P avail, in presence of high plant biomass and high demand */
/* now add the P and OM associated with that C */
     phbio_npp_P[cellLoc] = PHBIO_NPP[cellLoc] * HP_PHBIO_IC_PC[HAB[cellLoc]];     /* habitat-specfic stoichiometry */
     phbio_npp_OM[cellLoc] = PHBIO_NPP[cellLoc] / HP_PHBIO_IC_CTOOM[HAB[cellLoc]]; /* habitat-specfic stoichiometry */

/* init ("target") ph/nph ratio and new transloc algorithm */
     MAC_PHtoNPH_Init = HP_PHBIO_MAX[HAB[cellLoc]] / HP_NPHBIO_MAX[HAB[cellLoc]] ;
     MAC_PHtoNPH = MAC_PH_BIOMAS[cellLoc] / MAC_NOPH_BIOMAS[cellLoc];

     PHBIO_TRANSLOC_POT[cellLoc]  = 0.0; /* (MAC_PHtoNPH<MAC_PHtoNPH_Init) ? (exp(HP_MAC_TRANSLOC_RC[HAB[cellLoc]] *(MAC_PHtoNPH_Init-MAC_PHtoNPH)) - 1.0) : (0.0) */ 

     PHBIO_TRANSLOC[cellLoc] =  ( (PHBIO_TRANSLOC_POT[cellLoc])*DT >NPHBIO_AVAIL[cellLoc] ) ? ( (NPHBIO_AVAIL[cellLoc])/DT ) : ( PHBIO_TRANSLOC_POT[cellLoc]);
/*  now remove the P and OM associated with that C */
     phbio_transl_P[cellLoc] = PHBIO_TRANSLOC[cellLoc] * mac_nph_PC[cellLoc];
     phbio_transl_OM[cellLoc] = PHBIO_TRANSLOC[cellLoc] / mac_nph_CtoOM[cellLoc];
     NPHBIO_MORT_POT[cellLoc] = NPHBIO_AVAIL[cellLoc]*HP_PHBIO_RCMORT[HAB[cellLoc]]*(1.0-MAC_PH_BIOMAS[cellLoc]/HP_PHBIO_MAX[HAB[cellLoc]]);
     NPHBIO_MORT[cellLoc] =  ( (PHBIO_TRANSLOC[cellLoc]+NPHBIO_MORT_POT[cellLoc])*DT>NPHBIO_AVAIL[cellLoc] ) ? ( (NPHBIO_AVAIL[cellLoc]-PHBIO_TRANSLOC[cellLoc]*DT)/DT ) : ( NPHBIO_MORT_POT[cellLoc]);
     PHBIO_MORT_POT[cellLoc] = HP_PHBIO_RCMORT[HAB[cellLoc]] *PHBIO_AVAIL[cellLoc] *(1.0-MAC_WATER_AVAIL_CF[cellLoc]);
/* now remove the P and OM associated with that C */
     nphbio_mort_P[cellLoc] = NPHBIO_MORT[cellLoc] * mac_nph_PC[cellLoc];
     nphbio_mort_OM[cellLoc] = NPHBIO_MORT[cellLoc] / mac_nph_CtoOM[cellLoc];

     NPHBIO_TRANSLOC_POT[cellLoc] = 0.0; /* (MAC_PHtoNPH>MAC_PHtoNPH_Init) ? (exp(HP_MAC_TRANSLOC_RC[HAB[cellLoc]] *(MAC_PHtoNPH-MAC_PHtoNPH_Init)) - 1.0) : (0.0) */ 
     NPHBIO_TRANSLOC[cellLoc] = ( (NPHBIO_TRANSLOC_POT[cellLoc])*DT >MAC_PH_BIOMAS[cellLoc] ) ? ( (MAC_PH_BIOMAS[cellLoc])/DT ) : ( NPHBIO_TRANSLOC_POT[cellLoc]);
/*  now remove the P and OM associated with that C */
     nphbio_transl_P[cellLoc] = NPHBIO_TRANSLOC[cellLoc] * mac_ph_PC[cellLoc];
     nphbio_transl_OM[cellLoc] = NPHBIO_TRANSLOC[cellLoc] / mac_ph_CtoOM[cellLoc];
     PHBIO_MORT[cellLoc] = ( (PHBIO_MORT_POT[cellLoc]+NPHBIO_TRANSLOC[cellLoc])*DT>PHBIO_AVAIL[cellLoc] ) ? ( (PHBIO_AVAIL[cellLoc]-NPHBIO_TRANSLOC[cellLoc]*DT)/DT ) : ( PHBIO_MORT_POT[cellLoc]);
/*  now remove the P associated with that C */
     phbio_mort_P[cellLoc] = PHBIO_MORT[cellLoc] * mac_ph_PC[cellLoc];
     phbio_mort_OM[cellLoc] = PHBIO_MORT[cellLoc] / mac_ph_CtoOM[cellLoc];


     FLOC_DECOMP_QUAL_CF[cellLoc] = Min(TP_SFWT_CONC_MG[cellLoc]/GP_DOM_DECOMP_POPT,1.0) ;
     FLOC_DECOMP_POT[cellLoc] = GP_DOM_RCDECOMP*FLOC[cellLoc]*DOM_TEMP_CF[cellLoc] *FLOC_DECOMP_QUAL_CF[cellLoc];
     FLOC_DECOMP[cellLoc] = ( (FLOC_DECOMP_POT[cellLoc])*DT>FLOC[cellLoc] ) ? ( (FLOC[cellLoc])/DT ) : ( FLOC_DECOMP_POT[cellLoc]);
     FLOC_DEPO_POT[cellLoc] = (  SURFACE_WAT[cellLoc] > GP_DetentZ ) ? ( FLOC[cellLoc]*0.05 ) : ( FLOC[cellLoc]/DT);
     FLOC_DEPO[cellLoc] = ( (FLOC_DEPO_POT[cellLoc]+FLOC_DECOMP[cellLoc])*DT>FLOC[cellLoc] ) ? ( (FLOC[cellLoc]-FLOC_DECOMP[cellLoc]*DT)/DT ) : ( FLOC_DEPO_POT[cellLoc]);
 
     HYD_MANNINGS_N[cellLoc]  = Max(-Abs((HP_MAC_MAXROUGH[HAB[cellLoc]]-HP_MAC_MINROUGH[HAB[cellLoc]])*  (pow(2.0,(1.0-SURFACE_WAT[cellLoc]/MAC_HEIGHT[cellLoc]))-1.0)) + HP_MAC_MAXROUGH[HAB[cellLoc]],HP_MAC_MINROUGH[HAB[cellLoc]]);
  } /* spatial loop end */
  } /* spatial loop end */
  usrErr("Done.");

} /* end of init_eqns */

Here is the call graph for this function:

void init_canals

(

int

irun

)

Call to initialize the water managment canal network topology and data.

Parameters:

irun

a counter of number of times a new simulation run is executed

Definition at line 2110 of file UnitMod.c.

References Canal_Network_Init(), GP_DATUM_DISTANCE, reinitCanals(), SED_ELEV, and usrErr().

{
   if (irun == 1) {
      usrErr("Initializing Water Management...");
      Canal_Network_Init(GP_DATUM_DISTANCE,SED_ELEV); /* WatMgmt.c - initialize the canal network topology and data */
      usrErr("Done Water Management.");
   }
   else {
      reinitCanals();
   }

}

Here is the call graph for this function:

void init_succession

(

void

)

Call to initialize the habitat succession module.

Definition at line 2124 of file UnitMod.c.

References HabSwitch_Init().

{
   HabSwitch_Init( ); 

}

Here is the call graph for this function:

void reinitBIR

(

void

)

Calls to re-initialize Basin/Indicator-Region data.

Definition at line 2131 of file UnitMod.c.

References BIRbudg_reset(), BIRstats_reset(), Cell_reset_avg(), Cell_reset_hydper(), usrErr(), and usrErr0().

{
   usrErr0("Re-initializing Basin/Indicator-Region info...");
   BIRstats_reset(); 
   BIRbudg_reset(); 
   Cell_reset_avg(); 
   Cell_reset_hydper(); 
   usrErr("Done.");
}

Here is the call graph for this function:

void reinitCanals

(

void

)

Call to re-initialize canal storages.

Definition at line 2142 of file UnitMod.c.

References CanalReInit(), usrErr(), and usrErr0().

{
   usrErr0("Re-initializing Canal depths & constituent masses...");
   CanalReInit();  
   usrErr("Done.");
}

Here is the call graph for this function:

void gen_output	(	int	step,
		ViewParm *	view
	)

Generate output.

Create output of spatial maps, point locations and debug data (if any)

Parameters:

	step	The current iteration number
	view	The struct containing output configuration data

Remarks:

You need to ensure that the Outlist_size (define in driver_utilities.h) is greater than (at least equal to) the number of output variables here (important if adding variables to this output list).

Remarks:

This UnitMod.c code "fragment" (gen_output function, populating tgen[] array) is generated from the "ModelOutlist_creator_v?.xls" OpenOffice workbook. Editing this source directly is not recommended w/o changing ModelOutlist_creator.
The order of the variables in the Model.outList configuration (model input) file MUST EXACTLY match their order in the tgen[] array of the struct.
The ModelOutlist_creator automatically generates both the Model.outList and the tgen[] code.
It is recommended that you utilize the ModelOutlist_creator to generate both the config file and the source code. NOTE: the code generator has a bug, and puts an 'f' argument in all variables, float or not. You must change doubles ('d') and unsigned chars ('c') by hand.

Definition at line 2162 of file UnitMod.c.

References AIR_TEMP, ALG_INCID_LIGHT, ALG_LIGHT_CF, ALG_LIGHT_EXTINCT, ALG_REFUGE, ALG_SAT, ALG_TEMP_CF, ALG_TOT, ALG_WAT_CF, avgPrint, BCmodel_sfwat, BCmodel_sfwatAvg, C_ALG, C_ALG_AVAIL_MORT, C_ALG_GPP, C_ALG_MORT, C_ALG_MORT_POT, C_ALG_NPP, C_ALG_NUT_CF, C_ALG_PROD_CF, C_ALG_RESP, C_ALG_RESP_POT, C_Peri_mortAvg, C_Peri_nppAvg, C_Peri_PCAvg, C_PeriAvg, C_PeriNutCFAvg, C_PeriRespAvg, CalMonOut, Cell_reset_avg(), Cell_reset_hydper(), outVar_struct::ctype, DAYJUL, DEPOS_ORG_MAT, DOM_DECOMP, DOM_DECOMP_POT, DOM_FR_FLOC, DOM_P_OM, DOM_QUALITY_CF, DOM_SED_AEROB_Z, DOM_SED_ANAEROB_Z, DOM_TEMP_CF, DOM_Z, DOP, DOP_DECOMP, ELEVATION, ETAvg, EvapAvg, FLOC, FLOC_DECOMP, FLOC_DECOMP_POT, FLOC_DECOMP_QUAL_CF, FLOC_DEPO, FLOC_DEPO_POT, FLOC_FR_ALGAE, Floc_fr_phBioAvg, FLOC_Z, FlocP_OMrep, FMOD(), H2O_TEMP, HAB, HYD_DOM_ACTWAT_PRES, HYD_DOM_ACTWAT_VOL, HYD_ET, HYD_EVAP_CALC, HYD_MANNINGS_N, HYD_RCCONDUCT, HYD_SAT_POT_TRANS, HYD_SED_WAT_VOL, HYD_TOT_POT_TRANSP, HYD_TRANSP, HYD_UNSAT_POT_TRANS, HYD_WATER_AVAIL, HydPerAnn, HydRelDepPosNeg, HydRelDepPosNegAvg, HydTotHd, LAI_eff, LAI_effAvg, MAC_HEIGHT, MAC_LAI, MAC_LIGHT_CF, MAC_MAX_BIO, MAC_NOPH_BIOMAS, mac_nph_PC_rep, mac_nph_PCAvg, Mac_nphBioAvg, Mac_nphMortAvg, Mac_nppAvg, MAC_NUT_CF, MAC_PH_BIOMAS, mac_ph_PC_rep, mac_ph_PCAvg, Mac_phBioAvg, Mac_phMortAvg, MAC_PROD_CF, MAC_REL_BIOM, MAC_SALT_CF, MAC_TEMP_CF, MAC_TOT_BIOM, Mac_totBioAvg, MAC_WATER_AVAIL_CF, MAC_WATER_CF, MacNutCfAvg, MacWatCfAvg, Manning_nAvg, NC_ALG, NC_ALG_AVAIL_MORT, NC_ALG_GPP, NC_ALG_MORT, NC_ALG_MORT_POT, NC_ALG_NPP, NC_ALG_NUT_CF, NC_ALG_PROD_CF, NC_ALG_RESP, NC_ALG_RESP_POT, NC_Peri_mortAvg, NC_Peri_nppAvg, NC_Peri_PCAvg, NC_PeriAvg, NC_PeriNutCFAvg, NC_PeriRespAvg, NPHBIO_AVAIL, NPHBIO_MORT, NPHBIO_MORT_POT, NPHBIO_REFUGE, NPHBIO_SAT, NPHBIO_TRANSLOC, NPHBIO_TRANSLOC_POT, numOutputs, ON_MAP, P_SUM_CELL, PeriAvg, PeriLiteCFAvg, outVar_struct::pfvar, PHBIO_AVAIL, PHBIO_MORT, PHBIO_MORT_POT, PHBIO_NPP, PHBIO_REFUGE, PHBIO_SAT, PHBIO_TRANSLOC, PHBIO_TRANSLOC_POT, outVar_struct::pname, RainAvg, SAL_SED_WT, SAL_SF_WT, SALT_Atm_Depos, SALT_SED_TO_SF_FLOW, SALT_SED_WT, SALT_SFWAT_DOWNFL, SALT_SFWAT_DOWNFL_POT, SALT_SURF_WT, SaltSedAvg, SaltSfAvg, SAT_TO_UNSAT_FL, SAT_VS_UNSAT, SAT_WATER, SAT_WT_HEAD, SAT_WT_RECHG, SAT_WT_TRANSP, SED_ELEV, SED_INACT_Z, SedElevAvg, SF_WT_EVAP, SF_WT_FROM_RAIN, SF_WT_INFILTRATION, SF_WT_POT_INF, SF_WT_TO_SAT_DOWNFLOW, SF_WT_VEL_mag, SF_WT_VEL_magAvg, SfWatAvg, SFWT_VOL, soil_MOIST_CF, SOLRAD274, SOLRADGRD, viewParm::step, SURFACE_WAT, TotHeadAvg, TP_Act_to_TotRep, TP_Atm_Depos, TP_DNFLOW, TP_DNFLOW_POT, TP_K, TP_SED_CONC, TP_SED_MINER, TP_SED_WT, TP_SED_WT_AZ, TP_SEDWT_CONCACT, TP_SEDWT_CONCACTMG, TP_SEDWT_UPTAKE, TP_settl, TP_settlAvg, TP_settlDays, TP_SF_WT, TP_SFWT_CONC, TP_SFWT_CONC_MG, TP_SFWT_MINER, TP_SFWT_UPTAK, TP_SORB, TP_SORB_POT, TP_SORBCONC, TP_SORBCONC_rep, TP_SORBTION, TP_UPFLOW, TP_UPFLOW_POT, TPSedMinAvg, TPSedUptAvg, TPSedWatAvg, TPSfMinAvg, TPSfUptAvg, TPSfWatAvg, TPSorbAvg, TPtoSOIL_rep, TPtoSOILAvg, TPtoVOLAvg, TranspAvg, UNSAT_AVAIL, UNSAT_CAP, UNSAT_DEPTH, UNSAT_HYD_COND_CF, UNSAT_MOIST_PRP, UNSAT_PERC, UNSAT_TO_SAT_FL, UNSAT_TRANSP, UNSAT_WATER, UNSAT_WT_POT, UnsatMoistAvg, UnsatZavg, and write_output().

{
    #define numOutputs 50000
    static int iw[numOutputs];
    int oIndex;
    ViewParm   *vp;

    static outVar_struct tgen[] = {
      { (float**)&TP_settlDays, "TP_settlDays", 'f' },
      { (float**)&FLOC, "FLOC", 'f' },
      { (float**)&FLOC_DECOMP, "FLOC_DECOMP", 'f' },
      { (float**)&FLOC_DECOMP_POT, "FLOC_DECOMP_POT", 'f' },
      { (float**)&FLOC_DECOMP_QUAL_CF, "FLOC_DECOMP_QUAL_CF", 'f' },
      { (float**)&FLOC_DEPO, "FLOC_DEPO", 'f' },
      { (float**)&FLOC_DEPO_POT, "FLOC_DEPO_POT", 'f' },
      { (float**)&FLOC_FR_ALGAE, "FLOC_FR_ALGAE", 'f' },
      { (float**)&FLOC_Z, "FLOC_Z", 'f' },
      { (float**)&FlocP_OMrep, "FlocP_OMrep", 'f' },
      { (float**)&soil_MOIST_CF, "soil_MOIST_CF", 'f' },
      { (float**)&TP_SED_MINER, "TP_SED_MINER", 'f' },
      { (float**)&TP_SFWT_MINER, "TP_SFWT_MINER", 'f' },
      { (float**)&AIR_TEMP, "AIR_TEMP", 'f' },
      { (unsigned char**)&HAB, "HAB", 'c' },
      { (float**)&SOLRAD274, "SOLRAD274", 'f' },
      { (float**)&SOLRADGRD, "SOLRADGRD", 'f' },
      { (float**)&H2O_TEMP, "H2O_TEMP", 'f' },
      { (float**)&HYD_DOM_ACTWAT_PRES, "HYD_DOM_ACTWAT_PRES", 'f' },
      { (float**)&HYD_DOM_ACTWAT_VOL, "HYD_DOM_ACTWAT_VOL", 'f' },
      { (float**)&HYD_ET, "HYD_ET", 'f' },
      { (float**)&HYD_EVAP_CALC, "HYD_EVAP_CALC", 'f' },
      { (float**)&HYD_MANNINGS_N, "HYD_MANNINGS_N", 'f' },
      { (float**)&HYD_SAT_POT_TRANS, "HYD_SAT_POT_TRANS", 'f' },
      { (float**)&HYD_SED_WAT_VOL, "HYD_SED_WAT_VOL", 'f' },
      { (float**)&HYD_TOT_POT_TRANSP, "HYD_TOT_POT_TRANSP", 'f' },
      { (float**)&HYD_TRANSP, "HYD_TRANSP", 'f' },
      { (float**)&HYD_UNSAT_POT_TRANS, "HYD_UNSAT_POT_TRANS", 'f' },
      { (float**)&HYD_WATER_AVAIL, "HYD_WATER_AVAIL", 'f' },
      { (float**)&HydTotHd, "HydTotHd", 'f' },
      { (float**)&HydRelDepPosNeg, "HydRelDepPosNeg", 'f' },
      { (float**)&LAI_eff, "LAI_eff", 'f' },
      { (float**)&MAC_WATER_AVAIL_CF, "MAC_WATER_AVAIL_CF", 'f' },
      { (float**)&SAT_TO_UNSAT_FL, "SAT_TO_UNSAT_FL", 'f' },
      { (float**)&SAT_VS_UNSAT, "SAT_VS_UNSAT", 'f' },
      { (float**)&SAT_WATER, "SAT_WATER", 'f' },
      { (float**)&SAT_WT_HEAD, "SAT_WT_HEAD", 'f' },
      { (float**)&SAT_WT_RECHG, "SAT_WT_RECHG", 'f' },
      { (float**)&SAT_WT_TRANSP, "SAT_WT_TRANSP", 'f' },
      { (float**)&SF_WT_EVAP, "SF_WT_EVAP", 'f' },
      { (float**)&SF_WT_FROM_RAIN, "SF_WT_FROM_RAIN", 'f' },
      { (float**)&SF_WT_INFILTRATION, "SF_WT_INFILTRATION", 'f' },
      { (float**)&SF_WT_POT_INF, "SF_WT_POT_INF", 'f' },
      { (float**)&SF_WT_TO_SAT_DOWNFLOW, "SF_WT_TO_SAT_DOWNFLOW", 'f' },
      { (float**)&SF_WT_VEL_mag, "SF_WT_VEL_mag", 'f' },
      { (float**)&BCmodel_sfwat, "BCmodel_sfwat", 'f' },
      { (float**)&SFWT_VOL, "SFWT_VOL", 'f' },
      { (float**)&SURFACE_WAT, "SURFACE_WAT", 'f' },
      { (float**)&UNSAT_AVAIL, "UNSAT_AVAIL", 'f' },
      { (float**)&UNSAT_CAP, "UNSAT_CAP", 'f' },
      { (float**)&UNSAT_DEPTH, "UNSAT_DEPTH", 'f' },
      { (float**)&UNSAT_HYD_COND_CF, "UNSAT_HYD_COND_CF", 'f' },
      { (float**)&UNSAT_MOIST_PRP, "UNSAT_MOIST_PRP", 'f' },
      { (float**)&UNSAT_PERC, "UNSAT_PERC", 'f' },
      { (float**)&UNSAT_TO_SAT_FL, "UNSAT_TO_SAT_FL", 'f' },
      { (float**)&UNSAT_TRANSP, "UNSAT_TRANSP", 'f' },
      { (float**)&UNSAT_WATER, "UNSAT_WATER", 'f' },
      { (float**)&UNSAT_WT_POT, "UNSAT_WT_POT", 'f' },
      { (float**)&ELEVATION, "ELEVATION", 'f' },
      { (float**)&HYD_RCCONDUCT, "HYD_RCCONDUCT", 'f' },
      { (unsigned char**)&ON_MAP, "ON_MAP", 'c' },
      { (float**)&SED_INACT_Z, "SED_INACT_Z", 'f' },
      { (float**)&MAC_HEIGHT, "MAC_HEIGHT", 'f' },
      { (float**)&MAC_LAI, "MAC_LAI", 'f' },
      { (float**)&MAC_LIGHT_CF, "MAC_LIGHT_CF", 'f' },
      { (float**)&MAC_MAX_BIO, "MAC_MAX_BIO", 'f' },
      { (float**)&MAC_NOPH_BIOMAS, "MAC_NOPH_BIOMAS", 'f' },
      { (float**)&mac_nph_PC_rep, "mac_nph_PC_rep", 'f' },
      { (float**)&MAC_NUT_CF, "MAC_NUT_CF", 'f' },
      { (float**)&MAC_PH_BIOMAS, "MAC_PH_BIOMAS", 'f' },
      { (float**)&mac_ph_PC_rep, "mac_ph_PC_rep", 'f' },
      { (float**)&MAC_PROD_CF, "MAC_PROD_CF", 'f' },
      { (float**)&MAC_REL_BIOM, "MAC_REL_BIOM", 'f' },
      { (float**)&MAC_SALT_CF, "MAC_SALT_CF", 'f' },
      { (float**)&MAC_TEMP_CF, "MAC_TEMP_CF", 'f' },
      { (float**)&MAC_TOT_BIOM, "MAC_TOT_BIOM", 'f' },
      { (float**)&MAC_WATER_CF, "MAC_WATER_CF", 'f' },
      { (float**)&NPHBIO_AVAIL, "NPHBIO_AVAIL", 'f' },
      { (float**)&NPHBIO_MORT, "NPHBIO_MORT", 'f' },
      { (float**)&NPHBIO_MORT_POT, "NPHBIO_MORT_POT", 'f' },
      { (float**)&NPHBIO_REFUGE, "NPHBIO_REFUGE", 'f' },
      { (float**)&NPHBIO_SAT, "NPHBIO_SAT", 'f' },
      { (float**)&NPHBIO_TRANSLOC, "NPHBIO_TRANSLOC", 'f' },
      { (float**)&NPHBIO_TRANSLOC_POT, "NPHBIO_TRANSLOC_POT", 'f' },
      { (float**)&PHBIO_AVAIL, "PHBIO_AVAIL", 'f' },
      { (float**)&PHBIO_MORT, "PHBIO_MORT", 'f' },
      { (float**)&PHBIO_MORT_POT, "PHBIO_MORT_POT", 'f' },
      { (float**)&PHBIO_NPP, "PHBIO_NPP", 'f' },
      { (float**)&PHBIO_REFUGE, "PHBIO_REFUGE", 'f' },
      { (float**)&PHBIO_SAT, "PHBIO_SAT", 'f' },
      { (float**)&PHBIO_TRANSLOC, "PHBIO_TRANSLOC", 'f' },
      { (float**)&PHBIO_TRANSLOC_POT, "PHBIO_TRANSLOC_POT", 'f' },
      { (float**)&TP_SEDWT_UPTAKE, "TP_SEDWT_UPTAKE", 'f' },
      { (float**)&ALG_INCID_LIGHT, "ALG_INCID_LIGHT", 'f' },
      { (float**)&ALG_LIGHT_CF, "ALG_LIGHT_CF", 'f' },
      { (float**)&ALG_LIGHT_EXTINCT, "ALG_LIGHT_EXTINCT", 'f' },
      { (float**)&ALG_REFUGE, "ALG_REFUGE", 'f' },
      { (float**)&ALG_SAT, "ALG_SAT", 'f' },
      { (float**)&ALG_TEMP_CF, "ALG_TEMP_CF", 'f' },
      { (float**)&ALG_TOT, "ALG_TOT", 'f' },
      { (float**)&ALG_WAT_CF, "ALG_WAT_CF", 'f' },
      { (float**)&C_ALG, "C_ALG", 'f' },
      { (float**)&C_ALG_AVAIL_MORT, "C_ALG_AVAIL_MORT", 'f' },
      { (float**)&C_ALG_GPP, "C_ALG_GPP", 'f' },
      { (float**)&C_ALG_MORT, "C_ALG_MORT", 'f' },
      { (float**)&C_ALG_MORT_POT, "C_ALG_MORT_POT", 'f' },
      { (float**)&C_ALG_NPP, "C_ALG_NPP", 'f' },
      { (float**)&C_ALG_NUT_CF, "C_ALG_NUT_CF", 'f' },
      { (float**)&C_ALG_PROD_CF, "C_ALG_PROD_CF", 'f' },
      { (float**)&C_ALG_RESP, "C_ALG_RESP", 'f' },
      { (float**)&C_ALG_RESP_POT, "C_ALG_RESP_POT", 'f' },
      { (float**)&NC_ALG, "NC_ALG", 'f' },
      { (float**)&NC_ALG_AVAIL_MORT, "NC_ALG_AVAIL_MORT", 'f' },
      { (float**)&NC_ALG_GPP, "NC_ALG_GPP", 'f' },
      { (float**)&NC_ALG_MORT, "NC_ALG_MORT", 'f' },
      { (float**)&NC_ALG_MORT_POT, "NC_ALG_MORT_POT", 'f' },
      { (float**)&NC_ALG_NPP, "NC_ALG_NPP", 'f' },
      { (float**)&NC_ALG_NUT_CF, "NC_ALG_NUT_CF", 'f' },
      { (float**)&NC_ALG_PROD_CF, "NC_ALG_PROD_CF", 'f' },
      { (float**)&NC_ALG_RESP, "NC_ALG_RESP", 'f' },
      { (float**)&NC_ALG_RESP_POT, "NC_ALG_RESP_POT", 'f' },
      { (float**)&TP_SFWT_UPTAK, "TP_SFWT_UPTAK", 'f' },
      { (float**)&TP_Act_to_TotRep, "TP_Act_to_TotRep", 'f' },
      { (float**)&TP_DNFLOW, "TP_DNFLOW", 'f' },
      { (float**)&TP_DNFLOW_POT, "TP_DNFLOW_POT", 'f' },
      { (float**)&TP_Atm_Depos, "TP_Atm_Depos", 'f' },
      { (float**)&TP_K, "TP_K", 'f' },
      { (double**)&TP_SED_CONC, "TP_SED_CONC", 'd' },
      { (double**)&TP_SED_WT, "TP_SED_WT", 'd' },
      { (double**)&TP_SED_WT_AZ, "TP_SED_WT_AZ", 'd' },
      { (double**)&TP_SEDWT_CONCACT, "TP_SEDWT_CONCACT", 'd' },
      { (float**)&TP_SEDWT_CONCACTMG, "TP_SEDWT_CONCACTMG", 'f' },
      { (float**)&TP_settl, "TP_settl", 'f' },
      { (double**)&TP_SF_WT, "TP_SF_WT", 'd' },
      { (double**)&TP_SFWT_CONC, "TP_SFWT_CONC", 'd' },
      { (float**)&TP_SFWT_CONC_MG, "TP_SFWT_CONC_MG", 'f' },
      { (double**)&TP_SORB, "TP_SORB", 'd' },
      { (float**)&TP_SORB_POT, "TP_SORB_POT", 'f' },
      { (double**)&TP_SORBCONC, "TP_SORBCONC", 'd' },
      { (float**)&TP_SORBCONC_rep, "TP_SORBCONC_rep", 'f' },
      { (float**)&TP_SORBTION, "TP_SORBTION", 'f' },
      { (float**)&TP_UPFLOW, "TP_UPFLOW", 'f' },
      { (float**)&TP_UPFLOW_POT, "TP_UPFLOW_POT", 'f' },
      { (double**)&SAL_SED_WT, "SAL_SED_WT", 'd' },
      { (float**)&SAL_SF_WT, "SAL_SF_WT", 'f' },
      { (float**)&SALT_SED_TO_SF_FLOW, "SALT_SED_TO_SF_FLOW", 'f' },
      { (double**)&SALT_SED_WT, "SALT_SED_WT", 'd' },
      { (float**)&SALT_SFWAT_DOWNFL, "SALT_SFWAT_DOWNFL", 'f' },
      { (float**)&SALT_SFWAT_DOWNFL_POT, "SALT_SFWAT_DOWNFL_POT", 'f' },
      { (double**)&SALT_SURF_WT, "SALT_SURF_WT", 'd' },
      { (float**)&SALT_Atm_Depos, "SALT_Atm_Depos", 'f' },
      { (double**)&DEPOS_ORG_MAT, "DEPOS_ORG_MAT", 'd' },
      { (float**)&DOM_DECOMP, "DOM_DECOMP", 'f' },
      { (float**)&DOM_DECOMP_POT, "DOM_DECOMP_POT", 'f' },
      { (float**)&DOM_FR_FLOC, "DOM_FR_FLOC", 'f' },
      { (double**)&DOM_P_OM, "DOM_P_OM", 'd' },
      { (float**)&DOM_QUALITY_CF, "DOM_QUALITY_CF", 'f' },
      { (float**)&DOM_SED_AEROB_Z, "DOM_SED_AEROB_Z", 'f' },
      { (float**)&DOM_SED_ANAEROB_Z, "DOM_SED_ANAEROB_Z", 'f' },
      { (float**)&DOM_TEMP_CF, "DOM_TEMP_CF", 'f' },
      { (float**)&DOM_Z, "DOM_Z", 'f' },
      { (double**)&DOP, "DOP", 'd' },
      { (float**)&DOP_DECOMP, "DOP_DECOMP", 'f' },
      { (float**)&P_SUM_CELL, "P_SUM_CELL", 'f' },
      { (float**)&SED_ELEV, "SED_ELEV", 'f' },
      { (float**)&TPtoSOIL_rep, "TPtoSOIL_rep", 'f' },
      { (float**)&Floc_fr_phBioAvg, "Floc_fr_phBioAvg", 'f' },
      { (float**)&TPSfMinAvg, "TPSfMinAvg", 'f' },
      { (float**)&ETAvg, "ETAvg", 'f' },
      { (float**)&EvapAvg, "EvapAvg", 'f' },
      { (float**)&HydPerAnn, "HydPerAnn", 'f' },
      { (float**)&LAI_effAvg, "LAI_effAvg", 'f' },
      { (float**)&Manning_nAvg, "Manning_nAvg", 'f' },
      { (float**)&RainAvg, "RainAvg", 'f' },
      { (float**)&SfWatAvg, "SfWatAvg", 'f' },
      { (float**)&TotHeadAvg, "TotHeadAvg", 'f' },
      { (float**)&HydRelDepPosNegAvg, "HydRelDepPosNegAvg", 'f' },
      { (float**)&TranspAvg, "TranspAvg", 'f' },
      { (float**)&UnsatMoistAvg, "UnsatMoistAvg", 'f' },
      { (float**)&UnsatZavg, "UnsatZavg", 'f' },
      { (float**)&SF_WT_VEL_magAvg, "SF_WT_VEL_magAvg", 'f' },
      { (float**)&BCmodel_sfwatAvg, "BCmodel_sfwatAvg", 'f' },
      { (float**)&mac_nph_PCAvg, "mac_nph_PCAvg", 'f' },
      { (float**)&Mac_nphBioAvg, "Mac_nphBioAvg", 'f' },
      { (float**)&Mac_nphMortAvg, "Mac_nphMortAvg", 'f' },
      { (float**)&Mac_nppAvg, "Mac_nppAvg", 'f' },
      { (float**)&mac_ph_PCAvg, "mac_ph_PCAvg", 'f' },
      { (float**)&Mac_phBioAvg, "Mac_phBioAvg", 'f' },
      { (float**)&Mac_phMortAvg, "Mac_phMortAvg", 'f' },
      { (float**)&Mac_totBioAvg, "Mac_totBioAvg", 'f' },
      { (float**)&MacNutCfAvg, "MacNutCfAvg", 'f' },
      { (float**)&MacWatCfAvg, "MacWatCfAvg", 'f' },
      { (float**)&TPSedUptAvg, "TPSedUptAvg", 'f' },
      { (float**)&C_Peri_mortAvg, "C_Peri_mortAvg", 'f' },
      { (float**)&C_Peri_nppAvg, "C_Peri_nppAvg", 'f' },
      { (float**)&C_Peri_PCAvg, "C_Peri_PCAvg", 'f' },
      { (float**)&C_PeriAvg, "C_PeriAvg", 'f' },
      { (float**)&C_PeriNutCFAvg, "C_PeriNutCFAvg", 'f' },
      { (float**)&C_PeriRespAvg, "C_PeriRespAvg", 'f' },
      { (float**)&NC_Peri_mortAvg, "NC_Peri_mortAvg", 'f' },
      { (float**)&NC_Peri_nppAvg, "NC_Peri_nppAvg", 'f' },
      { (float**)&NC_Peri_PCAvg, "NC_Peri_PCAvg", 'f' },
      { (float**)&NC_PeriAvg, "NC_PeriAvg", 'f' },
      { (float**)&NC_PeriNutCFAvg, "NC_PeriNutCFAvg", 'f' },
      { (float**)&NC_PeriRespAvg, "NC_PeriRespAvg", 'f' },
      { (float**)&PeriAvg, "PeriAvg", 'f' },
      { (float**)&PeriLiteCFAvg, "PeriLiteCFAvg", 'f' },
      { (float**)&TPSfUptAvg, "TPSfUptAvg", 'f' },
      { (float**)&TP_settlAvg, "TP_settlAvg", 'f' },
      { (float**)&TPSedWatAvg, "TPSedWatAvg", 'f' },
      { (float**)&TPSfWatAvg, "TPSfWatAvg", 'f' },
      { (float**)&SaltSedAvg, "SaltSedAvg", 'f' },
      { (float**)&SaltSfAvg, "SaltSfAvg", 'f' },
      { (float**)&SedElevAvg, "SedElevAvg", 'f' },
      { (float**)&TPSedMinAvg, "TPSedMinAvg", 'f' },
      { (float**)&TPSorbAvg, "TPSorbAvg", 'f' },
      { (float**)&TPtoSOILAvg, "TPtoSOILAvg", 'f' },
      { (float**)&TPtoVOLAvg, "TPtoVOLAvg", 'f' },








      { NULL, NULL, '\0' },
  };
  
    outVar_struct *ptable;
    int  i;

    for (i = 0, ptable = tgen; ptable->pfvar != NULL; ptable++, i++)
    {
  vp = view + i;

/* TODO: develop flexible output of calendar-based and julian-based outsteps (jan 11, 2005) */
if (vp->step > 0)
                
            if (strcmp(ptable->pname,"HydPerAnn")!=0) { /* i.e., not the HydPerAnn variable */
                
                if  (step % vp->step == 0 && (vp->step != CalMonOut) ) {   /* standard julian-day outstep interval variables (note: the != CalMonOut needed for step=0) */ 
                    oIndex = iw[i]++;
                    write_output(oIndex, vp, *(ptable->pfvar), ptable->pname, ptable->ctype, step);
                }
                else if ( (avgPrint) && (vp->step == CalMonOut) ) { /* variables output at the special 1-calendar-month outstep interval */  
                    oIndex = iw[i]++;
                    write_output(oIndex, vp, *(ptable->pfvar), ptable->pname, ptable->ctype, step);
                }
            }
        
            else
                if (FMOD(DAYJUL, 273.0) ==0) { /* hydroperiod is printed at a special-case time (approximately Oct 1 every year) */
                    oIndex = iw[i]++;
                    write_output(oIndex, vp, *(ptable->pfvar), ptable->pname, ptable->ctype, step);
                }
        
     
    }

        /* after printing, zero the arrays holding averages or hydroperiods (v2.2.1note using avgPrint var)*/
    if (avgPrint) {
        Cell_reset_avg();
    }

    if (FMOD(DAYJUL, 273.0) ==0) {
        Cell_reset_hydper();
    }


} /* end of gen_output routine */

Here is the call graph for this function:

void ReadGlobalParms	(	char *	s_parm_name,
		int	s_parm_relval
	)

Acquire the model parameters that are global to the domain.

Parameters:

	s_parm_name	Name of the sensitivity parameter being varied for this run
	s_parm_relval	Indicator of current value of relative range in sensitivity parm values: nominal (0), low (1), or high (2)

Definition at line 2532 of file UnitMod.c.

References get_global_parm(), GP_alg_alkP_min, GP_ALG_C_TO_OM, GP_ALG_IC_MULT, GP_alg_light_ext_coef, GP_ALG_LIGHT_SAT, GP_ALG_PC, GP_alg_R_accel, GP_ALG_RC_MORT, GP_ALG_RC_MORT_DRY, GP_ALG_RC_PROD, GP_ALG_RC_RESP, GP_ALG_REF_MULT, GP_ALG_SHADE_FACTOR, GP_ALG_TEMP_OPT, GP_alg_uptake_coef, GP_AlgComp, GP_algMortDepth, GP_ALTIT, GP_C_ALG_KS_P, GP_C_ALG_threshTP, GP_calibDecomp, GP_calibET, GP_calibGWat, GP_CL_IN_RAIN, GP_DATUM_DISTANCE, GP_DetentZ, GP_dispLenRef, GP_dispParm, GP_DOM_decomp_coef, GP_DOM_DECOMP_POPT, GP_DOM_DECOMP_TOPT, GP_DOM_DECOMPRED, GP_DOM_RCDECOMP, GP_Floc_BD, GP_Floc_rcSoil, GP_FlocMax, GP_HYD_IC_SFWAT_ADD, GP_HYD_IC_UNSAT_ADD, GP_HYD_ICUNSATMOIST, GP_HYD_RCRECHG, GP_IC_BATHY_MULT, GP_IC_BulkD_MULT, GP_IC_DOM_BD_MULT, GP_IC_ELEV_MULT, GP_IC_TPtoSOIL_MULT, GP_IDW_pow, GP_LATDEG, GP_MAC_IC_MULT, GP_MAC_REFUG_MULT, GP_mac_uptake_coef, GP_mann_height_coef, GP_mannDepthPow, GP_mannHeadPow, GP_MinCheck, GP_NC_ALG_KS_P, GP_PO4toTP, GP_PO4toTPint, GP_settlVel, GP_SLRise, GP_SOLOMEGA, GP_sorbToTP, GP_TP_DIFFCOEF, GP_TP_DIFFDEPTH, GP_TP_ICSEDWAT, GP_TP_ICSFWAT, GP_TP_IN_RAIN, GP_TP_K_INTER, GP_TP_K_SLOPE, GP_TP_P_OM, GP_TPpart_thresh, GP_WQMthresh, and GP_WQualMonitZ.

 {
     
/* Geography, hydrology */
    GP_SOLOMEGA = get_global_parm(s_parm_name, s_parm_relval,"GP_SOLOMEGA"); 
    GP_ALTIT = get_global_parm(s_parm_name, s_parm_relval,"GP_ALTIT"); 
    GP_LATDEG = get_global_parm(s_parm_name, s_parm_relval,"GP_LATDEG"); 
    GP_mannDepthPow = get_global_parm(s_parm_name, s_parm_relval,"GP_mannDepthPow"); 
    GP_mannHeadPow = get_global_parm(s_parm_name, s_parm_relval,"GP_mannHeadPow"); 
    GP_calibGWat = get_global_parm(s_parm_name, s_parm_relval,"GP_calibGWat"); 
    GP_IDW_pow = get_global_parm(s_parm_name, s_parm_relval,"GP_IDW_pow"); 
    GP_calibET = get_global_parm(s_parm_name, s_parm_relval,"GP_calibET"); 
    GP_DATUM_DISTANCE = get_global_parm(s_parm_name, s_parm_relval,"GP_DATUM_DISTANCE"); 
    GP_HYD_IC_SFWAT_ADD = get_global_parm(s_parm_name, s_parm_relval,"GP_HYD_IC_SFWAT_ADD"); 
    GP_HYD_IC_UNSAT_ADD = get_global_parm(s_parm_name, s_parm_relval,"GP_HYD_IC_UNSAT_ADD"); 
    GP_HYD_RCRECHG = get_global_parm(s_parm_name, s_parm_relval,"GP_HYD_RCRECHG"); 
    GP_HYD_ICUNSATMOIST = get_global_parm(s_parm_name, s_parm_relval,"GP_HYD_ICUNSATMOIST"); 
    GP_DetentZ = get_global_parm(s_parm_name, s_parm_relval,"GP_DetentZ"); 
    GP_WQualMonitZ = get_global_parm(s_parm_name, s_parm_relval,"GP_WQualMonitZ"); 
    GP_MinCheck = get_global_parm(s_parm_name, s_parm_relval,"GP_MinCheck"); 
    GP_SLRise = get_global_parm(s_parm_name, s_parm_relval,"GP_SLRise"); 
    GP_dispLenRef = get_global_parm(s_parm_name, s_parm_relval,"GP_dispLenRef"); 
    GP_dispParm = get_global_parm(s_parm_name, s_parm_relval,"GP_dispParm"); 
 
 /* Periphyton/Algae */
    GP_ALG_IC_MULT = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_IC_MULT"); 
    GP_alg_uptake_coef = get_global_parm(s_parm_name, s_parm_relval,"GP_alg_uptake_coef"); 
    GP_ALG_SHADE_FACTOR = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_SHADE_FACTOR"); 
    GP_algMortDepth = get_global_parm(s_parm_name, s_parm_relval,"GP_algMortDepth"); 
    GP_ALG_RC_MORT_DRY = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_RC_MORT_DRY"); 
    GP_ALG_RC_MORT = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_RC_MORT"); 
    GP_ALG_RC_PROD = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_RC_PROD"); 
    GP_ALG_RC_RESP = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_RC_RESP"); 
    GP_alg_R_accel = get_global_parm(s_parm_name, s_parm_relval,"GP_alg_R_accel"); 
    GP_AlgComp = get_global_parm(s_parm_name, s_parm_relval,"GP_AlgComp"); 
    GP_ALG_REF_MULT = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_REF_MULT"); 
    GP_NC_ALG_KS_P = get_global_parm(s_parm_name, s_parm_relval,"GP_NC_ALG_KS_P"); 
    GP_alg_alkP_min = get_global_parm(s_parm_name, s_parm_relval,"GP_alg_alkP_min"); 
    GP_C_ALG_KS_P = get_global_parm(s_parm_name, s_parm_relval,"GP_C_ALG_KS_P"); 
    GP_ALG_TEMP_OPT = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_TEMP_OPT"); 
    GP_C_ALG_threshTP = get_global_parm(s_parm_name, s_parm_relval,"GP_C_ALG_threshTP"); 
    GP_ALG_C_TO_OM = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_C_TO_OM"); 
    GP_alg_light_ext_coef = get_global_parm(s_parm_name, s_parm_relval,"GP_alg_light_ext_coef"); 
    GP_ALG_LIGHT_SAT = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_LIGHT_SAT"); 
    GP_ALG_PC = get_global_parm(s_parm_name, s_parm_relval,"GP_ALG_PC"); 

/* Soil */
    GP_DOM_RCDECOMP = get_global_parm(s_parm_name, s_parm_relval,"GP_DOM_RCDECOMP"); 
    GP_DOM_DECOMPRED = get_global_parm(s_parm_name, s_parm_relval,"GP_DOM_DECOMPRED"); 
    GP_calibDecomp = get_global_parm(s_parm_name, s_parm_relval,"GP_calibDecomp"); 
    GP_DOM_decomp_coef = get_global_parm(s_parm_name, s_parm_relval,"GP_DOM_decomp_coef"); 
    GP_DOM_DECOMP_POPT = get_global_parm(s_parm_name, s_parm_relval,"GP_DOM_DECOMP_POPT"); 
    GP_DOM_DECOMP_TOPT = get_global_parm(s_parm_name, s_parm_relval,"GP_DOM_DECOMP_TOPT"); 
    GP_sorbToTP = get_global_parm(s_parm_name, s_parm_relval,"GP_sorbToTP"); 
    GP_IC_ELEV_MULT = get_global_parm(s_parm_name, s_parm_relval,"GP_IC_ELEV_MULT"); 
    GP_IC_BATHY_MULT = get_global_parm(s_parm_name, s_parm_relval,"GP_IC_BATHY_MULT"); 
    GP_IC_DOM_BD_MULT = get_global_parm(s_parm_name, s_parm_relval,"GP_IC_DOM_BD_MULT"); 
    GP_IC_BulkD_MULT = get_global_parm(s_parm_name, s_parm_relval,"GP_IC_BulkD_MULT"); 
    GP_IC_TPtoSOIL_MULT = get_global_parm(s_parm_name, s_parm_relval,"GP_IC_TPtoSOIL_MULT"); 
 
/* Macrophytes */
    GP_MAC_IC_MULT = get_global_parm(s_parm_name, s_parm_relval,"GP_MAC_IC_MULT"); 
    GP_MAC_REFUG_MULT = get_global_parm(s_parm_name, s_parm_relval,"GP_MAC_REFUG_MULT"); 
    GP_mac_uptake_coef = get_global_parm(s_parm_name, s_parm_relval,"GP_mac_uptake_coef"); 
    GP_mann_height_coef = get_global_parm(s_parm_name, s_parm_relval,"GP_mann_height_coef"); 

/* Floc */
    GP_Floc_BD = get_global_parm(s_parm_name, s_parm_relval,"GP_Floc_BD"); 
    GP_FlocMax = get_global_parm(s_parm_name, s_parm_relval,"GP_FlocMax"); 
    GP_TP_P_OM = get_global_parm(s_parm_name, s_parm_relval,"GP_TP_P_OM"); 
    GP_Floc_rcSoil = get_global_parm(s_parm_name, s_parm_relval,"GP_Floc_rcSoil"); 
                
/* Phosphorus */
    GP_TP_DIFFCOEF = get_global_parm(s_parm_name, s_parm_relval,"GP_TP_DIFFCOEF"); 
    GP_TP_K_INTER = get_global_parm(s_parm_name, s_parm_relval,"GP_TP_K_INTER"); 
    GP_TP_K_SLOPE = get_global_parm(s_parm_name, s_parm_relval,"GP_TP_K_SLOPE"); 
    GP_WQMthresh = get_global_parm(s_parm_name, s_parm_relval,"GP_WQMthresh"); 
    GP_PO4toTP = get_global_parm(s_parm_name, s_parm_relval,"GP_PO4toTP"); 
    GP_TP_IN_RAIN = get_global_parm(s_parm_name, s_parm_relval,"GP_TP_IN_RAIN"); 
    GP_CL_IN_RAIN = get_global_parm(s_parm_name, s_parm_relval,"GP_CL_IN_RAIN"); 
    GP_PO4toTPint = get_global_parm(s_parm_name, s_parm_relval,"GP_PO4toTPint"); 
    GP_TP_ICSFWAT = get_global_parm(s_parm_name, s_parm_relval,"GP_TP_ICSFWAT"); 
    GP_TP_ICSEDWAT = get_global_parm(s_parm_name, s_parm_relval,"GP_TP_ICSEDWAT"); 
    GP_TPpart_thresh = get_global_parm(s_parm_name, s_parm_relval,"GP_TPpart_thresh"); 
    GP_TP_DIFFDEPTH = get_global_parm(s_parm_name, s_parm_relval,"GP_TP_DIFFDEPTH"); 
    GP_settlVel = get_global_parm(s_parm_name, s_parm_relval,"GP_settlVel"); 
    
}

Here is the call graph for this function:

void ReadHabParms	(	char *	s_parm_name,
		int	s_parm_relval
	)

Acquire the model parameters that are specific to different habitat types in the domain.

Parameters:

	s_parm_name	Name of the sensitivity parameter being varied for this run
	s_parm_relval	Indicator of current value of relative range in sensitivity parm values: nominal (0), low (1), or high (2)

Remarks:

The get_hab_parm function called during initialization expects the appropriate habitat-specific parameter to have a first header line that has parameter names that exactly match those in this code.

The ordering of function calls to read the parameters is unimportant; the ordering of the modules in the datafile is unimportant. However, the sequence of the column-field parameter names in header must (obviously?) correspond to the data columns.

Definition at line 2463 of file UnitMod.c.

References get_hab_parm(), HP_ALG_MAX, HP_DOM_AEROBTHIN, HP_DOM_MAXDEPTH, HP_FireInt, HP_FLOC_IC, HP_FLOC_IC_CTOOM, HP_FLOC_IC_PC, HP_HYD_POROSITY, HP_HYD_RCINFILT, HP_HYD_SPEC_YIELD, HP_MAC_CANOPDECOUP, HP_MAC_KSP, HP_MAC_LIGHTSAT, HP_MAC_MAXCANOPCOND, HP_MAC_MAXHT, HP_MAC_MAXLAI, HP_MAC_MAXROUGH, HP_MAC_MINROUGH, HP_MAC_SALIN_THRESH, HP_MAC_TEMPOPT, HP_MAC_TRANSLOC_RC, HP_MAC_WAT_TOLER, HP_NPHBIO_IC_CTOOM, HP_NPHBIO_IC_PC, HP_NPHBIO_MAX, HP_NPHBIO_ROOTDEPTH, HP_PHBIO_IC_CTOOM, HP_PHBIO_IC_PC, HP_PHBIO_MAX, HP_PHBIO_RCMORT, HP_PHBIO_RCNPP, HP_PhosHi, HP_PhosInt, HP_PhosLo, HP_SalinHi, HP_SalinInt, HP_SalinLo, HP_SALT_ICSEDWAT, HP_SALT_ICSFWAT, HP_SfDepthHi, HP_SfDepthInt, HP_SfDepthLo, and HP_TP_CONC_GRAD.

{

 /* Periphyton/Algae */
  HP_ALG_MAX = get_hab_parm(s_parm_name, s_parm_relval, "HP_ALG_MAX"); 

/* Soil */
  HP_DOM_MAXDEPTH = get_hab_parm(s_parm_name, s_parm_relval,"HP_DOM_MAXDEPTH");  
  HP_DOM_AEROBTHIN = get_hab_parm(s_parm_name, s_parm_relval,"HP_DOM_AEROBTHIN"); 

/* Phosphorus */
  HP_TP_CONC_GRAD = get_hab_parm(s_parm_name, s_parm_relval,"HP_TP_CONC_GRAD"); 

/* Salt/tracer */
  HP_SALT_ICSEDWAT = get_hab_parm(s_parm_name, s_parm_relval,"HP_SALT_ICSEDWAT"); 
  HP_SALT_ICSFWAT = get_hab_parm(s_parm_name, s_parm_relval,"HP_SALT_ICSFWAT"); 
        
/* Macrophytes */
  HP_PHBIO_MAX = get_hab_parm(s_parm_name, s_parm_relval,"HP_PHBIO_MAX"); 
  HP_NPHBIO_MAX = get_hab_parm(s_parm_name, s_parm_relval,"HP_NPHBIO_MAX"); 
  HP_MAC_MAXHT = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_MAXHT"); 
  HP_NPHBIO_ROOTDEPTH = get_hab_parm(s_parm_name, s_parm_relval,"HP_NPHBIO_ROOTDEPTH"); 
  HP_MAC_MAXROUGH = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_MAXROUGH"); 
  HP_MAC_MINROUGH = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_MINROUGH"); 
  HP_MAC_MAXLAI = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_MAXLAI"); 
  HP_MAC_MAXCANOPCOND = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_MAXCANOPCOND"); /* unused in ELMv2.2, 2.3 */ 
  HP_MAC_CANOPDECOUP = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_CANOPDECOUP"); /* unused in ELMv2.2, 2.3 */ 
  HP_MAC_TEMPOPT = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_TEMPOPT"); 
  HP_MAC_LIGHTSAT = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_LIGHTSAT"); 
  HP_MAC_KSP = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_KSP"); 
  HP_PHBIO_RCNPP = get_hab_parm(s_parm_name, s_parm_relval,"HP_PHBIO_RCNPP"); 
  HP_PHBIO_RCMORT = get_hab_parm(s_parm_name, s_parm_relval,"HP_PHBIO_RCMORT"); 
  HP_MAC_WAT_TOLER = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_WAT_TOLER"); 
  HP_MAC_SALIN_THRESH = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_SALIN_THRESH"); /* unused in ELMv2.2, 2.3 */ 
  HP_PHBIO_IC_CTOOM = get_hab_parm(s_parm_name, s_parm_relval,"HP_PHBIO_IC_CTOOM"); 
  HP_NPHBIO_IC_CTOOM = get_hab_parm(s_parm_name, s_parm_relval,"HP_NPHBIO_IC_CTOOM"); 
  HP_PHBIO_IC_PC = get_hab_parm(s_parm_name, s_parm_relval,"HP_PHBIO_IC_PC"); 
  HP_NPHBIO_IC_PC = get_hab_parm(s_parm_name, s_parm_relval,"HP_NPHBIO_IC_PC"); 
  HP_MAC_TRANSLOC_RC = get_hab_parm(s_parm_name, s_parm_relval,"HP_MAC_TRANSLOC_RC"); 

/* Hydrology */
  HP_HYD_RCINFILT = get_hab_parm(s_parm_name, s_parm_relval,"HP_HYD_RCINFILT"); 
  HP_HYD_SPEC_YIELD = get_hab_parm(s_parm_name, s_parm_relval,"HP_HYD_SPEC_YIELD");  
  HP_HYD_POROSITY = get_hab_parm(s_parm_name, s_parm_relval,"HP_HYD_POROSITY"); 

/* Floc */
  HP_FLOC_IC = get_hab_parm(s_parm_name, s_parm_relval,"HP_FLOC_IC"); 
  HP_FLOC_IC_CTOOM = get_hab_parm(s_parm_name, s_parm_relval,"HP_FLOC_IC_CTOOM"); 
  HP_FLOC_IC_PC = get_hab_parm(s_parm_name, s_parm_relval,"HP_FLOC_IC_PC"); 

/* Habitat succession */
  HP_SfDepthLo = get_hab_parm(s_parm_name, s_parm_relval,"HP_SfDepthLo"); 
  HP_SfDepthHi = get_hab_parm(s_parm_name, s_parm_relval,"HP_SfDepthHi"); 
  HP_SfDepthInt = get_hab_parm(s_parm_name, s_parm_relval,"HP_SfDepthInt"); 
  HP_PhosLo = get_hab_parm(s_parm_name, s_parm_relval,"HP_PhosLo"); 
  HP_PhosHi = get_hab_parm(s_parm_name, s_parm_relval,"HP_PhosHi"); 
  HP_PhosInt = get_hab_parm(s_parm_name, s_parm_relval,"HP_PhosInt"); 
  HP_FireInt = get_hab_parm(s_parm_name, s_parm_relval,"HP_FireInt"); 
  HP_SalinLo = get_hab_parm(s_parm_name, s_parm_relval,"HP_SalinLo"); 
  HP_SalinHi = get_hab_parm(s_parm_name, s_parm_relval,"HP_SalinHi"); 
  HP_SalinInt = get_hab_parm(s_parm_name, s_parm_relval,"HP_SalinInt"); 
  
}

Here is the call graph for this function:

void ReadModExperimParms	(	char *	s_parm_name,
		int	s_parm_relval
	)

Acquire the model parameters that are used in special model experiments - used only in special, research-oriented applications. (Added for v2.6).
NOTE that this was quickly set up for the ELM Peer Review (2006) project, and (at least in v2.6.0) should be used in conjunction with the spatial interpolators for rain and pET inputs. (because this is intended for scales that are potentially incompatible w/ simultaneous use of gridIO inputs on SFWMM stage/depth that are expected w/ gridIO rain/pET).
NOTE: this has not been specifically developed/tested for inclusion within the automated sensitivity analyses - thus only been used at this point for the ModExperimParms_NOM nominal parameter set (Nov 2006).
.

Parameters:

	s_parm_name	Name of the sensitivity parameter being varied for this run
	s_parm_relval	Indicator of current value of relative range in sensitivity parm values: nominal (0), low (1), or high (2)

Definition at line 2636 of file UnitMod.c.

References conv_kgTOmg, get_modexperim_parm(), GP_BC_InputRow, GP_BC_Pconc, GP_BC_SatWat_add, GP_BC_Sconc, GP_BC_SfWat_add, GP_BC_SfWat_addHi, GP_BC_SfWat_targ, isModExperim, msgStr, usrErr(), usrErr0(), and WriteMsg().

 {
    if (isModExperim) {
                 sprintf(msgStr,"####### Reading special model experiment parameters.  \nYou should NOT be using gridIO spatial time series data for rain, pET, and SFWMM-output depth #######..."); 
            WriteMsg(msgStr,1); 
            usrErr0(msgStr);
            
        GP_BC_SfWat_add = get_modexperim_parm(s_parm_name, s_parm_relval,"GP_BC_SfWat_add"); 
        GP_BC_SfWat_addHi = get_modexperim_parm(s_parm_name, s_parm_relval,"GP_BC_SfWat_addHi"); 
        GP_BC_SatWat_add = get_modexperim_parm(s_parm_name, s_parm_relval,"GP_BC_SatWat_add"); 
        GP_BC_SfWat_targ = get_modexperim_parm(s_parm_name, s_parm_relval,"GP_BC_SfWat_targ"); 
        GP_BC_InputRow = get_modexperim_parm(s_parm_name, s_parm_relval,"GP_BC_InputRow"); 
        GP_BC_Pconc = get_modexperim_parm(s_parm_name, s_parm_relval,"GP_BC_Pconc"); /* ug/L */
        GP_BC_Sconc = get_modexperim_parm(s_parm_name, s_parm_relval,"GP_BC_Sconc"); /* g/L */
        
        GP_BC_Pconc /= conv_kgTOmg; /* convert from ug/L to g/L (same as div by the kg->mg conversion) */

            sprintf(msgStr,"done."); 
            WriteMsg(msgStr,1); 
            usrErr(msgStr);
    }
    else {
        GP_BC_SfWat_add = 0.0; /* value of 0.0 has no effect on model results (adds nothing to boundary depth/stages) */
        GP_BC_SfWat_addHi = 0.0; /* value of 0.0 has no effect on model results (adds nothing to boundary depth/stages) */
        GP_BC_SatWat_add = 0.0; /* value of 0.0 has no effect on model results (adds nothing to boundary depth/stages) */
        GP_BC_SfWat_targ = 0.0; /* value of 0.0 has no effect on model results (only used in Oct06 specialized model experiment - code doesn't use this parm otherwise) */
        GP_BC_InputRow = 0; /* value of 0 has no effect on model results (only used in Oct06 specialized model experiment - code doesn't use this parm otherwise) */
        GP_BC_Pconc = 0.0;
        GP_BC_Sconc = 0.0;
    }
 } 

Here is the call graph for this function:

void PtInterp_read

(

void

)

On-the-fly interpolations to develop spatial time series from point data.
.

Read the point data into the lists.
Note that this was quickly set up for the ELM Peer Review (2006) project, and (at least in v2.6.0) needs to be used in conjunction with the model experiment parms for synthetic stage boundary conditions (because it skips all gridIO inputs, including SFWMM stage/depth).

For ELM v2.6, extracted/re-used these code fragments from ELM v2.1 code, with associated updated uses/documentation

Definition at line 2680 of file UnitMod.c.

References NPtTS2, NPtTS3, NPtTS4, NPtTS5, NPtTS6, PTSL_Init(), PTSL_ReadLists(), pTSList2, pTSList3, pTSList4, pTSList5, pTSList6, Timestep2, Timestep3, Timestep4, Timestep5, Timestep6, TIndex2, TIndex3, TIndex4, TIndex5, TIndex6, usrErr(), and usrErr0().

{
                /* rainfall and pET point data for models that do not use gridIO inputs, but use interpolated point time series */
            /* final arg in PTSL_ReadLists is the column number of of the data (not incl. the 3 date columns) */
        usrErr0 ("\n*** WARNING: You are not using gridIO spatial time series data for rain, pET, and SFWMM-output depth.  \nReading rainfall and pET point time series data... ");
                pTSList2 = PTSL_Init(50, 2);
                PTSL_ReadLists(pTSList2,"rain",TIndex2++,&Timestep2,&NPtTS2, 1); /* rainfall in data-col 1 (file's col 4) */
        
        pTSList3 = PTSL_Init(50, 2);
        PTSL_ReadLists(pTSList3,"pET",TIndex3++,&Timestep3,&NPtTS3, 1); /* pET data in data-col 1 (file's col 4) */

        usrErr("done.\n");

        if (99 == 66) { /* never-get-here: temporary v2.6 PTSL - Below (old code frags extracted from v2.1) are left here as template for other data (or re-implementing the ELM v2.1 pET calculations if data available) */
        pTSList4 = PTSL_Init(50, 2);
        PTSL_ReadLists(pTSList4,"pET",TIndex4++,&Timestep4,&NPtTS4, 2);  /* dew point temperature data can be in data-col 2 */
        pTSList5 = PTSL_Init(50, 2);
        PTSL_ReadLists(pTSList5,"pET",TIndex5++,&Timestep5,&NPtTS5, 3);  /* wind speed data can be in data-col 3 */
        pTSList6 = PTSL_Init(50, 2);
        PTSL_ReadLists(pTSList6,"pET",TIndex6++,&Timestep6,&NPtTS6, 4);  /* cloud cover data can be in data-col 4 */
        }
}

Here is the call graph for this function:

void get_map_dims

(

void

)

Get the map dimensions of the global model array.

This mererly calls the "read_map_dims" function

Definition at line 2707 of file UnitMod.c.

References read_map_dims().

{
  read_map_dims("Elevation");
}

Here is the call graph for this function:

void alloc_memory

(

)

Allocate memory.

Allocate memory for model variables, and initialize (not context-specific) values.

Definition at line 2717 of file UnitMod.c.

References AIR_TEMP, ALG_INCID_LIGHT, ALG_LIGHT_CF, ALG_LIGHT_EXTINCT, ALG_REFUGE, ALG_SAT, ALG_TEMP_CF, ALG_TOT, ALG_WAT_CF, basn, Bathymetry, BCmodel_sfwat, BCondFlow, boundcond_depth, boundcond_ETp, boundcond_rain, BulkD, C_ALG, C_ALG_AVAIL_MORT, C_ALG_GPP, C_ALG_GPP_P, C_ALG_MORT, C_ALG_MORT_P, C_ALG_MORT_POT, C_ALG_NPP, C_ALG_NUT_CF, C_ALG_P, C_ALG_PC, C_ALG_PCrep, C_ALG_PROD_CF, C_ALG_RESP, C_ALG_RESP_POT, DEPOS_ORG_MAT, DIM, DINdummy, DOM_BD, DOM_DECOMP, DOM_DECOMP_POT, DOM_FR_FLOC, DOM_fr_nphBio, DOM_P_OM, DOM_QUALITY_CF, DOM_SED_AEROB_Z, DOM_SED_ANAEROB_Z, DOM_TEMP_CF, DOM_Z, DOP, DOP_DECOMP, DOP_FLOC, DOP_nphBio, ELEVATION, FIREdummy, FLOC, FLOC_DECOMP, FLOC_DECOMP_POT, FLOC_DECOMP_QUAL_CF, FLOC_DEPO, FLOC_DEPO_POT, FLOC_FR_ALGAE, Floc_fr_phBio, FLOC_Z, FlocP, FlocP_DECOMP, FlocP_DEPO, FlocP_FR_ALGAE, FlocP_OM, FlocP_OMrep, FlocP_PhBio, H2O_TEMP, HAB, HP_ALG_MAX, HP_DOM_AEROBTHIN, HP_DOM_MAXDEPTH, HP_FireInt, HP_FLOC_IC, HP_FLOC_IC_CTOOM, HP_FLOC_IC_PC, HP_HYD_POROSITY, HP_HYD_RCINFILT, HP_HYD_SPEC_YIELD, HP_MAC_CANOPDECOUP, HP_MAC_KSP, HP_MAC_LIGHTSAT, HP_MAC_MAXCANOPCOND, HP_MAC_MAXHT, HP_MAC_MAXLAI, HP_MAC_MAXROUGH, HP_MAC_MINROUGH, HP_MAC_SALIN_THRESH, HP_MAC_TEMPOPT, HP_MAC_TRANSLOC_RC, HP_MAC_WAT_TOLER, HP_NPHBIO_IC_CTOOM, HP_NPHBIO_IC_PC, HP_NPHBIO_MAX, HP_NPHBIO_ROOTDEPTH, HP_PHBIO_IC_CTOOM, HP_PHBIO_IC_PC, HP_PHBIO_MAX, HP_PHBIO_RCMORT, HP_PHBIO_RCNPP, HP_PhosHi, HP_PhosInt, HP_PhosLo, HP_SalinHi, HP_SalinInt, HP_SalinLo, HP_SALT_ICSEDWAT, HP_SALT_ICSFWAT, HP_SfDepthHi, HP_SfDepthInt, HP_SfDepthLo, HP_TP_CONC_GRAD, HYD_DOM_ACTWAT_PRES, HYD_DOM_ACTWAT_VOL, HYD_ET, HYD_EVAP_CALC, HYD_MANNINGS_N, HYD_RCCONDUCT, HYD_SAT_POT_TRANS, HYD_SED_WAT_VOL, HYD_TOT_POT_TRANSP, HYD_TRANSP, HYD_UNSAT_POT_TRANS, HYD_WATER_AVAIL, HydRelDepPosNeg, HydTotHd, init_pvar(), Inorg_Z, LAI_eff, MAC_HEIGHT, MAC_LAI, MAC_LIGHT_CF, MAC_MAX_BIO, MAC_NOPH_BIOMAS, mac_nph_CtoOM, mac_nph_OM, mac_nph_P, mac_nph_PC, mac_nph_PC_rep, MAC_NUT_CF, MAC_PH_BIOMAS, mac_ph_CtoOM, mac_ph_OM, mac_ph_P, mac_ph_PC, mac_ph_PC_rep, MAC_PROD_CF, MAC_REL_BIOM, MAC_SALT_CF, MAC_TEMP_CF, MAC_TOT_BIOM, MAC_WATER_AVAIL_CF, MAC_WATER_CF, nalloc(), NC_ALG, NC_ALG_AVAIL_MORT, NC_ALG_GPP, NC_ALG_GPP_P, NC_ALG_MORT, NC_ALG_MORT_P, NC_ALG_MORT_POT, NC_ALG_NPP, NC_ALG_NUT_CF, NC_ALG_P, NC_ALG_PC, NC_ALG_PCrep, NC_ALG_PROD_CF, NC_ALG_RESP, NC_ALG_RESP_POT, NPHBIO_AVAIL, NPHBIO_MORT, nphbio_mort_OM, nphbio_mort_P, NPHBIO_MORT_POT, NPHBIO_REFUGE, NPHBIO_SAT, nphbio_transl_OM, nphbio_transl_P, NPHBIO_TRANSLOC, NPHBIO_TRANSLOC_POT, ON_MAP, P_SUM_CELL, PHBIO_AVAIL, PHBIO_MORT, phbio_mort_OM, phbio_mort_P, PHBIO_MORT_POT, PHBIO_NPP, phbio_npp_OM, phbio_npp_P, PHBIO_REFUGE, PHBIO_SAT, phbio_transl_OM, phbio_transl_P, PHBIO_TRANSLOC, PHBIO_TRANSLOC_POT, s0, s1, SAL_SED_WT, SAL_SF_WT, SAL_SF_WT_mb, SALT_Atm_Depos, SALT_SED_TO_SF_FLOW, SALT_SED_WT, SALT_SFWAT_DOWNFL, SALT_SFWAT_DOWNFL_POT, SALT_SURF_WT, SAT_TO_UNSAT_FL, SAT_VS_UNSAT, SAT_WATER, SAT_WT_HEAD, SAT_WT_RECHG, SAT_WT_TRANSP, SED_ELEV, SED_INACT_Z, SF_WT_EVAP, SF_WT_FROM_RAIN, SF_WT_INFILTRATION, SF_WT_POT_INF, SF_WT_TO_SAT_DOWNFLOW, SF_WT_VEL_mag, SFWT_VOL, soil_MOIST_CF, SOLRAD274, SOLRADGRD, SURFACE_WAT, TP_Act_to_Tot, TP_Act_to_TotRep, TP_Atm_Depos, TP_AtmosDepos, TP_DNFLOW, TP_DNFLOW_POT, TP_K, TP_SED_CONC, TP_SED_MINER, TP_SED_WT, TP_SED_WT_AZ, TP_SEDWT_CONCACT, TP_SEDWT_CONCACTMG, TP_SEDWT_UPTAKE, TP_settl, TP_settlDays, TP_SF_WT, TP_SFWT_CONC, TP_SFWT_CONC_MG, TP_SFWT_MINER, TP_SFWT_UPTAK, TP_SORB, TP_SORB_POT, TP_SORBCONC, TP_SORBCONC_rep, TP_SORBTION, TP_UPFLOW, TP_UPFLOW_POT, TPtoSOIL, TPtoSOIL_rep, TPtoVOL, TPtoVOL_rep, UNSAT_AVAIL, UNSAT_CAP, UNSAT_DEPTH, UNSAT_HYD_COND_CF, UNSAT_MOIST_PRP, UNSAT_PERC, UNSAT_TO_SAT_FL, UNSAT_TRANSP, UNSAT_WATER, UNSAT_WT_POT, usrErr(), usrErr0(), and WQMsettlVel.

{
  usrErr0("Allocating Memory...");  /* console message */
  
  ON_MAP = (unsigned char *) nalloc(sizeof(unsigned char)*(s0+2)*(s1+2),"ON_MAP");
  init_pvar(ON_MAP,NULL,'c',0.0);

  BCondFlow = (int *) nalloc(sizeof(int)*(s0+2)*(s1+2),"BCondFlow");
  init_pvar(BCondFlow,NULL,'d',0.0);
  HAB = (unsigned char *) nalloc(sizeof(unsigned char)*(s0+2)*(s1+2),"HAB");
  init_pvar(HAB,NULL,'c',0.0);
  basn = (int *) nalloc(sizeof(int)*(s0+2)*(s1+2),"basn"); /* Basin/Indicator-Region map */
  init_pvar(basn,NULL,'d',0.0);

  ALG_INCID_LIGHT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ALG_INCID_LIGHT");
  init_pvar(ALG_INCID_LIGHT,NULL,'f',0.0);
  ALG_LIGHT_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ALG_LIGHT_CF");
  init_pvar(ALG_LIGHT_CF,NULL,'f',0.0);
  ALG_LIGHT_EXTINCT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ALG_LIGHT_EXTINCT");
  init_pvar(ALG_LIGHT_EXTINCT,NULL,'f',0.0);
  ALG_WAT_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ALG_WAT_CF");
  init_pvar(ALG_WAT_CF,NULL,'f',0.0);
  ALG_TEMP_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ALG_TEMP_CF");
  init_pvar(ALG_TEMP_CF,NULL,'f',0.0);
  ALG_REFUGE = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ALG_REFUGE");
  init_pvar(ALG_REFUGE,NULL,'f',0.0);
  ALG_SAT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ALG_SAT");
  init_pvar(ALG_SAT,NULL,'f',0.0);
  ALG_TOT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ALG_TOT");
  init_pvar(ALG_TOT,NULL,'f',0.0);

  NC_ALG_AVAIL_MORT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_AVAIL_MORT");
  init_pvar(NC_ALG_AVAIL_MORT,NULL,'f',0.0);
  NC_ALG_GPP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_GPP");
  init_pvar(NC_ALG_GPP,NULL,'f',0.0);
  NC_ALG_MORT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_MORT");
  init_pvar(NC_ALG_MORT,NULL,'f',0.0);
  NC_ALG_MORT_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_MORT_POT");
  init_pvar(NC_ALG_MORT_POT,NULL,'f',0.0);
  NC_ALG_NPP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_NPP");
  init_pvar(NC_ALG_NPP,NULL,'f',0.0);
  NC_ALG_NUT_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_NUT_CF");
  init_pvar(NC_ALG_NUT_CF,NULL,'f',0.0);
  NC_ALG_PROD_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_PROD_CF");
  init_pvar(NC_ALG_PROD_CF,NULL,'f',0.0);
  NC_ALG_RESP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_RESP");
  init_pvar(NC_ALG_RESP,NULL,'f',0.0);
  NC_ALG_RESP_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_RESP_POT");
  init_pvar(NC_ALG_RESP_POT,NULL,'f',0.0);
  NC_ALG = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG");
  init_pvar(NC_ALG,NULL,'f',0.0);
  C_ALG_AVAIL_MORT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_AVAIL_MORT");
  init_pvar(C_ALG_AVAIL_MORT,NULL,'f',0.0);
  C_ALG_GPP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_GPP");
  init_pvar(C_ALG_GPP,NULL,'f',0.0);
  C_ALG_MORT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_MORT");
  init_pvar(C_ALG_MORT,NULL,'f',0.0);
  C_ALG_MORT_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_MORT_POT");
  init_pvar(C_ALG_MORT_POT,NULL,'f',0.0);
  C_ALG_NPP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_NPP");
  init_pvar(C_ALG_NPP,NULL,'f',0.0);
  C_ALG_NUT_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_NUT_CF");
  init_pvar(C_ALG_NUT_CF,NULL,'f',0.0);
  C_ALG_PROD_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_PROD_CF");
  init_pvar(C_ALG_PROD_CF,NULL,'f',0.0);
  C_ALG_RESP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_RESP");
  init_pvar(C_ALG_RESP,NULL,'f',0.0);
  C_ALG_RESP_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_RESP_POT");
  init_pvar(C_ALG_RESP_POT,NULL,'f',0.0);
  C_ALG = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG");
  init_pvar(C_ALG,NULL,'f',0.0);
  NC_ALG_P = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_P");
  init_pvar(NC_ALG_P,NULL,'f',0.0);
  C_ALG_P = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_P");
  init_pvar(C_ALG_P,NULL,'f',0.0);
  NC_ALG_GPP_P = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_GPP_P");
  init_pvar(NC_ALG_GPP_P,NULL,'f',0.0);
  C_ALG_GPP_P = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_GPP_P");
  init_pvar(C_ALG_GPP_P,NULL,'f',0.0);
  NC_ALG_MORT_P = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_MORT_P");
  init_pvar(NC_ALG_MORT_P,NULL,'f',0.0);
  C_ALG_MORT_P = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_MORT_P");
  init_pvar(C_ALG_MORT_P,NULL,'f',0.0);
  NC_ALG_PCrep = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_ALG_PCrep");
  init_pvar(NC_ALG_PCrep,NULL,'f',0.0);
  C_ALG_PCrep = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_ALG_PCrep");
  init_pvar(C_ALG_PCrep,NULL,'f',0.0);
  NC_ALG_PC = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"NC_ALG_PC");
  init_pvar(NC_ALG_PC,NULL,'l',0.0);
  C_ALG_PC = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"C_ALG_PC");
  init_pvar(C_ALG_PC,NULL,'l',0.0);

  DEPOS_ORG_MAT = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"DEPOS_ORG_MAT");
  init_pvar(DEPOS_ORG_MAT,NULL,'l',0.0);
        
  DOM_Z = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_Z");
  init_pvar(DOM_Z,NULL,'f',0.0);
  DOM_DECOMP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_DECOMP");
  init_pvar(DOM_DECOMP,NULL,'f',0.0);
  DOM_DECOMP_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_DECOMP_POT");
  init_pvar(DOM_DECOMP_POT,NULL,'f',0.0);
  DOM_fr_nphBio = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_fr_nphBio");
  init_pvar(DOM_fr_nphBio,NULL,'f',0.0);
  
  Floc_fr_phBio = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Floc_fr_phBio");
  init_pvar(Floc_fr_phBio,NULL,'f',0.0);
  DOM_FR_FLOC = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_FR_FLOC");
  init_pvar(DOM_FR_FLOC,NULL,'f',0.0);
  soil_MOIST_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"soil_MOIST_CF");
  init_pvar(soil_MOIST_CF,NULL,'f',0.0);
  DOM_QUALITY_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_QUALITY_CF");
  init_pvar(DOM_QUALITY_CF,NULL,'f',0.0);
  DOM_SED_AEROB_Z = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_SED_AEROB_Z");
  init_pvar(DOM_SED_AEROB_Z,NULL,'f',0.0);
  DOM_SED_ANAEROB_Z = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_SED_ANAEROB_Z");
  init_pvar(DOM_SED_ANAEROB_Z,NULL,'f',0.0);
  DOM_TEMP_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_TEMP_CF");
  init_pvar(DOM_TEMP_CF,NULL,'f',0.0);
  ELEVATION = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ELEVATION");
  init_pvar(ELEVATION,NULL,'f',0.0);
  Bathymetry = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Bathymetry");
  init_pvar(Bathymetry,NULL,'f',0.0);
  SED_ELEV = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SED_ELEV");
  init_pvar(SED_ELEV,NULL,'f',0.0);
  SED_INACT_Z = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SED_INACT_Z");
  init_pvar(SED_INACT_Z,NULL,'f',0.0);
  DOP_FLOC = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOP_FLOC");
  init_pvar(DOP_FLOC,NULL,'f',0.0);
  DOP_nphBio = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOP_nphBio");
  init_pvar(DOP_nphBio,NULL,'f',0.0);

  DOM_P_OM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"DOM_P_OM");
  init_pvar(DOM_P_OM,NULL,'l',0.0);

  TPtoSOIL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPtoSOIL");
  init_pvar(TPtoSOIL,NULL,'f',0.0);
  TPtoSOIL_rep = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPtoSOIL_rep");
  init_pvar(TPtoSOIL_rep,NULL,'f',0.0);
  TPtoVOL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPtoVOL");
  init_pvar(TPtoVOL,NULL,'f',0.0);
  TPtoVOL_rep = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPtoVOL_rep");
  init_pvar(TPtoVOL_rep,NULL,'f',0.0);
  BulkD = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"BulkD");
  init_pvar(BulkD,NULL,'f',0.0);
  DOM_BD = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOM_BD");
  init_pvar(DOM_BD,NULL,'f',0.0);
  Inorg_Z = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Inorg_Z");
  init_pvar(Inorg_Z,NULL,'f',0.0);
  DIM = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DIM");
  init_pvar(DIM,NULL,'f',0.0);
  DOP_DECOMP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DOP_DECOMP");
  init_pvar(DOP_DECOMP,NULL,'f',0.0);

  DOP = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"DOP");
  init_pvar(DOP,NULL,'l',0.0);

/* placeholder for fire */
  FIREdummy = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FIREdummy");
  init_pvar(FIREdummy,NULL,'f',0.0);
        
  HYD_DOM_ACTWAT_PRES = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_DOM_ACTWAT_PRES");
  init_pvar(HYD_DOM_ACTWAT_PRES,NULL,'f',0.0);
  HYD_DOM_ACTWAT_VOL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_DOM_ACTWAT_VOL");
  init_pvar(HYD_DOM_ACTWAT_VOL,NULL,'f',0.0);
  HYD_EVAP_CALC = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_EVAP_CALC");
  init_pvar(HYD_EVAP_CALC,NULL,'f',0.0);
  HYD_MANNINGS_N = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_MANNINGS_N");
  init_pvar(HYD_MANNINGS_N,NULL,'f',0.0);
  HYD_RCCONDUCT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_RCCONDUCT");
  init_pvar(HYD_RCCONDUCT,NULL,'f',0.0);
  HYD_SAT_POT_TRANS = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_SAT_POT_TRANS");
  init_pvar(HYD_SAT_POT_TRANS,NULL,'f',0.0);
  HYD_SED_WAT_VOL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_SED_WAT_VOL");
  init_pvar(HYD_SED_WAT_VOL,NULL,'f',0.0);
  HYD_TOT_POT_TRANSP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_TOT_POT_TRANSP");
  init_pvar(HYD_TOT_POT_TRANSP,NULL,'f',0.0);
  HydTotHd = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HydTotHd");
  init_pvar(HydTotHd,NULL,'f',0.0);
  HydRelDepPosNeg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HydRelDepPosNeg");
  init_pvar(HydRelDepPosNeg,NULL,'f',0.0);
  HYD_TRANSP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_TRANSP");
  init_pvar(HYD_TRANSP,NULL,'f',0.0);
  HYD_ET = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_ET");
  init_pvar(HYD_ET,NULL,'f',0.0);
  HYD_UNSAT_POT_TRANS = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_UNSAT_POT_TRANS");
  init_pvar(HYD_UNSAT_POT_TRANS,NULL,'f',0.0);
  HYD_WATER_AVAIL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HYD_WATER_AVAIL");
  init_pvar(HYD_WATER_AVAIL,NULL,'f',0.0);

/* sfwmm rainfall, stage, and pET mapped to elm grid */
  boundcond_rain = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"boundcond_rain");
  init_pvar(boundcond_rain,NULL,'f',0.0);
  boundcond_depth = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"boundcond_depth");
  init_pvar(boundcond_depth,NULL,'f',0.0);
  boundcond_ETp = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"boundcond_ETp");
  init_pvar(boundcond_ETp,NULL,'f',0.0);

  SAT_TO_UNSAT_FL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SAT_TO_UNSAT_FL");
  init_pvar(SAT_TO_UNSAT_FL,NULL,'f',0.0);
  SAT_VS_UNSAT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SAT_VS_UNSAT");
  init_pvar(SAT_VS_UNSAT,NULL,'f',0.0);
  SAT_WATER = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SAT_WATER");
  init_pvar(SAT_WATER,NULL,'f',0.0);
  SAT_WT_HEAD = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SAT_WT_HEAD");
  init_pvar(SAT_WT_HEAD,NULL,'f',0.0);
  SAT_WT_RECHG = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SAT_WT_RECHG");
  init_pvar(SAT_WT_RECHG,NULL,'f',0.0);
  SAT_WT_TRANSP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SAT_WT_TRANSP");
  init_pvar(SAT_WT_TRANSP,NULL,'f',0.0);
  SF_WT_EVAP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SF_WT_EVAP");
  init_pvar(SF_WT_EVAP,NULL,'f',0.0);
  SF_WT_FROM_RAIN = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SF_WT_FROM_RAIN");
  init_pvar(SF_WT_FROM_RAIN,NULL,'f',0.0);
  SF_WT_INFILTRATION = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SF_WT_INFILTRATION");
  init_pvar(SF_WT_INFILTRATION,NULL,'f',0.0);
  SF_WT_POT_INF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SF_WT_POT_INF");
  init_pvar(SF_WT_POT_INF,NULL,'f',0.0);
  SF_WT_TO_SAT_DOWNFLOW = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SF_WT_TO_SAT_DOWNFLOW");
  init_pvar(SF_WT_TO_SAT_DOWNFLOW,NULL,'f',0.0);
  SFWT_VOL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SFWT_VOL");
  init_pvar(SFWT_VOL,NULL,'f',0.0);
  SURFACE_WAT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SURFACE_WAT");
  init_pvar(SURFACE_WAT,NULL,'f',0.0);
  SF_WT_VEL_mag = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SF_WT_VEL_mag");
  init_pvar(SF_WT_VEL_mag,NULL,'f',0.0); 
  BCmodel_sfwat = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"BCmodel_sfwat");
  init_pvar(BCmodel_sfwat,NULL,'f',0.0); 

  UNSAT_AVAIL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_AVAIL");
  init_pvar(UNSAT_AVAIL,NULL,'f',0.0);
  UNSAT_CAP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_CAP");
  init_pvar(UNSAT_CAP,NULL,'f',0.0);
  UNSAT_DEPTH = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_DEPTH");
  init_pvar(UNSAT_DEPTH,NULL,'f',0.0);
  UNSAT_HYD_COND_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_HYD_COND_CF");
  init_pvar(UNSAT_HYD_COND_CF,NULL,'f',0.0);
  UNSAT_MOIST_PRP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_MOIST_PRP");
  init_pvar(UNSAT_MOIST_PRP,NULL,'f',0.0);
  UNSAT_PERC = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_PERC");
  init_pvar(UNSAT_PERC,NULL,'f',0.0);
  UNSAT_TO_SAT_FL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_TO_SAT_FL");
  init_pvar(UNSAT_TO_SAT_FL,NULL,'f',0.0);
  UNSAT_TRANSP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_TRANSP");
  init_pvar(UNSAT_TRANSP,NULL,'f',0.0);
  UNSAT_WATER = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_WATER");
  init_pvar(UNSAT_WATER,NULL,'f',0.0);
  UNSAT_WT_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UNSAT_WT_POT");
  init_pvar(UNSAT_WT_POT,NULL,'f',0.0);

  MAC_HEIGHT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_HEIGHT");
  init_pvar(MAC_HEIGHT,NULL,'f',0.0);
  MAC_LAI = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_LAI");
  init_pvar(MAC_LAI,NULL,'f',0.0);
  LAI_eff = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"LAI_eff");
  init_pvar(LAI_eff,NULL,'f',0.0);
  MAC_LIGHT_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_LIGHT_CF");
  init_pvar(MAC_LIGHT_CF,NULL,'f',0.0);
  MAC_MAX_BIO = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_MAX_BIO");
  init_pvar(MAC_MAX_BIO,NULL,'f',0.0);
  MAC_NOPH_BIOMAS = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_NOPH_BIOMAS");
  init_pvar(MAC_NOPH_BIOMAS,NULL,'f',0.0);
  MAC_NUT_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_NUT_CF");
  init_pvar(MAC_NUT_CF,NULL,'f',0.0);
  MAC_PH_BIOMAS = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_PH_BIOMAS");
  init_pvar(MAC_PH_BIOMAS,NULL,'f',0.0);
  MAC_PROD_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_PROD_CF");
  init_pvar(MAC_PROD_CF,NULL,'f',0.0);
  MAC_REL_BIOM = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_REL_BIOM");
  init_pvar(MAC_REL_BIOM,NULL,'f',0.0);
  MAC_SALT_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_SALT_CF");
  init_pvar(MAC_SALT_CF,NULL,'f',0.0);
  MAC_TEMP_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_TEMP_CF");
  init_pvar(MAC_TEMP_CF,NULL,'f',0.0);
  MAC_TOT_BIOM = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_TOT_BIOM");
  init_pvar(MAC_TOT_BIOM,NULL,'f',0.0);
  MAC_WATER_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_WATER_CF");
  init_pvar(MAC_WATER_CF,NULL,'f',0.0);
  MAC_WATER_AVAIL_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MAC_WATER_AVAIL_CF");
  init_pvar(MAC_WATER_AVAIL_CF,NULL,'f',0.0);
  NPHBIO_AVAIL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NPHBIO_AVAIL");
  init_pvar(NPHBIO_AVAIL,NULL,'f',0.0);
  NPHBIO_MORT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NPHBIO_MORT");
  init_pvar(NPHBIO_MORT,NULL,'f',0.0);
  NPHBIO_MORT_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NPHBIO_MORT_POT");
  init_pvar(NPHBIO_MORT_POT,NULL,'f',0.0);
  NPHBIO_REFUGE = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NPHBIO_REFUGE");
  init_pvar(NPHBIO_REFUGE,NULL,'f',0.0);
  NPHBIO_SAT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NPHBIO_SAT");
  init_pvar(NPHBIO_SAT,NULL,'f',0.0);
  NPHBIO_TRANSLOC = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NPHBIO_TRANSLOC");
  init_pvar(NPHBIO_TRANSLOC,NULL,'f',0.0);
  NPHBIO_TRANSLOC_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NPHBIO_TRANSLOC_POT");
  init_pvar(NPHBIO_TRANSLOC_POT,NULL,'f',0.0);
  PHBIO_AVAIL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PHBIO_AVAIL");
  init_pvar(PHBIO_AVAIL,NULL,'f',0.0);
  PHBIO_MORT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PHBIO_MORT");
  init_pvar(PHBIO_MORT,NULL,'f',0.0);
  PHBIO_MORT_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PHBIO_MORT_POT");
  init_pvar(PHBIO_MORT_POT,NULL,'f',0.0);
  PHBIO_NPP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PHBIO_NPP");
  init_pvar(PHBIO_NPP,NULL,'f',0.0);
  PHBIO_REFUGE = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PHBIO_REFUGE");
  init_pvar(PHBIO_REFUGE,NULL,'f',0.0);
  PHBIO_SAT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PHBIO_SAT");
  init_pvar(PHBIO_SAT,NULL,'f',0.0); 
  PHBIO_TRANSLOC = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PHBIO_TRANSLOC");
  init_pvar(PHBIO_TRANSLOC,NULL,'f',0.0);
  PHBIO_TRANSLOC_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PHBIO_TRANSLOC_POT");
  init_pvar(PHBIO_TRANSLOC_POT,NULL,'f',0.0);

  phbio_npp_P = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"phbio_npp_P");
  init_pvar(phbio_npp_P,NULL,'l',0.0);
  phbio_npp_OM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"phbio_npp_OM");
  init_pvar(phbio_npp_OM,NULL,'l',0.0);
  phbio_mort_P = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"phbio_mort_P");
  init_pvar(phbio_mort_P,NULL,'l',0.0);
  phbio_mort_OM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"phbio_mort_OM");
  init_pvar(phbio_mort_OM,NULL,'l',0.0);
  phbio_transl_P = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"phbio_transl_P");
  init_pvar(phbio_transl_P,NULL,'l',0.0);
  phbio_transl_OM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"phbio_transl_OM");
  init_pvar(phbio_transl_OM,NULL,'l',0.0);
  nphbio_transl_P = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"nphbio_transl_P");
  init_pvar(nphbio_transl_P,NULL,'l',0.0);
  nphbio_transl_OM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"nphbio_transl_OM");
  init_pvar(nphbio_transl_OM,NULL,'l',0.0);
  nphbio_mort_P = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"nphbio_mort_P");
  init_pvar(nphbio_mort_P,NULL,'l',0.0);
  nphbio_mort_OM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"nphbio_mort_OM");
  init_pvar(nphbio_mort_OM,NULL,'l',0.0);
  mac_nph_P = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"mac_nph_P");
  init_pvar(mac_nph_P,NULL,'l',0.0);
  mac_nph_PC = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"mac_nph_PC");
  init_pvar(mac_nph_PC,NULL,'l',0.0);
  mac_nph_OM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"mac_nph_OM");
  init_pvar(mac_nph_OM,NULL,'l',0.0);
  mac_nph_CtoOM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"mac_nph_CtoOM");
  init_pvar(mac_nph_CtoOM,NULL,'l',0.0);
  mac_ph_P = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"mac_ph_P");
  init_pvar(mac_ph_P,NULL,'l',0.0);
  mac_ph_PC = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"mac_ph_PC");
  init_pvar(mac_ph_PC,NULL,'l',0.0);
  mac_ph_OM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"mac_ph_OM");
  init_pvar(mac_ph_OM,NULL,'l',0.0);
  mac_ph_CtoOM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"mac_ph_CtoOM");
  init_pvar(mac_ph_CtoOM,NULL,'l',0.0);

  mac_nph_PC_rep = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"mac_nph_PC_rep");
  init_pvar(mac_nph_PC_rep,NULL,'f',0.0);
  mac_ph_PC_rep = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"mac_ph_PC_rep");
  init_pvar(mac_ph_PC_rep,NULL,'f',0.0);

  TP_SED_WT = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"TP_SED_WT");
  init_pvar(TP_SED_WT,NULL,'l',0.0);
  TP_SED_CONC = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"TP_SED_CONC");
  init_pvar(TP_SED_CONC,NULL,'l',0.0);
  TP_SEDWT_CONCACT = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"TP_SEDWT_CONCACT");
  init_pvar(TP_SEDWT_CONCACT,NULL,'l',0.0);
  TP_SF_WT = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"TP_SF_WT");
  init_pvar(TP_SF_WT,NULL,'l',0.0);
  TP_SFWT_CONC = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"TP_SFWT_CONC");
  init_pvar(TP_SFWT_CONC,NULL,'l',0.0);
  TP_SORB = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"TP_SORB");
  init_pvar(TP_SORB,NULL,'l',0.0);
  TP_SORBCONC = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"TP_SORBCONC");
  init_pvar(TP_SORBCONC,NULL,'l',0.0);
  TP_SED_WT_AZ = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"TP_SED_WT_AZ");
  init_pvar(TP_SED_WT_AZ,NULL,'l',0.0);
  TP_Act_to_Tot = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"TP_Act_to_Tot");
  init_pvar(TP_Act_to_Tot,NULL,'l',0.0);

  TP_Act_to_TotRep = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_Act_to_TotRep");
  init_pvar(TP_Act_to_TotRep,NULL,'f',0.0);
  TP_SORBCONC_rep = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_SORBCONC_rep");
  init_pvar(TP_SORBCONC_rep,NULL,'f',0.0);

  TP_DNFLOW = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_DNFLOW");
  init_pvar(TP_DNFLOW,NULL,'f',0.0);
  TP_DNFLOW_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_DNFLOW_POT");
  init_pvar(TP_DNFLOW_POT,NULL,'f',0.0);
  TP_Atm_Depos = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_Atm_Depos");
  init_pvar(TP_Atm_Depos,NULL,'f',0.0);
/* v2.6 added map of atmospheric TP deposition rate */
  TP_AtmosDepos = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_AtmosDepos");
  init_pvar(TP_AtmosDepos,NULL,'f',0.0);
  TP_K = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_K");
  init_pvar(TP_K,NULL,'f',0.0);
  TP_SED_MINER = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_SED_MINER");
  init_pvar(TP_SED_MINER,NULL,'f',0.0);
  TP_SEDWT_CONCACTMG = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_SEDWT_CONCACTMG");
  init_pvar(TP_SEDWT_CONCACTMG,NULL,'f',0.0);
  TP_SEDWT_UPTAKE = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_SEDWT_UPTAKE");
  init_pvar(TP_SEDWT_UPTAKE,NULL,'f',0.0);
  TP_SFWT_CONC_MG = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_SFWT_CONC_MG");
  init_pvar(TP_SFWT_CONC_MG,NULL,'f',0.0);
  TP_SFWT_MINER = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_SFWT_MINER");
  init_pvar(TP_SFWT_MINER,NULL,'f',0.0);
  TP_SFWT_UPTAK = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_SFWT_UPTAK");
  init_pvar(TP_SFWT_UPTAK,NULL,'f',0.0);
  TP_settl = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_settl");
  init_pvar(TP_settl,NULL,'f',0.0);
  TP_SORB_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_SORB_POT");
  init_pvar(TP_SORB_POT,NULL,'f',0.0);
  TP_SORBTION = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_SORBTION");
  init_pvar(TP_SORBTION,NULL,'f',0.0);
  TP_UPFLOW = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_UPFLOW");
  init_pvar(TP_UPFLOW,NULL,'f',0.0);
  TP_UPFLOW_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_UPFLOW_POT");
  init_pvar(TP_UPFLOW_POT,NULL,'f',0.0);
  P_SUM_CELL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"P_SUM_CELL");
  init_pvar(P_SUM_CELL,NULL,'f',0.0);

  DINdummy = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"DINdummy");
  init_pvar(DINdummy,NULL,'l',0.0);

  WQMsettlVel = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"WQMsettlVel");
  init_pvar(WQMsettlVel,NULL,'f',0.0);
  TP_settlDays = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_settlDays");
  init_pvar(TP_settlDays,NULL,'f',0.0);

  SAL_SED_WT = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"SAL_SED_WT");
  init_pvar(SAL_SED_WT,NULL,'l',0.0);
  SAL_SF_WT_mb = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"SAL_SF_WT_mb");
  init_pvar(SAL_SF_WT_mb,NULL,'l',0.0);
  SALT_SED_WT = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"SALT_SED_WT");
  init_pvar(SALT_SED_WT,NULL,'l',0.0);
  SALT_SURF_WT = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"SALT_SURF_WT");
  init_pvar(SALT_SURF_WT,NULL,'l',0.0);
        
  SAL_SF_WT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SAL_SF_WT");
  init_pvar(SAL_SF_WT,NULL,'f',0.0);
  SALT_Atm_Depos = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SALT_Atm_Depos");
  init_pvar(SALT_Atm_Depos,NULL,'f',0.0);
  SALT_SED_TO_SF_FLOW = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SALT_SED_TO_SF_FLOW");
  init_pvar(SALT_SED_TO_SF_FLOW,NULL,'f',0.0);
  SALT_SFWAT_DOWNFL = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SALT_SFWAT_DOWNFL");
  init_pvar(SALT_SFWAT_DOWNFL,NULL,'f',0.0);
  SALT_SFWAT_DOWNFL_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SALT_SFWAT_DOWNFL_POT");
  init_pvar(SALT_SFWAT_DOWNFL_POT,NULL,'f',0.0);

  FLOC_DECOMP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FLOC_DECOMP");
  init_pvar(FLOC_DECOMP,NULL,'f',0.0);
  FLOC_DECOMP_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FLOC_DECOMP_POT");
  init_pvar(FLOC_DECOMP_POT,NULL,'f',0.0);
  FLOC_DECOMP_QUAL_CF = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FLOC_DECOMP_QUAL_CF");
  init_pvar(FLOC_DECOMP_QUAL_CF,NULL,'f',0.0);
  FLOC_Z = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FLOC_Z");
  init_pvar(FLOC_Z,NULL,'f',0.0);
  FLOC_DEPO = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FLOC_DEPO");
  init_pvar(FLOC_DEPO,NULL,'f',0.0);
  FLOC_DEPO_POT = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FLOC_DEPO_POT");
  init_pvar(FLOC_DEPO_POT,NULL,'f',0.0);
  FLOC_FR_ALGAE = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FLOC_FR_ALGAE");
  init_pvar(FLOC_FR_ALGAE,NULL,'f',0.0);
  FLOC = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FLOC");
  init_pvar(FLOC,NULL,'f',0.0);
  FlocP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FlocP");
  init_pvar(FlocP,NULL,'f',0.0);
  FlocP_DECOMP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FlocP_DECOMP");
  init_pvar(FlocP_DECOMP,NULL,'f',0.0);
  FlocP_FR_ALGAE = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FlocP_FR_ALGAE");
  init_pvar(FlocP_FR_ALGAE,NULL,'f',0.0);
  FlocP_PhBio = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FlocP_PhBio");
  init_pvar(FlocP_PhBio,NULL,'f',0.0);
  FlocP_DEPO = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FlocP_DEPO");
  init_pvar(FlocP_DEPO,NULL,'f',0.0);
  FlocP_OMrep = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"FlocP_OMrep");
  init_pvar(FlocP_OMrep,NULL,'f',0.0);
  FlocP_OM = (double *) nalloc(sizeof(double)*(s0+2)*(s1+2),"FlocP_OM");
  init_pvar(FlocP_OM,NULL,'l',0.0);

  SOLRADGRD = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SOLRADGRD");
  init_pvar(SOLRADGRD,NULL,'f',0.0);
  SOLRAD274 = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SOLRAD274");
  init_pvar(SOLRAD274,NULL,'f',0.0);
  AIR_TEMP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"AIR_TEMP");
  init_pvar(AIR_TEMP,NULL,'f',0.0);
  H2O_TEMP = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"H2O_TEMP");
  init_pvar(H2O_TEMP,NULL,'f',0.0);

/* habitat-specific parameter arrays */
  HP_ALG_MAX = NULL;

  HP_DOM_MAXDEPTH = NULL;
  HP_DOM_AEROBTHIN = NULL;

  HP_TP_CONC_GRAD = NULL;

  HP_SALT_ICSEDWAT = NULL;
  HP_SALT_ICSFWAT = NULL;

  HP_PHBIO_MAX = NULL;
  HP_NPHBIO_MAX = NULL;
  HP_MAC_MAXHT = NULL;
  HP_NPHBIO_ROOTDEPTH = NULL;
  HP_MAC_MAXROUGH = NULL;
  HP_MAC_MINROUGH = NULL;
  HP_MAC_MAXLAI = NULL;
  HP_MAC_MAXCANOPCOND = NULL;
  HP_MAC_CANOPDECOUP = NULL;
  HP_MAC_TEMPOPT = NULL;
  HP_MAC_LIGHTSAT = NULL;
  HP_MAC_KSP = NULL;
  HP_PHBIO_RCNPP = NULL;
  HP_PHBIO_RCMORT = NULL;
  HP_MAC_WAT_TOLER = NULL;
  HP_MAC_SALIN_THRESH = NULL;
  HP_PHBIO_IC_CTOOM = NULL;
  HP_NPHBIO_IC_CTOOM = NULL;
  HP_PHBIO_IC_PC = NULL;
  HP_NPHBIO_IC_PC = NULL;
  HP_MAC_TRANSLOC_RC = NULL;

  HP_HYD_RCINFILT = NULL;
  HP_HYD_SPEC_YIELD = NULL;
  HP_HYD_POROSITY = NULL;

  HP_FLOC_IC = NULL;
  HP_FLOC_IC_CTOOM = NULL;
  HP_FLOC_IC_PC = NULL;

  HP_SfDepthLo = NULL;
  HP_SfDepthHi = NULL;
  HP_SfDepthInt = NULL;
  HP_PhosLo = NULL;
  HP_PhosHi = NULL;
  HP_PhosInt = NULL;
  HP_FireInt = NULL;
  HP_SalinLo = NULL;
  HP_SalinHi = NULL;
  HP_SalinInt = NULL;
  
  usrErr("Done."); /* console message */

}

Here is the call graph for this function:

float graph7	(	unsigned char	y,
		float	x
	)

Time series interplator, data set 7.

The graphX functions are generic time-series interpolator; graph7 is interpolator for data set g7 (determining unsaturated infiltration control function).

Parameters:

	y	NA (=0)
	x	independent variable data value (soil moisture proportion)

Returns:

float dependent variable value (proportion of max infiltration rate)

Variables local to function

s local slope of independent/dependent variable values
ig array index of the data pairs
Np number of data pairs (incl. 0)

Definition at line 3265 of file UnitMod.c.

References g7.

Referenced by cell_dyn7().

{
  float s;
  int ig=0, Np=10;
  while(1) {
  if (x <= g7[ig][0]) { if(ig>0) ig=ig-1; else return(g7[0][1+y]);}
  else if (x > g7[ig][0] && x <= g7[ig+1][0]) {
         s =   (g7[ig+1][1+y]-g7[ig][1+y])/
            (g7[ig+1][0]-g7[ig][0]);
         return(s * (x-g7[ig][0]) + g7[ig][1+y]); }
    else if (x > g7[ig+1][0]) { if(ig<Np) ig=ig+1; else return(g7[Np][1+y]);}
  }
}

float graph8	(	unsigned char	y,
		float	x
	)

Time series interplator, data set 8.

The graphX functions are generic time-series interpolator; graph8 is interpolator for data set g8 (determining water availability to plants).

Parameters:

	y	NA (=0)
	x	independent variable data value (proportion of water available in upper soil zone)

Returns:

float dependent variable value (proportion of max water availability to plants)

Varialbes local to function

s local slope of independent/dependent variable values
ig array index of the data pairs
Np number of data pairs (incl. 0)

Definition at line 3292 of file UnitMod.c.

References g8.

Referenced by cell_dyn7(), and init_eqns().

{
  float s;
  int ig=0, Np=10;
  while(1) {
  if (x <= g8[ig][0]) { if(ig>0) ig=ig-1; else return(g8[0][1+y]);}
  else if (x > g8[ig][0] && x <= g8[ig+1][0]) {
         s =   (g8[ig+1][1+y]-g8[ig][1+y])/
            (g8[ig+1][0]-g8[ig][0]);
         return(s * (x-g8[ig][0]) + g8[ig][1+y]); }
    else if (x > g8[ig+1][0]) { if(ig<Np) ig=ig+1; else return(g8[Np][1+y]);}
  }
}

void HabSwitch_Init

(

void

)

Transfers habitat-specific parameters into data struct, allocate memory.

Definition at line 25 of file Success.c.

Referenced by init_succession().

{
  int ii;
  
        /* put these habitat-specific parameters into a concise data struct for use here */
  for( ii = 0; ii < habNumTot; ii++) {
        Habi[ii].Water.Llo = HP_SfDepthLo[ii+1];
        Habi[ii].Water.Lhi = HP_SfDepthHi[ii+1];
        Habi[ii].Water.Pin = HP_SfDepthInt[ii+1];
        Habi[ii].Nutrient.Llo = HP_PhosLo[ii+1];
        Habi[ii].Nutrient.Lhi = HP_PhosHi[ii+1];
        Habi[ii].Nutrient.Pin = HP_PhosInt[ii+1];
        Habi[ii].PFin = HP_FireInt[ii+1];
        Habi[ii].Salinity.Llo = HP_SalinLo[ii+1];
        Habi[ii].Salinity.Lhi = HP_SalinHi[ii+1];
        Habi[ii].Salinity.Pin = HP_SalinInt[ii+1];
  }
   
   alloc_hab_hist( );
   sprintf (msgStr, "Succession ON, module OK for %d habitats...", ii ); usrErr(msgStr); WriteMsg(msgStr,1);

   return; 
}

unsigned char HabSwitch	(	int	ix,
		int	iy,
		float *	Water,
		float *	Nutrient,
		int *	Fire,
		float *	Salinity,
		unsigned char *	HAB
	)

Switches habitats (the option that is currently used).

Returns the number of habitat to switch to based on the length of the weekly (or other) averaged period of favorable conditions. In this case the period of habitat favorable conditions is calculated as the number of weeks (or other time intervals) during which the habitat conditions matched the specified for a period longer than the given one - SW_TIME_TH. The switching occurs as soon as the number of such successfull weeks exceeds the time specified in Pin

Parameters:

	ix	Model domain row
	iy	Model domain column
	Water	Current water depth data array
	Nutrient	Current nutrient conc. data array
	Fire	Fire data array (unused, no fire implemented)
	Salinity	Current salinity conc. data array
	HAB	Habitat-type data array

Returns:

habitat type of cell

Definition at line 66 of file Success.c.

Referenced by cell_dyn1().

{
 int StateW, StateN, StateS, i;
 int HabW[MAX_NHAB], HabN[MAX_NHAB], HabS[MAX_NHAB], DW, DN, DS;
 int cell =  T(ix,iy);
 int hab = HAB[cell];   /* current habitat in the cell */

 /* define the habitat type that matches the existing water conditions */
 
 /* HabHist is an array of integers : ssSnnNwwW, where 
    ww are the two digits for the number of weeks in the water level favorable conditions,
    W the number of days in those conditions during the current week;
    nn are the two digits for the number of weeks being in the nutrient favorable conditions, 
    N the number of days in those conditions during the current week; 
    ss are the two digits for the number of weeks in the salinity favorable conditions,
    S the number of days in those conditions during the current week;
    
    The switching occurs when all of these histories exceed the habitat specific 
        periods Pin.
 */
 for ( i = 0; i < habNumTot; i++ )
        {
         DW = HabHist[cell*habNumTot +i]%10;
         HabW[i] = (HabHist[cell*habNumTot +i]/10)%100;
         DN = (HabHist[cell*habNumTot +i]/1000)%10;
         HabN[i] = HabHist[cell*habNumTot +i]/10000;
         DS = (HabHist[cell*habNumTot +i]/1000000)%10;
         HabS[i] = HabHist[cell*habNumTot +i]/10000000;
         
         /* when the averaging time elapses, if #favorable days exceeds a threshold (using 4 for 7 day AV_PER), increment the period (weeks) history */
         if ((int)SimTime.TIME%AV_PER == 0)
           { 
                if (DW > SW_TIME_TH_W) HabHist[cell*habNumTot +i] = HabHist[cell*habNumTot +i] - DW + 100;
                else HabHist[cell*habNumTot +i] = 0;
                if (DN > SW_TIME_TH_N) HabHist[cell*habNumTot +i] = HabHist[cell*habNumTot +i] - DN*1000 + 10000;
                else HabHist[cell*habNumTot +i] = 0;
                if (DS > SW_TIME_TH_S) HabHist[cell*habNumTot +i] = HabHist[cell*habNumTot +i] - DS*1000000 + 10000000;
                else HabHist[cell*habNumTot +i] = 0;
           }    

        /* check what habitat type the existing conditions match; increment the day# if conditions are favorable */
         if ( InHab (Water[cell], Habi[i].Water) )                    HabHist[cell*habNumTot + i] = HabHist[cell*habNumTot + i] + 1;
         if ( InHab (Nutrient[cell]*conv_kgTOmg, Habi[i].Nutrient) )  HabHist[cell*habNumTot + i] = HabHist[cell*habNumTot + i] + 1000;
         if ( InHab (Salinity[cell], Habi[i].Salinity) )              HabHist[cell*habNumTot + i] = HabHist[cell*habNumTot + i] + 1000000;
        } 
   
         /* check if the historical conditions for switching hold */
 for ( i = 0; i < habNumTot; i++ )  
        if ( HabW[i] >= Habi[i].Water.Pin && HabN[i] >= Habi[i].Nutrient.Pin && HabS[i] >= Habi[i].Salinity.Pin ) 
                { HabHist[cell*habNumTot +i] = 0;
                  return (i+1); /* returns new hab, HAB[] is offset by 1 from these array IDs */
                }
                
 return hab;    
}

void Run_Canal_Network	(	float *	SWH,
		float *	Elevation,
		float *	MC,
		float *	GW,
		float *	poros,
		float *	GWcond,
		double *	NA,
		double *	PA,
		double *	SA,
		double *	GNA,
		double *	GPA,
		double *	GSA,
		float *	Unsat,
		float *	sp_yield
	)

Runs the water management network.

Invoke the calls to water control structure flows and the canal-cell interactions.

Parameters:

	SWH	SURFACE_WAT
	Elevation	SED_ELEV
	MC	HYD_MANNINGS_N
	GW	SAT_WATER
	poros	HP_HYD_POROSITY
	GWcond	HYD_RCCONDUCT
	NA	DINdummy
	PA	TP_SF_WT
	SA	SALT_SURF_WT
	GNA	DINdummy
	GPA	TP_SED_WT
	GSA	SALT_SED_WT
	Unsat	UNSAT_WATER
	sp_yield	HP_HYD_SPEC_YIELD

Definition at line 330 of file WatMgmt.c.

References Chan::area, Chan::basin, CanalOutFile, CanalOutFile_P, CanalOutFile_S, canDebugFile, canPrint, canstep, Chan_list, simTime::da, debug, Flows_in_Structures(), FluxChannel(), FMOD(), hyd_iter, simTime::IsBudgEnd, simTime::IsSimulationEnd, simTime::mo, N_c_iter, num_chan, P, Chan::P_con, printchan, Chan::S_con, SensiOn, SimTime, Chan::sumHistIn, Chan::sumHistOut, Chan::sumRuleIn, Chan::sumRuleOut, TOT_P_CAN, TOT_S_CAN, TOT_VOL_CAN, Chan::wat_depth, WstructOutFile, WstructOutFile_P, WstructOutFile_S, and simTime::yr.

{ int i;
 float CH_vol;

 if ( canPrint && (( N_c_iter++ % hyd_iter ) == 0.0) ) {
        if (SensiOn) { 
            printchan = (SimTime.IsSimulationEnd) ? (1) : (0); /* flag to indicate to print canal/struct data */
         }
         else printchan = 1;
 }
 else  printchan = 0;

 if (printchan == 1) {
     
     fprintf( WstructOutFile, "\n%d/%d/%d\t",SimTime.yr[0],SimTime.mo[0],SimTime.da[0] );
     fprintf( WstructOutFile_P, "\n%d/%d/%d\t",SimTime.yr[0],SimTime.mo[0],SimTime.da[0] );
/*      fprintf( WstructOutFile_N, "\n%d/%d/%d\t",SimTime.yr[0],SimTime.mo[0],SimTime.da[0] ); */
     fprintf( WstructOutFile_S, "\n%d/%d/%d\t",SimTime.yr[0],SimTime.mo[0],SimTime.da[0] );

     fprintf (CanalOutFile, "\n%d/%d/%d\t",SimTime.yr[0],SimTime.mo[0],SimTime.da[0] );
     fprintf (CanalOutFile_P, "\n%d/%d/%d\t",SimTime.yr[0],SimTime.mo[0],SimTime.da[0] );
/*      fprintf (CanalOutFile_N, "\n%d/%d/%d\t",SimTime.yr[0],SimTime.mo[0],SimTime.da[0] ); */
     fprintf (CanalOutFile_S, "\n%d/%d/%d\t",SimTime.yr[0],SimTime.mo[0],SimTime.da[0] );
 }
    
  
 for ( i = 0; i < num_chan; i++ )
 {   /* set the sum of historical (or other-model) and Rule-based flows to/from a canal per iteration to 0 */   
     Chan_list[i]->sumHistIn = Chan_list[i]->sumHistOut = 0.0;
     Chan_list[i]->sumRuleIn = Chan_list[i]->sumRuleOut = 0.0;
 }

/* calculate flows through water control structures */
 Flows_in_Structures ( SWH, GW, poros, Elevation, NA, PA, SA ); 
  
/* output  header for canal-cell flux output canal debug file, at relatively high debug levels (writes a LOT of stuff) */
 if( debug > 3 ) 
 {
     fprintf( canDebugFile, "N%3d  WatDepth     Pconc     Sconc        flux_S        flux_G        flux_L           Qin          Qout #_iter      Area    error \n", N_c_iter );
      
 }

/* Flux the water along a canal using the relaxation procedure */
  
 for( i = 0; i < num_chan; i++ )
     if (Chan_list[i]->width > 0) /* a neg width canal is skipped */

     { 
         FluxChannel ( i, SWH, Elevation, MC, GW, poros, GWcond, NA, PA, SA, GNA, GPA, GSA, Unsat, sp_yield );
             /* calculate total canal volume after canal fluxes */
         CH_vol = Chan_list[i]->area*Chan_list[i]->wat_depth; 

             /* sum the storages on iteration that performs budget checks */
         if ( !( FMOD(N_c_iter,(1/canstep) )) && (SimTime.IsBudgEnd ) ) { 
             TOT_VOL_CAN[Chan_list[i]->basin] += CH_vol;
             TOT_VOL_CAN[0] += CH_vol;
             TOT_P_CAN[Chan_list[i]->basin] += Chan_list[i]->P;
             TOT_P_CAN[0] += Chan_list[i]->P;
             TOT_S_CAN[Chan_list[i]->basin] += Chan_list[i]->S;
             TOT_S_CAN[0] += Chan_list[i]->S;
         }
                                                                                               
     
         if ( printchan )
         {
                 /* report N&P concentration in mg/L (kg/m3==g/L * 1000 = mg/L) */
             Chan_list[i]->P_con = (CH_vol > 0) ? (Chan_list[i]->P/CH_vol*1000.0) : 0.0;
/*              Chan_list[i]->N_con = (CH_vol > 0) ? (Chan_list[i]->N/CH_vol*1000.0) : 0.0; */
             Chan_list[i]->S_con = (CH_vol > 0) ? (Chan_list[i]->S/CH_vol       ) : 0.0;
 
             /* v2.2 increased decimal places in output (from 6.3f to 7.4f) */
             fprintf( CanalOutFile, "%6.2f\t", Chan_list[i]->wat_depth );
             fprintf( CanalOutFile_P, "%7.4f\t", Chan_list[i]->P_con );
/*          fprintf( CanalOutFile_N, "%7.4f\t", Chan_list[i]->N_con ); */
             fprintf( CanalOutFile_S, "%7.4f\t", Chan_list[i]->S_con ); 
         }
     } 
 if ( printchan )
 {
     fflush(CanalOutFile);
     fflush(CanalOutFile_P);
/*       fflush(CanalOutFile_N); */
     fflush(CanalOutFile_S);
 }
  
 return;
}

Here is the call graph for this function:

void Canal_Network_Init	(	float	baseDatum,
		float *	elev
	)

Initialize the water managment network topology.

Initialize/configure the network of canals/levees and and water control structures. The canal information stored in the global array Chan_list

Parameters:

	baseDatum	GP_DATUM_DISTANCE
	elev	SED_ELEV

Definition at line 96 of file WatMgmt.c.

References Chan::area, CanalOutFile, CanalOutFile_P, CanalOutFile_S, canDebugFile, Chan_list, ChanInFile, Channel_configure(), debug, H_OPSYS, Chan::ic_depth, Chan::ic_N_con, Chan::ic_P_con, Chan::ic_S_con, init_pvar(), MCopen, modelFileName, modelName, modelVers, Chan::N, nalloc(), Structure::next_in_list, num_chan, ON_MAP, OutputPath, Chan::P, ProjName, ReadChanStruct(), ReadStructures(), Chan::S, s0, s1, Structure::S_nam, SimAlt, SimModif, struct_first, structs, T, UNIX, usrErr(), WstructOutFile, WstructOutFile_P, and WstructOutFile_S.

{ struct Structure *structs;
  int i,j;
  char filename[30];

  sprintf(filename,"CanalData");

/* Input the canals geometry file, return pointer to first vector               */
/* Configure the canals, marking the cells that interact with them              */ 
/* and storing the pointers to the cells for each of the canals in Chan_list array */
  Channel_configure(elev, ReadChanStruct (filename));  

  for( i = 0; i < num_chan; i++ )
  {
      Chan_list[i]->P = Chan_list[i]->ic_P_con * Chan_list[i]->area * Chan_list[i]->ic_depth; /* kg/m3 * m2 * m */
      Chan_list[i]->N = Chan_list[i]->ic_N_con * Chan_list[i]->area * Chan_list[i]->ic_depth; /* kg/m3 * m2 * m */
      Chan_list[i]->S = Chan_list[i]->ic_S_con * Chan_list[i]->area * Chan_list[i]->ic_depth; /* kg/m3 * m2 * m */
  }

  usrErr ("\tCanal geometry configured OK");
  
/* Read data on the water control structures, return pointer to the first structure */
  ReadStructures  (filename, baseDatum);

  ON_MAP[T(2,2)] = 0;
  
  MCopen = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MCopen"); /* open-water manning's coef, used in structure cell-cell bridge flow */
  init_pvar(MCopen,NULL,'f',0.05); /* this is a hard-wired parameter (value set to last argument, 0.05) - but do not do anything much with it now for the bridge flows */
  
 
 if ( debug > 0 )       /* Output the canal/levee modifications to ON_MAP */
 {
        sprintf( modelFileName, "%s/%s/Output/Debug/ON_MAP_CANAL.txt", OutputPath, ProjName );
   

  if ( ( ChanInFile = fopen( modelFileName, "w" ) ) ==  NULL )
  {
     printf( "Can't open the %s canal/levee debug file!\n", modelFileName );
     exit(-1) ;
  }
  fprintf ( ChanInFile, "ROWS=%d\nCOLUMNS=%d\nFORMAT=text\nINFO=\"Debug data: Overland flow restrictions due to levees. \"\nMISSING=0\n", s0, s1 );

  for ( i = 1; i <= s0 ; i++ ) 
    { for ( j = 1 ; j <= s1 ; j++ )
         fprintf( ChanInFile, "%4d\t", ON_MAP[T(i,j)]) ;
      fprintf ( ChanInFile, "\n" );
    }   
  fclose( ChanInFile ) ;
 }


/* Open file for writing structure flows */
    { if(H_OPSYS==UNIX) 
                sprintf( modelFileName, "%s/%s/Output/Canal/structsOut", OutputPath, ProjName );
      else sprintf( modelFileName, "%s%s:Output:structsOut", OutputPath, ProjName );
    }

        /* Open file to print structure flows to */
    if ( ( WstructOutFile = fopen( modelFileName, "w" ) ) ==  NULL )
        {
       printf( "Can't open %s file!\n", modelFileName );
       exit(-1) ;
    }
/* Print The Header Line For This File */
    fprintf ( WstructOutFile,
              "%s %s %s %s scenario: Sum of water flows at structures (ft^3/sec)\n     Date\t", &modelName, &modelVers, &SimAlt, &SimModif );
    structs = struct_first;
    while ( structs != NULL )
    {   fprintf( WstructOutFile, "%7s\t", structs->S_nam);       
            structs = structs->next_in_list;
    }

/* Open file for writing structure P concs */
    { if(H_OPSYS==UNIX) 
                sprintf( modelFileName, "%s/%s/Output/Canal/structsOut_P", OutputPath, ProjName );
      else sprintf( modelFileName, "%s%s:Output:structsOut_P", OutputPath, ProjName );
    }

        /*  Open file to print structure flows to */
    if ( ( WstructOutFile_P = fopen( modelFileName, "w" ) ) ==  NULL )
        {
       printf( "Can't open %s file!\n", modelFileName );
       exit(-1) ;
    }
/* Print The Header Line For This File */
    fprintf ( WstructOutFile_P,
              "%s %s %s %s scenario: Flow weighted mean TP conc at structures ( mg/L) \n     Date\t", &modelName, &modelVers, &SimAlt, &SimModif );
    structs = struct_first;
    while ( structs != NULL ) 
    {   fprintf( WstructOutFile_P, "%7s\t", structs->S_nam);      
            structs = structs->next_in_list; 
    }

/* Open file for writing structure Salin concs */
    { if(H_OPSYS==UNIX) 
                sprintf( modelFileName, "%s/%s/Output/Canal/structsOut_S", OutputPath, ProjName );
      else sprintf( modelFileName, "%s%s:Output:structsOut_S", OutputPath, ProjName );
    }

        /*  Open file to print structure flows to */
    if ( ( WstructOutFile_S = fopen( modelFileName, "w" ) ) ==  NULL )
        {
       printf( "Can't open %s file!\n", modelFileName );
       exit(-1) ;
    }
/* Print The Header Line For This File */
    fprintf ( WstructOutFile_S,
              "%s %s %s %s scenario: Flow weighted mean tracer concentration at structures ( g/L) \n     Date\t", &modelName, &modelVers, &SimAlt, &SimModif );
    structs = struct_first;
    while ( structs != NULL ) 
    {   fprintf( WstructOutFile_S, "%7s\t", structs->S_nam);      
            structs = structs->next_in_list; 
    }

/****/
    
        /* Open file to print canal stage info to */
    { if(H_OPSYS==UNIX) 
                sprintf( modelFileName, "%s/%s/Output/Canal/CanalOut", OutputPath, ProjName );
      else sprintf( modelFileName, "%s%s:Output:CanalOut", OutputPath, ProjName );
    }

    if ( ( CanalOutFile = fopen( modelFileName, "w" ) ) ==  NULL )
        {
       printf( "Can't open %s file!\n", modelFileName );
       exit(-1) ;
    }

    fprintf ( CanalOutFile, "%s %s %s %s scenario: Instantaneous water depth (meters, from bottom of canal) in canal Reaches\n    Date\t", &modelName, &modelVers, &SimAlt, &SimModif ); /* print the header line for this file */
    /*  channels with negative widths are reserved for new canals */
    /* v2.2 put a "R_" prefix in front of the canal ID# */
    for( i = 0; i < num_chan; i++ ) {if (Chan_list[i]->width > 0) fprintf ( CanalOutFile, "R_%d\t",Chan_list[i]->number);}
    

        /* Open file to print canal phosph info to */
    { if(H_OPSYS==UNIX) 
                sprintf( modelFileName, "%s/%s/Output/Canal/CanalOut_P", OutputPath, ProjName );
      else sprintf( modelFileName, "%s%s:Output:CanalOut_P", OutputPath, ProjName );
    }

    if ( ( CanalOutFile_P = fopen( modelFileName, "w" ) ) ==  NULL )
        {
       printf( "Can't open %s file!\n", modelFileName );
       exit(-1) ;
    }

    fprintf ( CanalOutFile_P, "%s %s %s %s scenario: Instantaneous TP conc (mg/L) in canal Reaches\n    Date\t", &modelName, &modelVers, &SimAlt, &SimModif ); /* print the header line for this file */
    /* v2.2 put a "R_" prefix in front of the canal ID# */
    for( i = 0; i < num_chan; i++ ) {if (Chan_list[i]->width > 0) fprintf ( CanalOutFile_P, "R_%d\t",Chan_list[i]->number);}
    
        /* Open file to print canal salinity/tracer info to */
    { if(H_OPSYS==UNIX) 
                sprintf( modelFileName, "%s/%s/Output/Canal/CanalOut_S", OutputPath, ProjName );
      else sprintf( modelFileName, "%s%s:Output:CanalOut_S", OutputPath, ProjName );
    }

    if ( ( CanalOutFile_S = fopen( modelFileName, "w" ) ) ==  NULL )
        {
       printf( "Can't open %s file!\n", modelFileName );
       exit(-1) ;
    }

    fprintf ( CanalOutFile_S, "%s %s %s %s scenario: Instantaneous tracer conc (g/L) in canal Reaches\n    Date\t", &modelName, &modelVers, &SimAlt, &SimModif ); /* print the header line for this file */
    /* v2.2 put a "R_" prefix in front of the canal ID# */
    for( i = 0; i < num_chan; i++ ) {if (Chan_list[i]->width > 0) fprintf ( CanalOutFile_S, "R_%d\t",Chan_list[i]->number);}
    
 

/* Open file for canal-cell flux debugging purposes */
  if( debug > 0 ) 
  { 
     if(H_OPSYS==UNIX) 
                sprintf( modelFileName, "%s/%s/Output/Debug/Can_debug", OutputPath, ProjName );
      else sprintf( modelFileName, "%s%s:Output:Can_debug", OutputPath, ProjName );
    

        /* Open file for debugging and error/warnings on canal-cell flows, structure flows */
    if ( ( canDebugFile = fopen( modelFileName, "w" ) ) ==  NULL )
        {
       printf( "Can't open %s file!\n", modelFileName );
       exit(-1) ;
    }
  
     fprintf ( canDebugFile, "Depending on level of the debug requested, printed here are data on canal-cell flows and excessive demands on data-driven structure flows. \n" ); /* v2.5 made use of this file pointer */
     fflush(canDebugFile); 
    
  }
  
  return;

}

Here is the call graph for this function:

void CanalReInit

(

)

Re-initialize the depths and concentrations in canals under the Positional Analysis mode.

Definition at line 292 of file WatMgmt.c.

References Chan::area, Chan_list, Chan::ic_depth, Chan::ic_N_con, Chan::ic_P_con, Chan::ic_S_con, Chan::N, num_chan, Chan::P, Chan::S, and Chan::wat_depth.

{
    int i;
    for( i = 0; i < num_chan; i++ )

    {
        Chan_list[i]->wat_depth = Chan_list[i]->ic_depth;
        Chan_list[i]->P = Chan_list[i]->ic_P_con * Chan_list[i]->area * Chan_list[i]->ic_depth; /* kg/m3 * m2 * m */
        Chan_list[i]->N = Chan_list[i]->ic_N_con * Chan_list[i]->area * Chan_list[i]->ic_depth; /* kg/m3 * m2 * m */
        Chan_list[i]->S = Chan_list[i]->ic_S_con * Chan_list[i]->area * Chan_list[i]->ic_depth; /* kg/m3 * m2 * m */
         
    }
}

void getInt	(	FILE *	inFile,
		const char *	lString,
		int *	iValPtr
	)

Get an integer following a specific string.

Parameters:

	inFile	File that is open
	lString	The string being read
	iValPtr	The char value found

Definition at line 1740 of file Driver_Utilities.c.

References scan_forward().

{
  int test;
  UCHAR iEx=0;
  if(lString)  
    scan_forward(inFile,lString);
  test = fscanf(inFile,"%d",iValPtr);
  if(test != 1) {
    fprintf(stderr,"Read Error (%d):",test);
    if(lString) fprintf(stderr,"%s\n",lString);
    *iValPtr = 0;
    iEx = 1;
  }
  if (iEx) exit(0);
}

Here is the call graph for this function:

void read_map_dims

(

const char *

filename

)

Establish the number of rows and columns of the model.

Read the map dimensions of the global model array, establishing rows=s0 and columns=s1

Parameters:

filename

character string of the representative map (usually "Elevation")

Definition at line 975 of file Driver_Utilities.c.

References broadcastInt(), debug, Exit(), gbl_size, Lprocnum, modelFileName, ModelPath, msgStr, ProjName, s0, s1, scan_forward(), usrErr(), and WriteMsg().

{
  FILE *file;
  
  if (debug>3) { sprintf(msgStr,"Getting map dims: %s",filename); usrErr(msgStr);} 
  if(Lprocnum == 1) {
    sprintf(modelFileName,"%s/%s/Data/Map_head/%s",ModelPath,ProjName,filename);
    file = fopen(modelFileName,"r");
    if(file==NULL) { 
      fprintf(stderr,"Unable to open map header file %s.\n",modelFileName); 
      fflush(stderr); 
      Exit(0);
    }
    scan_forward(file,"cols:");
    fscanf(file,"%d",&gbl_size[1]);
    sprintf(msgStr,"cols = %d\n",gbl_size[1]); WriteMsg(msgStr,1);
    scan_forward(file,"rows:");
    fscanf(file,"%d",&gbl_size[0]);
    sprintf(msgStr,"rows = %d\n",gbl_size[0]); WriteMsg(msgStr,1);
    fclose(file);
  }
  broadcastInt(gbl_size);   /* does nothing in serial (non-parallel) implementation */
  broadcastInt(gbl_size+1); /* does nothing in serial (non-parallel) implementation */
  s0 = gbl_size[0];
  s1 = gbl_size[1];
}

Here is the call graph for this function:

void write_output	(	int	index,
		ViewParm *	vp,
		void *	Map,
		const char *	filename,
		char	Mtype,
		int	step
	)

Determine which functions to call for model output.

Parameters:

	index	Count index of the output iteration for this variable (may be > step)
	vp	A struct of ViewParm, outlist configuration
	Map	Model variable array data
	filename	Output file name
	Mtype	General output format type
	step	The current output step

Definition at line 435 of file Driver_Utilities.c.

References calc_maxmin(), debug, viewParm::fileName, point3D::format, getPrecision(), viewParm::mapType, msgStr, viewParm::nPoints, scale1::o, viewParm::points, print_loc_ave(), print_point(), quick_look(), scale1::s, viewParm::scale, viewParm::step, point3D::type, viewParm::varUnits, write_map_file(), WriteMsg(), point3D::x, point3D::y, and point3D::z.

{
        int i; Point3D point;
        

        if(vp->mapType != 'N' ) { 
                        write_map_file((char*)filename,Map,Mtype,index,vp->scale.s,vp->scale.o,getPrecision(vp),vp->mapType,vp->varUnits,vp->step,vp->fileName); /* v2.8.2 added varUnits, vp->step (which is outstep interval), and fileName for netCDF use */
                        if (debug > 3) calc_maxmin(vp,Map,Mtype,(char*)filename,step);
        }
        for(i=0; i< (vp->nPoints); i++ ) {
                point = vp->points[i];
            if (debug > 3) { sprintf(msgStr,"\nwriting Out: %s(%d): %c(), index = %d, step=%d\n", filename, i, point.type, index, step ); 
            WriteMsg(msgStr,1); 
            }
            
                switch( point.type ) {  
                    case 'm': case 'M': calc_maxmin( vp,Map,Mtype,(char*)filename,step); break; 
                    case 'w': quick_look( Map,(char*) filename, Mtype, point.x, point.y, point.z, point.format ); break;
                    case 'a': case 's': case 'A': case 'S': print_loc_ave( &point, Map, Mtype, (char*)filename, step ); break;
                    case 'p': print_point( vp, Map, Mtype, (char*)filename, step, i ); break;
                }
        }
}

Here is the call graph for this function:

void getChar	(	FILE *	inFile,
		const char *	lString,
		char *	cValPtr
	)

Get a character following a specific string.

Parameters:

	inFile	File that is open
	lString	The string being read
	cValPtr	The char value found

Definition at line 1702 of file Driver_Utilities.c.

References scan_forward().

{
  int test;
  UCHAR iEx=0;
  if(lString)  scan_forward(inFile,lString);
  test = fscanf(inFile,"%c",cValPtr);
  if(test != 1) {
    fprintf(stderr,"Read Error (%d):",test);
    if(lString) fprintf(stderr,"%s\n",lString);
    iEx = 1;
    *cValPtr = '\0';
  }
  if (iEx) exit(0);
}

Here is the call graph for this function:

void init_pvar	(	VOIDP	Map,
		UCHAR *	mask,
		unsigned char	Mtype,
		float	iv
	)

Initialize a variable to a value.

Parameters:

	Map	array of data
	mask	data mask
	Mtype	the data type of the map data
	iv	the value used to initialize variable

Definition at line 1008 of file Driver_Utilities.c.

{
  int i0, i1;
  
  switch(Mtype) {
  case 'b' :    /* added double for (non-map) basin (b) array budget calcs */
    for(i0=0; i0<=numBasn; i0++) {
        ((double*)Map)[i0] = iv;
      }
    break;
  case 'l' :    /* added double (l == letter "ell" ) for map arrays */
    for(i0=0; i0<=s0+1; i0++) 
      for(i1=0; i1<=s1+1; i1++) {
        if(mask==NULL) ((double*)Map)[T(i0,i1)] = iv;
        else if ( mask[T(i0,i1)] == 0 ) ((double*)Map)[T(i0,i1)] = 0;
        else ((double*)Map)[T(i0,i1)] = iv;
      }
    break;
  case 'f' :    
    for(i0=0; i0<=s0+1; i0++) 
      for(i1=0; i1<=s1+1; i1++) {
        if(mask==NULL) ((float*)Map)[T(i0,i1)] = iv;
        else if ( mask[T(i0,i1)] == 0 ) ((float*)Map)[T(i0,i1)] = 0;
        else ((float*)Map)[T(i0,i1)] = iv;
      }
    break;
  case 'i' :    case 'd' :      
    for(i0=0; i0<=s0+1; i0++) 
      for(i1=0; i1<=s1+1; i1++) {
        if(mask==NULL) ((int*)Map)[T(i0,i1)] = (int)iv;
        else if ( mask[T(i0,i1)] == 0 ) ((int*)Map)[T(i0,i1)] = 0;
        else ((int*)Map)[T(i0,i1)] = (int)iv;
      }
    break;
  case 'c' :    
    for(i0=0; i0<=s0+1; i0++) 
      for(i1=0; i1<=s1+1; i1++) {
        if(mask==NULL) ((unsigned char*)Map)[T(i0,i1)] = (unsigned char) '\0' + (int) iv;
        else if ( mask[T(i0,i1)] == 0 ) ((unsigned char*)Map)[T(i0,i1)] = '\0';
        else ((unsigned char*)Map)[T(i0,i1)] = (unsigned char) '\0' + (int) iv;
      } 
    break;
 
   default :
    printf(" in default case\n");
   break;
  }
}

int read_map_file	(	const char *	filename,
		VOIDP	Map,
		unsigned char	Mtype,
		float	scale_value,
		float	offset_value
	)

Get the file and read/convert the data of map (array).

Parameters:

	filename	Input file name
	Map	Model variable array data
	Mtype	General data format type
	scale_value	Variable-scaling multiplier
	offset_value	Variable-scaling offset

Returns:

byte size of data values

Definition at line 674 of file Driver_Utilities.c.

References dbgPt, debug, gridSize, gTemp, gTempSize, lcl_size, link_edges(), msgStr, nalloc(), procnum, quick_look(), readMap(), s0, s1, T, usrErr(), WriteMsg(), point2D::x, and point2D::y.

{
  int i, j, k0, size;
  unsigned temp;
  UCHAR *tmpPtr, Dsize;
  
gridSize = (s0+2)*(s1+2);
gTempSize = gridSize*8;


  size = gridSize*4 +1;
  if( size > gTempSize ) { 
    if(gTemp) free((char*)gTemp); 
    gTemp = (UCHAR*)nalloc( size, "gTemp" );    
    gTempSize = size; 
  }
  
  if(debug>2) { 
    sprintf(msgStr,"Reading %s\n",filename);  
    usrErr(msgStr); 
    WriteMsg(msgStr,1); 
  } 
  
  Dsize = readMap(filename,gTemp);
  
  if(debug) { 
    sprintf(msgStr,"name = %s, proc = %d, scale_value = %f, offset_value = %f, size = %x\n ",
            filename,procnum,scale_value,offset_value,Dsize);  
    WriteMsg(msgStr,1); 
  } 
  for (i=1; i<=s0; i++) {
    for (j=1; j<=s1; j++) {
      k0 = Dsize*((i-1)*lcl_size[1] + (j-1));
      tmpPtr = gTemp+k0;
      switch(Dsize) {
        case 1: temp = gTemp[k0]; break;
        case 2: temp = gTemp[k0]*256 + gTemp[k0+1]; break;
        case 3: temp = gTemp[k0]*65536 + gTemp[k0+1]*256 + gTemp[k0+2]; break;
        case 4: temp = gTemp[k0]*16777216 + gTemp[k0+1]*65536 + gTemp[k0+2]*256 + gTemp[k0+3]; break;
        default: fprintf(stderr,"ERROR, illegal size: %x\n",Dsize); temp = 0;
      }                                         
      switch (Mtype) {
        case 'f' :
          ((float*)Map)[T(i,j)] = scale_value*((float)temp)+offset_value; 
        break;
        case 'd' : case 'i' :
          ((int*)Map)[T(i,j)] = (int)(scale_value * (float)temp + offset_value); 
        break;
        case 'c' :
          ((unsigned char*)Map)[T(i,j)] = (int)(scale_value * (unsigned char)temp); 
        break;
      }
    }
  }
  if(debug) quick_look(Map, (char*)filename, Mtype, dbgPt.x, dbgPt.y, 2,'E');
  link_edges(Map,Mtype);
  fflush(stderr);
  return Dsize;
}

Here is the call graph for this function:

int scan_forward	(	FILE *	infile,
		const char *	tstring
	)

Scan forward until a particular string is found.

Parameters:

	infile	The file being read
	tstring	The sought-after string

Returns:

Success/failure

Definition at line 1814 of file Driver_Utilities.c.

{
  int sLen, i, cnt=0;
  char Input_string[100], test;
  
  sLen = strlen(tstring);
  while( ( test = fgetc(infile) ) != EOF ) {
    for(i=0; i<(sLen-1); i++) 
        Input_string[i] = Input_string[i+1];
    Input_string[sLen-1] = test;
    Input_string[sLen] = '\0';
    if(++cnt >= sLen) {
      test =  strcmp(Input_string,tstring);
      if( test == 0 ) return 1;
    }
  }
  return(-1);
}

VOIDP nalloc	(	unsigned	mem_size,
		const char	var_name[]
	)

Allocate memory for a variable.

Parameters:

	mem_size	The size of memory space
	var_name	The variable's name

Returns:

Pointer to that memory

Definition at line 1857 of file Driver_Utilities.c.

{
  VOIDP rp;

  
  if(mem_size == 0) return(NULL);
  rp = (VOIDP)malloc( mem_size );
  total_memory += mem_size;
  fasync(stderr);
  if( rp == NULL ) {
    fprintf(stderr,"Sorry, out of memory(%d): %s\n",mem_size,var_name);
    Exit(0);
  }
  fmulti(stderr);
  return(rp);
}

float FMOD	(	float	x,
		float	y
	)

Modulus of a pair of (double) arguments.

Parameters:

	x	Numerator
	y	Denominator

Returns:

modulus (float) result

Definition at line 1675 of file Driver_Utilities.c.

                             { 
return (float)fmod((double)x, (double)y); 
} 

void PTSL_ReadLists	(	PTSeriesList *	thisStruct,
		const char *	ptsFileName,
		int	index,
		float *	timeStep,
		int *	nPtTS,
		int	col
	)

Point Time Series interpolation (unused): read raw point data.

Definition at line 1218 of file Driver_Utilities.c.

References broadcastInt(), debug, Exit(), gNPtTs, gTS, H_OPSYS, Lprocnum, modelFileName, ModelPath, msgStr, ProjName, PTSL_AddpTSeries(), UNIX, usrErr(), and WriteMsg().

{
  char pathname[150], infilename[60], ss[201], ret = '\n';
  FILE* cfile;
  int ix, iy, tst, sCnt=0;
  if( Lprocnum == 1 ) {
    if(H_OPSYS==UNIX) sprintf(modelFileName,"%s/%s/Data/%s.pts",ModelPath,ProjName,ptsFileName);
    else sprintf(modelFileName,"%s%s:Data:%s.pts",ModelPath,ProjName,ptsFileName); 
    cfile = fopen(modelFileName,"r");
    if(cfile==NULL) {fprintf(stdout,"\nERROR: Unable to open timeseries file %s\n",modelFileName); Exit(1); }
    else { sprintf(msgStr,"\nReading file %s\n",modelFileName); WriteMsg(msgStr,1); } 
    if (debug > 2) {sprintf(msgStr,"Reading %s timeseries, column %d",modelFileName, col); usrErr(msgStr);}
    
  

    fgets(ss,200,cfile); /* skip header line */
  }
  while(1) {
    if( Lprocnum == 1 ) {
      tst = fscanf(cfile,"%d",&ix);
      if( tst > 0  ) {
        fscanf(cfile,"%d",&iy); 
        tst = fscanf(cfile,"%s",infilename); 
        sprintf(modelFileName,"%s/%s/Data/%s",ModelPath,ProjName,infilename);
      }
    }
    broadcastInt(&tst); 
    if(tst<1) break;
    broadcastInt(&ix); 
    broadcastInt(&iy); 
    PTSL_AddpTSeries(thisStruct, ix, iy, index, sCnt, col);
    sCnt++;
  }
  if( Lprocnum == 1 ) fclose(cfile);  
  *nPtTS = gNPtTs;
  *timeStep = gTS;
} 

Here is the call graph for this function:

void PTSL_CreatePointMap	(	PTSeriesList *	pList,
		void *	Map,
		unsigned char	Mtype,
		int	step,
		float	scale
	)

Point Time Series interpolation (unused): generate interpolated spatial (map) data.

Definition at line 1258 of file Driver_Utilities.c.

References ON_MAP, PTSL_GetInterpolatedValue0(), s0, s1, and T.

{
  int i0, i1;
  
  switch(Mtype) {
  case 'f' :    
    for(i0=0; i0<=s0+1; i0++) 
      for(i1=0; i1<=s1+1; i1++) 
        ((float*)Map)[T(i0,i1)] = (ON_MAP[T(i0,i1)]) ? PTSL_GetInterpolatedValue0(pList,i0,i1,step)*scale : 0.0 /*was this value (v0.5beta) -0.012 */; 
    break;
  case 'i' :    case 'd' :      
    for(i0=0; i0<=s0+1; i0++) 
      for(i1=0; i1<=s1+1; i1++) 
        ((int*)Map)[T(i0,i1)] = (int)  ( (ON_MAP[T(i0,i1)]) ? PTSL_GetInterpolatedValue0(pList,i0,i1,step)*scale : 0 );
    break;
  case 'c' :    
    for(i0=0; i0<=s0+1; i0++) 
      for(i1=0; i1<=s1+1; i1++) 
        ((unsigned char*)Map)[T(i0,i1)] = (unsigned char) '\0' + (int)  ( (ON_MAP[T(i0,i1)]) ? PTSL_GetInterpolatedValue0(pList,i0,i1,step)*scale : 0 );
    break;
  }
}

Here is the call graph for this function:

void stats

(

int

step

)

Calling function for budget and summary stats.

Called every time step, this calls functions to summarize variables across time At the time interval for output, this calls functions to make the final summaries, and then resets the data for new interval.

Definition at line 63 of file BudgStats.c.

References BIRbudg_date(), BIRbudg_reset(), BIRbudg_sum(), BIRbudg_sumFinal(), BIRstats_date(), BIRstats_hydro_date(), BIRstats_hydro_reset(), BIRstats_hydro_sumFinal(), BIRstats_reset(), BIRstats_sum(), BIRstats_sumFinal(), CellAvg(), simTime::IsBIRavgEnd, simTime::IsBIRhydEnd, simTime::IsBudgEnd, simTime::IsBudgFirst, simTime::IsDay0, and SimTime.

{
    CellAvg();  /* Generate sums, means (avgs), on cell-by-cell basis (not by Basin/IRegion here) */
        
    BIRstats_sum();  
    BIRbudg_sum();  

/* v2.8 hydro Perf Measure summaries - is a first cut, TODO is re-organize it */
    if ( (SimTime.IsBIRhydEnd) )  {
                if (!SimTime.IsDay0) BIRstats_hydro_date(); 
                BIRstats_hydro_sumFinal();
        BIRstats_hydro_reset();
    } 
    if ( (SimTime.IsBIRavgEnd) )  {
        if (!SimTime.IsDay0) BIRstats_date(); /* skip TIME 0 of simulation */
                BIRstats_sumFinal();
        BIRstats_reset();
    } 
    if ( (SimTime.IsBudgEnd) )  {
        if (!SimTime.IsBudgFirst) BIRbudg_date(); /* skip first budget interval to accumulate info for mass-balance budget check */
                BIRbudg_sumFinal();
        BIRbudg_reset();
    } 
} 

Here is the call graph for this function:

void alloc_mem_stats

(

void

)

Allocate memory for the BIR-based and cell-based stats variables.

Definition at line 2137 of file BudgStats.c.

References basn, BCmodel_sfwatAvg, BIR_DayFire, BIR_Sf_vel, C_Peri_mortAvg, C_Peri_nppAvg, C_Peri_PCAvg, C_PeriAvg, C_PeriNutCFAvg, C_PeriRespAvg, Calg_GPP, Calg_mort, CLsf_avg, Cperi_avg, DayFire, dop_decomp, dop_desorb, dop_macIn, dop_sorbIn, Elev_avg, ETAvg, EVAP, EvapAvg, floc_decomp, Floc_fr_phBioAvg, floc_In, HydPerAnn, HydRelDepPosNegAvg, init_pvar(), LAI_effAvg, Mac_avg, mac_mort, mac_nph_PCAvg, Mac_nphBioAvg, Mac_nphMortAvg, mac_NPP, Mac_nppAvg, mac_ph_PCAvg, Mac_phBioAvg, Mac_phMortAvg, Mac_totBioAvg, MacNutCfAvg, MacWatCfAvg, Manning_nAvg, msgStr, nalloc(), NC_Peri_mortAvg, NC_Peri_nppAvg, NC_Peri_PCAvg, NC_PeriAvg, NC_PeriNutCFAvg, NC_PeriRespAvg, NCalg_GPP, NCalg_mort, NCperi_avg, numBasn, numCells, ON_MAP, P, P_ATMOS, P_Calg, P_CELL, P_DEAD, P_DEAD_CELL, P_DEAD_ERR, P_DEAD_ERR_CUM, P_DEAD_IN, P_DEAD_IN_AVG, P_DEAD_IN_SUM, P_DEAD_OLD, P_DEAD_OUT, P_DEAD_OUT_AVG, P_DEAD_OUT_SUM, P_ERR, P_ERR_CUM, P_IN, P_IN_AVG, P_IN_GW, P_IN_OVL, P_IN_SPG, P_IN_STR, P_IN_SUM, P_LIVE, P_LIVE_CELL, P_LIVE_ERR, P_LIVE_ERR_CUM, P_LIVE_IN, P_LIVE_IN_AVG, P_LIVE_IN_SUM, P_LIVE_OLD, P_LIVE_OUT, P_LIVE_OUT_AVG, P_LIVE_OUT_SUM, P_MAC, P_NCalg, P_OLD, P_OUT, P_OUT_AVG, P_OUT_GW, P_OUT_OVL, P_OUT_SPG, P_OUT_STR, P_OUT_SUM, P_settl, P_WAT, P_WAT_CELL, P_WAT_ERR, P_WAT_ERR_CUM, P_WAT_IN, P_WAT_IN_AVG, P_WAT_IN_SUM, P_WAT_OLD, P_WAT_OUT, P_WAT_OUT_AVG, P_WAT_OUT_SUM, PeriAvg, PeriLiteCFAvg, RAIN, RainAvg, RCHG, s0, s1, S_ERR_CUM, S_IN, S_IN_AVG, S_IN_GW, S_IN_OVL, S_IN_SPG, S_IN_STR, S_IN_SUM, S_OUT, S_OUT_AVG, S_OUT_GW, S_OUT_OVL, S_OUT_SPG, S_OUT_STR, S_OUT_SUM, SALT_ATMOS, SaltSedAvg, SaltSfAvg, SedElevAvg, SF_WT_VEL_magAvg, Sfwat_avg, SfWatAvg, StgMinElev, SUMGW, SUMSF, SUMUW, T, TOT_P_CAN, TOT_S, TOT_S_CAN, TOT_S_CELL, TOT_S_ERR, TOT_S_OLD, TOT_VOL, TOT_VOL_AVG_ERR, TOT_VOL_CAN, TOT_VOL_CUM_ERR, TOT_VOL_ERR, TOT_VOL_OLD, TotHeadAvg, TP_settlAvg, TPpore_avg, TPSedMinAvg, TPSedUptAvg, TPSedWatAvg, TPsf_avg, TPSfMinAvg, TPSfUptAvg, TPSfWatAvg, TPsoil_avg, TPSorbAvg, TPtoSOILAvg, TPtoVOLAvg, TRANSP, TranspAvg, Unsat_avg, UnsatMoistAvg, UnsatZavg, usrErr0(), VOL_ERR_PER_INFL, VOL_IN, VOL_IN_AVG, VOL_IN_GW, VOL_IN_OVL, VOL_IN_SPG, VOL_IN_STR, VOL_IN_SUM, VOL_OUT, VOL_OUT_AVG, VOL_OUT_GW, VOL_OUT_OVL, VOL_OUT_SPG, VOL_OUT_STR, VOL_OUT_SUM, wat_sedMiner, wat_sedUpt, wat_sfMiner, and wat_sfUpt.

{
    int ix,iy,cellLoc, numBasnMax=0;


    for(ix=0; ix<=s0+1; ix++) 
        for(iy=0; iy<=s1+1; iy++)
            if (ON_MAP[cellLoc= T(ix,iy)]) { 
                if (basn[cellLoc] > numBasnMax) numBasnMax = basn[cellLoc]; 
            }
    numBasn = numBasnMax; /* total number of basins in domain */
    
    sprintf (msgStr," %d Basins/Indicator-Regions...",numBasn); usrErr0(msgStr);
    
/* basin budget arrays (number of actual basins plus basin 0, which is whole system) */
    numCells = (int *) nalloc (sizeof(int)*(numBasn+1),"numCells"); /* number of cells in a basin */

/* Indicator region averages (non-budget) */
        /* v2.8 hydro Perf Measure summaries - is a first cut, TODO is re-organize it */
        StgMinElev = (double *) nalloc(sizeof(double)*(numBasn+1),"StgMinElev");
        init_pvar(StgMinElev,NULL,'b',0.0);
        BIR_Sf_vel = (double *) nalloc(sizeof(double)*(numBasn+1),"BIR_Sf_vel");
        init_pvar(BIR_Sf_vel,NULL,'b',0.0);
        BIR_DayFire = (double *) nalloc(sizeof(double)*(numBasn+1),"BIR_DayFire");
        init_pvar(BIR_DayFire,NULL,'b',0.0);
        DayFire = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"DayFire");
        init_pvar(DayFire,NULL,'f',0.0);
        CLsf_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"CLsf_avg");
        init_pvar(CLsf_avg,NULL,'b',0.0);
/* end of v2.8 hydro Perf Measure summaries - is a first cut, TODO is re-organize it */

        Sfwat_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"Sfwat_avg");
        init_pvar(Sfwat_avg,NULL,'b',0.0);
        Unsat_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"Unsat_avg");
        init_pvar(Unsat_avg,NULL,'b',0.0);
        TPsf_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"TPsf_avg");
        init_pvar(TPsf_avg,NULL,'b',0.0);
        TPpore_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"TPpore_avg");
        init_pvar(TPpore_avg,NULL,'b',0.0);
        TPsoil_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"TPsoil_avg");
        init_pvar(TPsoil_avg,NULL,'b',0.0);
        NCperi_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"NCperi_avg");
        init_pvar(NCperi_avg,NULL,'b',0.0);
        Cperi_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"Cperi_avg");
        init_pvar(Cperi_avg,NULL,'b',0.0);
        Mac_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"Mac_avg");
        init_pvar(Mac_avg,NULL,'b',0.0);
        Elev_avg = (double *) nalloc(sizeof(double)*(numBasn+1),"Elev_avg");
        init_pvar(Elev_avg,NULL,'b',0.0);
/* hydro mass bal vars */
        SUMSF = (double *) nalloc(sizeof(double)*(numBasn+1),"SUMSF");
        init_pvar(SUMSF,NULL,'b',0.0);
        SUMGW = (double *) nalloc(sizeof(double)*(numBasn+1),"SUMGW");
        init_pvar(SUMGW,NULL,'b',0.0);
        SUMUW = (double *) nalloc(sizeof(double)*(numBasn+1),"SUMUW");
        init_pvar(SUMUW,NULL,'b',0.0);
        RAIN = (double *) nalloc(sizeof(double)*(numBasn+1),"RAIN");
        init_pvar(RAIN,NULL,'b',0.0);
        EVAP = (double *) nalloc(sizeof(double)*(numBasn+1),"EVAP");
        init_pvar(EVAP,NULL,'b',0.0);
        TRANSP = (double *) nalloc(sizeof(double)*(numBasn+1),"TRANSP");
        init_pvar(TRANSP,NULL,'b',0.0);
        RCHG = (double *) nalloc(sizeof(double)*(numBasn+1),"RCHG");
        init_pvar(RCHG,NULL,'b',0.0);

        TOT_VOL = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_VOL");
        init_pvar(TOT_VOL,NULL,'b',0.0);
        TOT_VOL_OLD = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_VOL_OLD");
        init_pvar(TOT_VOL_OLD,NULL,'b',0.0);
        VOL_IN = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_IN");
        init_pvar(VOL_IN,NULL,'b',0.0);
        VOL_OUT = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_OUT");
        init_pvar(VOL_OUT,NULL,'b',0.0);
        TOT_VOL_ERR = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_VOL_ERR");
        init_pvar(TOT_VOL_ERR,NULL,'b',0.0);
        TOT_VOL_CUM_ERR = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_VOL_CUM_ERR");
        init_pvar(TOT_VOL_CUM_ERR,NULL,'b',0.0);
        TOT_VOL_AVG_ERR = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_VOL_AVG_ERR");
        init_pvar(TOT_VOL_AVG_ERR,NULL,'b',0.0);
        VOL_ERR_PER_INFL = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_ERR_PER_INFL");
        init_pvar(VOL_ERR_PER_INFL,NULL,'b',0.0);

        VOL_IN_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_IN_SUM");
        init_pvar(VOL_IN_SUM,NULL,'b',0.0);
        VOL_OUT_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_OUT_SUM");
        init_pvar(VOL_OUT_SUM,NULL,'b',0.0);
        VOL_IN_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_IN_AVG");
        init_pvar(VOL_IN_AVG,NULL,'b',0.0);
        VOL_OUT_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_OUT_AVG");
        init_pvar(VOL_OUT_AVG,NULL,'b',0.0);

        TOT_VOL_CAN = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_VOL_CAN");
        init_pvar(TOT_VOL_CAN,NULL,'b',0.0);

        VOL_IN_STR = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_IN_STR");
        init_pvar(VOL_IN_STR,NULL,'b',0.0);
        VOL_IN_OVL = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_IN_OVL");
        init_pvar(VOL_IN_OVL,NULL,'b',0.0);
        VOL_IN_SPG = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_IN_SPG");
        init_pvar(VOL_IN_SPG,NULL,'b',0.0);
        VOL_IN_GW = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_IN_GW");
        init_pvar(VOL_IN_GW,NULL,'b',0.0);

        VOL_OUT_STR = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_OUT_STR");
        init_pvar(VOL_OUT_STR,NULL,'b',0.0);
        VOL_OUT_OVL = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_OUT_OVL");
        init_pvar(VOL_OUT_OVL,NULL,'b',0.0);
        VOL_OUT_SPG = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_OUT_SPG");
        init_pvar(VOL_OUT_SPG,NULL,'b',0.0);
        VOL_OUT_GW = (double *) nalloc(sizeof(double)*(numBasn+1),"VOL_OUT_GW");
        init_pvar(VOL_OUT_GW,NULL,'b',0.0);

/* phosph mass bal vars for all storage fractions */
        P_CELL = (double *) nalloc(sizeof(double)*(numBasn+1),"P_CELL");
        init_pvar(P_CELL,NULL,'b',0.0);
        P_ATMOS = (double *) nalloc(sizeof(double)*(numBasn+1),"P_ATMOS");
        init_pvar(P_ATMOS,NULL,'b',0.0);

        P = (double *) nalloc(sizeof(double)*(numBasn+1),"P");
        init_pvar(P,NULL,'b',0.0);
        P_OLD = (double *) nalloc(sizeof(double)*(numBasn+1),"P_OLD");
        init_pvar(P_OLD,NULL,'b',0.0);
        P_IN = (double *) nalloc(sizeof(double)*(numBasn+1),"P_IN");
        init_pvar(P_IN,NULL,'b',0.0);
        P_OUT = (double *) nalloc(sizeof(double)*(numBasn+1),"P_OUT");
        init_pvar(P_OUT,NULL,'b',0.0);
        P_ERR = (double *) nalloc(sizeof(double)*(numBasn+1),"P_ERR");
        init_pvar(P_ERR,NULL,'b',0.0);
        P_ERR_CUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_ERR_CUM");
        init_pvar(P_ERR_CUM,NULL,'b',0.0);

        P_IN_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_IN_SUM");
        init_pvar(P_IN_SUM,NULL,'b',0.0);
        P_OUT_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_OUT_SUM");
        init_pvar(P_OUT_SUM,NULL,'b',0.0);
        P_IN_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_IN_AVG");
        init_pvar(P_IN_AVG,NULL,'b',0.0);
        P_OUT_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_OUT_AVG");
        init_pvar(P_OUT_AVG,NULL,'b',0.0);

        TOT_P_CAN = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_P_CAN");
        init_pvar(TOT_P_CAN,NULL,'b',0.0);

        P_IN_STR = (double *) nalloc(sizeof(double)*(numBasn+1),"P_IN_STR");
        init_pvar(P_IN_STR,NULL,'b',0.0);
        P_IN_OVL = (double *) nalloc(sizeof(double)*(numBasn+1),"P_IN_OVL");
        init_pvar(P_IN_OVL,NULL,'b',0.0);
        P_IN_SPG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_IN_SPG");
        init_pvar(P_IN_SPG,NULL,'b',0.0);
        P_IN_GW = (double *) nalloc(sizeof(double)*(numBasn+1),"P_IN_GW");
        init_pvar(P_IN_GW,NULL,'b',0.0);

        P_OUT_STR = (double *) nalloc(sizeof(double)*(numBasn+1),"P_OUT_STR");
        init_pvar(P_OUT_STR,NULL,'b',0.0);
        P_OUT_OVL = (double *) nalloc(sizeof(double)*(numBasn+1),"P_OUT_OVL");
        init_pvar(P_OUT_OVL,NULL,'b',0.0);
        P_OUT_SPG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_OUT_SPG");
        init_pvar(P_OUT_SPG,NULL,'b',0.0);
        P_OUT_GW = (double *) nalloc(sizeof(double)*(numBasn+1),"P_OUT_GW");
        init_pvar(P_OUT_GW,NULL,'b',0.0);

/* phosph mass bal vars for live fraction */
        P_LIVE_CELL = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_CELL");
        init_pvar(P_LIVE_CELL,NULL,'b',0.0);
        P_MAC = (double *) nalloc(sizeof(double)*(numBasn+1),"P_MAC");
        init_pvar(P_MAC,NULL,'b',0.0);
        P_Calg = (double *) nalloc(sizeof(double)*(numBasn+1),"P_Calg");
        init_pvar(P_Calg,NULL,'b',0.0);
        P_NCalg = (double *) nalloc(sizeof(double)*(numBasn+1),"P_NCalg");
        init_pvar(P_NCalg,NULL,'b',0.0);
        Calg_GPP = (double *) nalloc(sizeof(double)*(numBasn+1),"Calg_GPP");
        init_pvar(Calg_GPP,NULL,'b',0.0);
        NCalg_GPP = (double *) nalloc(sizeof(double)*(numBasn+1),"NCalg_GPP");
        init_pvar(NCalg_GPP,NULL,'b',0.0);
        Calg_mort = (double *) nalloc(sizeof(double)*(numBasn+1),"Calg_mort");
        init_pvar(Calg_mort,NULL,'b',0.0);
        NCalg_mort = (double *) nalloc(sizeof(double)*(numBasn+1),"NCalg_mort");
        init_pvar(NCalg_mort,NULL,'b',0.0);

        mac_NPP = (double *) nalloc(sizeof(double)*(numBasn+1),"mac_NPP");
        init_pvar(mac_NPP,NULL,'b',0.0);
        mac_mort = (double *) nalloc(sizeof(double)*(numBasn+1),"mac_mort");
        init_pvar(mac_mort,NULL,'b',0.0);

        P_LIVE = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE");
        init_pvar(P_LIVE,NULL,'b',0.0);

        P_LIVE_OLD = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_OLD");
        init_pvar(P_LIVE_OLD,NULL,'b',0.0);
        P_LIVE_IN = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_IN");
        init_pvar(P_LIVE_IN,NULL,'b',0.0);
        P_LIVE_OUT = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_OUT");
        init_pvar(P_LIVE_OUT,NULL,'b',0.0);
        P_LIVE_ERR = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_ERR");
        init_pvar(P_LIVE_ERR,NULL,'b',0.0);
        P_LIVE_ERR_CUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_ERR_CUM");
        init_pvar(P_LIVE_ERR_CUM,NULL,'b',0.0);

        P_LIVE_IN_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_IN_SUM");
        init_pvar(P_LIVE_IN_SUM,NULL,'b',0.0);
        P_LIVE_OUT_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_OUT_SUM");
        init_pvar(P_LIVE_OUT_SUM,NULL,'b',0.0);
        P_LIVE_IN_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_IN_AVG");
        init_pvar(P_LIVE_IN_AVG,NULL,'b',0.0);
        P_LIVE_OUT_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_LIVE_OUT_AVG");
        init_pvar(P_LIVE_OUT_AVG,NULL,'b',0.0);

/* phosph mass bal vars for dead fraction */
        P_DEAD_CELL = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_CELL");
        init_pvar(P_DEAD_CELL,NULL,'b',0.0);
        dop_macIn = (double *) nalloc(sizeof(double)*(numBasn+1),"dop_macIn");
        init_pvar(dop_macIn,NULL,'b',0.0);
        dop_sorbIn = (double *) nalloc(sizeof(double)*(numBasn+1),"dop_sorbIn");
        init_pvar(dop_sorbIn,NULL,'b',0.0);
        dop_decomp = (double *) nalloc(sizeof(double)*(numBasn+1),"dop_decomp");
        init_pvar(dop_decomp,NULL,'b',0.0);
        dop_desorb = (double *) nalloc(sizeof(double)*(numBasn+1),"dop_desorb");
        init_pvar(dop_desorb,NULL,'b',0.0);
        floc_decomp = (double *) nalloc(sizeof(double)*(numBasn+1),"floc_decomp");
        init_pvar(floc_decomp,NULL,'b',0.0);
        floc_In = (double *) nalloc(sizeof(double)*(numBasn+1),"floc_In");
        init_pvar(floc_In,NULL,'b',0.0);

        P_DEAD = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD");
        init_pvar(P_DEAD,NULL,'b',0.0);

        P_DEAD_OLD = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_OLD");
        init_pvar(P_DEAD_OLD,NULL,'b',0.0);
        P_DEAD_IN = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_IN");
        init_pvar(P_DEAD_IN,NULL,'b',0.0);
        P_DEAD_OUT = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_OUT");
        init_pvar(P_DEAD_OUT,NULL,'b',0.0);
        P_DEAD_ERR = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_ERR");
        init_pvar(P_DEAD_ERR,NULL,'b',0.0);
        P_DEAD_ERR_CUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_ERR_CUM");
        init_pvar(P_DEAD_ERR_CUM,NULL,'b',0.0);

        P_DEAD_IN_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_IN_SUM");
        init_pvar(P_DEAD_IN_SUM,NULL,'b',0.0);
        P_DEAD_OUT_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_OUT_SUM");
        init_pvar(P_DEAD_OUT_SUM,NULL,'b',0.0);
        P_DEAD_IN_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_IN_AVG");
        init_pvar(P_DEAD_IN_AVG,NULL,'b',0.0);
        P_DEAD_OUT_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_DEAD_OUT_AVG");
        init_pvar(P_DEAD_OUT_AVG,NULL,'b',0.0);

/* phosph mass bal vars for water-borne fraction */
        P_WAT_CELL = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_CELL");
        init_pvar(P_WAT_CELL,NULL,'b',0.0);
        wat_sfMiner = (double *) nalloc(sizeof(double)*(numBasn+1),"wat_sfMiner");
        init_pvar(wat_sfMiner,NULL,'b',0.0);
        wat_sedMiner = (double *) nalloc(sizeof(double)*(numBasn+1),"wat_sedMiner");
        init_pvar(wat_sedMiner,NULL,'b',0.0);
        wat_sfUpt = (double *) nalloc(sizeof(double)*(numBasn+1),"wat_sfUpt");
        init_pvar(wat_sfUpt,NULL,'b',0.0);
        P_settl = (double *) nalloc(sizeof(double)*(numBasn+1),"P_settl");
        init_pvar(P_settl,NULL,'b',0.0);
        wat_sedUpt = (double *) nalloc(sizeof(double)*(numBasn+1),"wat_sedUpt");
        init_pvar(wat_sedUpt,NULL,'b',0.0);

        P_WAT = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT");
        init_pvar(P_WAT,NULL,'b',0.0);

        P_WAT_OLD = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_OLD");
        init_pvar(P_WAT_OLD,NULL,'b',0.0);
        P_WAT_IN = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_IN");
        init_pvar(P_WAT_IN,NULL,'b',0.0);
        P_WAT_OUT = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_OUT");
        init_pvar(P_WAT_OUT,NULL,'b',0.0);
        P_WAT_ERR = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_ERR");
        init_pvar(P_WAT_ERR,NULL,'b',0.0);
        P_WAT_ERR_CUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_ERR_CUM");
        init_pvar(P_WAT_ERR_CUM,NULL,'b',0.0);

        P_WAT_IN_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_IN_SUM");
        init_pvar(P_WAT_IN_SUM,NULL,'b',0.0);
        P_WAT_OUT_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_OUT_SUM");
        init_pvar(P_WAT_OUT_SUM,NULL,'b',0.0);
        P_WAT_IN_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_IN_AVG");
        init_pvar(P_WAT_IN_AVG,NULL,'b',0.0);
        P_WAT_OUT_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"P_WAT_OUT_AVG");
        init_pvar(P_WAT_OUT_AVG,NULL,'b',0.0);

/* salt mass bal vars */
        TOT_S_CELL = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_S_CELL");
        init_pvar(TOT_S_CELL,NULL,'b',0.0);
        SALT_ATMOS = (double *) nalloc(sizeof(double)*(numBasn+1),"SALT_ATMOS");
        init_pvar(SALT_ATMOS,NULL,'b',0.0);

        TOT_S = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_S");
        init_pvar(TOT_S,NULL,'b',0.0);
        TOT_S_OLD = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_S_OLD");
        init_pvar(TOT_S_OLD,NULL,'b',0.0);
        S_IN = (double *) nalloc(sizeof(double)*(numBasn+1),"S_IN");
        init_pvar(S_IN,NULL,'b',0.0);
        S_OUT = (double *) nalloc(sizeof(double)*(numBasn+1),"S_OUT");
        init_pvar(S_OUT,NULL,'b',0.0);
        TOT_S_ERR = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_S_ERR");
        init_pvar(TOT_S_ERR,NULL,'b',0.0);
        S_ERR_CUM = (double *) nalloc(sizeof(double)*(numBasn+1),"S_ERR_CUM");
        init_pvar(S_ERR_CUM,NULL,'b',0.0);

        S_IN_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"S_IN_SUM");
        init_pvar(S_IN_SUM,NULL,'b',0.0);
        S_OUT_SUM = (double *) nalloc(sizeof(double)*(numBasn+1),"S_OUT_SUM");
        init_pvar(S_OUT_SUM,NULL,'b',0.0);
        S_IN_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"S_IN_AVG");
        init_pvar(S_IN_AVG,NULL,'b',0.0);
        S_OUT_AVG = (double *) nalloc(sizeof(double)*(numBasn+1),"S_OUT_AVG");
        init_pvar(S_OUT_AVG,NULL,'b',0.0);

        TOT_S_CAN = (double *) nalloc(sizeof(double)*(numBasn+1),"TOT_S_CAN");
        init_pvar(TOT_S_CAN,NULL,'b',0.0);

        S_IN_STR = (double *) nalloc(sizeof(double)*(numBasn+1),"S_IN_STR");
        init_pvar(S_IN_STR,NULL,'b',0.0);
        S_IN_OVL = (double *) nalloc(sizeof(double)*(numBasn+1),"S_IN_OVL");
        init_pvar(S_IN_OVL,NULL,'b',0.0);
        S_IN_SPG = (double *) nalloc(sizeof(double)*(numBasn+1),"S_IN_SPG");
        init_pvar(S_IN_SPG,NULL,'b',0.0);
        S_IN_GW = (double *) nalloc(sizeof(double)*(numBasn+1),"S_IN_GW");
        init_pvar(S_IN_GW,NULL,'b',0.0);

        S_OUT_STR = (double *) nalloc(sizeof(double)*(numBasn+1),"S_OUT_STR");
        init_pvar(S_OUT_STR,NULL,'b',0.0);
        S_OUT_OVL = (double *) nalloc(sizeof(double)*(numBasn+1),"S_OUT_OVL");
        init_pvar(S_OUT_OVL,NULL,'b',0.0);
        S_OUT_SPG = (double *) nalloc(sizeof(double)*(numBasn+1),"S_OUT_SPG");
        init_pvar(S_OUT_SPG,NULL,'b',0.0);
        S_OUT_GW = (double *) nalloc(sizeof(double)*(numBasn+1),"S_OUT_GW");
        init_pvar(S_OUT_GW,NULL,'b',0.0);

/* map arrays with summary stats */
        HydPerAnn = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HydPerAnn");
        init_pvar(HydPerAnn,NULL,'f',0.0);
        SfWatAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SfWatAvg");
        init_pvar(SfWatAvg,NULL,'f',0.0);
        TotHeadAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TotHeadAvg");
        init_pvar(TotHeadAvg,NULL,'f',0.0);
        HydRelDepPosNegAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"HydRelDepPosNegAvg");
        init_pvar(HydRelDepPosNegAvg,NULL,'f',0.0);
        UnsatZavg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UnsatZavg");
        init_pvar(UnsatZavg,NULL,'f',0.0);

        RainAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"RainAvg");
        init_pvar(RainAvg,NULL,'f',0.0);
        ETAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"ETAvg"); 
        init_pvar(ETAvg,NULL,'f',0.0);
        EvapAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"EvapAvg");
        init_pvar(EvapAvg,NULL,'f',0.0);
        TranspAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TranspAvg");
        init_pvar(TranspAvg,NULL,'f',0.0);
        UnsatMoistAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"UnsatMoistAvg");
        init_pvar(UnsatMoistAvg,NULL,'f',0.0);
        /* v2.7.0 addition */
        SF_WT_VEL_magAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SF_WT_VEL_magAvg");
        init_pvar(SF_WT_VEL_magAvg,NULL,'f',0.0);
        /* v2.7.1 addition */
        BCmodel_sfwatAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"BCmodel_sfwatAvg");
        init_pvar(BCmodel_sfwatAvg,NULL,'f',0.0);

        TPSfWatAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPSfWatAvg");
        init_pvar(TPSfWatAvg,NULL,'f',0.0);
        TPSfUptAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPSfUptAvg");
        init_pvar(TPSfUptAvg,NULL,'f',0.0);
        TPSfMinAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPSfMinAvg");
        init_pvar(TPSfMinAvg,NULL,'f',0.0);
        TP_settlAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TP_settlAvg");
        init_pvar(TP_settlAvg,NULL,'f',0.0);
        TPSedWatAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPSedWatAvg");
        init_pvar(TPSedWatAvg,NULL,'f',0.0);
        TPSedUptAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPSedUptAvg");
        init_pvar(TPSedUptAvg,NULL,'f',0.0);
        TPSedMinAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPSedMinAvg");
        init_pvar(TPSedMinAvg,NULL,'f',0.0);
        TPSorbAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPSorbAvg");
        init_pvar(TPSorbAvg,NULL,'f',0.0);
        TPtoVOLAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPtoVOLAvg");
        init_pvar(TPtoVOLAvg,NULL,'f',0.0);
        TPtoSOILAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"TPtoSOILAvg");
        init_pvar(TPtoSOILAvg,NULL,'f',0.0);

        SaltSfAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SaltSfAvg");
        init_pvar(SaltSfAvg,NULL,'f',0.0);
        SaltSedAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SaltSedAvg");
        init_pvar(SaltSedAvg,NULL,'f',0.0);

        Floc_fr_phBioAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Floc_fr_phBioAvg");
        init_pvar(Floc_fr_phBioAvg,NULL,'f',0.0);

        NC_PeriAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_PeriAvg");
        init_pvar(NC_PeriAvg,NULL,'f',0.0);
        NC_Peri_nppAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_Peri_nppAvg");
        init_pvar(NC_Peri_nppAvg,NULL,'f',0.0);
        NC_Peri_mortAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_Peri_mortAvg");
        init_pvar(NC_Peri_mortAvg,NULL,'f',0.0);
        NC_PeriRespAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_PeriRespAvg");
        init_pvar(NC_PeriRespAvg,NULL,'f',0.0);
        NC_PeriNutCFAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_PeriNutCFAvg");
        init_pvar(NC_PeriNutCFAvg,NULL,'f',0.0);
        NC_Peri_PCAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"NC_Peri_PCAvg");
        init_pvar(NC_Peri_PCAvg,NULL,'f',0.0);
        C_PeriAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_PeriAvg");
        init_pvar(C_PeriAvg,NULL,'f',0.0);
        C_Peri_nppAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_Peri_nppAvg");
        init_pvar(C_Peri_nppAvg,NULL,'f',0.0);
        C_Peri_mortAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_Peri_mortAvg");
        init_pvar(C_Peri_mortAvg,NULL,'f',0.0);
        C_PeriRespAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_PeriRespAvg");
        init_pvar(C_PeriRespAvg,NULL,'f',0.0);
        C_PeriNutCFAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_PeriNutCFAvg");
        init_pvar(C_PeriNutCFAvg,NULL,'f',0.0);
        C_Peri_PCAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"C_Peri_PCAvg");
        init_pvar(C_Peri_PCAvg,NULL,'f',0.0);
        PeriAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PeriAvg");
        init_pvar(PeriAvg,NULL,'f',0.0);
        PeriLiteCFAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"PeriLiteCFAvg");
        init_pvar(PeriLiteCFAvg,NULL,'f',0.0);

        Mac_nphBioAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Mac_nphBioAvg");
        init_pvar(Mac_nphBioAvg,NULL,'f',0.0);
        Mac_phBioAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Mac_phBioAvg");
        init_pvar(Mac_phBioAvg,NULL,'f',0.0);
        Mac_totBioAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Mac_totBioAvg");
        init_pvar(Mac_totBioAvg,NULL,'f',0.0);
        Mac_nppAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Mac_nppAvg");
        init_pvar(Mac_nppAvg,NULL,'f',0.0);
        Mac_nphMortAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Mac_nphMortAvg");
        init_pvar(Mac_nphMortAvg,NULL,'f',0.0);
        Mac_phMortAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Mac_phMortAvg");
        init_pvar(Mac_phMortAvg,NULL,'f',0.0);
        LAI_effAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"LAI_effAvg");
        init_pvar(LAI_effAvg,NULL,'f',0.0);
        Manning_nAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"Manning_nAvg");
        init_pvar(Manning_nAvg,NULL,'f',0.0);
        MacNutCfAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MacNutCfAvg");
        init_pvar(MacNutCfAvg,NULL,'f',0.0);
        MacWatCfAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"MacWatCfAvg");
        init_pvar(MacWatCfAvg,NULL,'f',0.0);
        mac_nph_PCAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"mac_nph_PCAvg");
        init_pvar(mac_nph_PCAvg,NULL,'f',0.0);
        mac_ph_PCAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"mac_ph_PCAvg");
        init_pvar(mac_ph_PCAvg,NULL,'f',0.0);

        SedElevAvg = (float *) nalloc(sizeof(float)*(s0+2)*(s1+2),"SedElevAvg");
        init_pvar(SedElevAvg,NULL,'f',0.0);

} /* end of alloc_mem_stats */

Here is the call graph for this function:

void BIRinit

(

void

)

Set up the Basin & Indicator Region (BIR) linkages/inheritances.

Definition at line 1164 of file BudgStats.c.

References basInFile, basins, basn, basn_list, basndef::basnTxt, CELL_SIZE, conv_kgTOmg, conv_mTOcm, basndef::family, basndef::FLok, basndef::IR, modelFileName, modelName, ModelPath, msgStr, numBasn, numCells, basndef::numFLok, basndef::numIR, ON_MAP, basndef::parent, ProjName, s0, s1, Scip(), T, and usrErr().

{
    int ix,iy,cellLoc,ibas;
    int ii, jj, basnID;
    int basnCnt=-1; /* the whole system basin-0 in the basinIR file is not considered part of this count of the number of Basin/IRs */
    char ss[222], *line, modnam[20], boundIR[3];

    sprintf( modelFileName, "%s/%s/Data/basinIR", ModelPath, ProjName );
/* Open file with basin linkage/inheritance data */
    if ( ( basInFile = fopen( modelFileName, "r" ) ) ==  NULL )
    {
        sprintf( msgStr,"Can't open %s basin definition input file! ",modelFileName ) ; usrErr(msgStr);
        exit(-1) ;
    }

    fgets( ss, 220, basInFile );fgets( ss, 220, basInFile ); /* skip 2 header lines */
    fgets( ss, 220, basInFile ); sscanf( ss,"%s", &modnam); 
    if (strcmp(modnam,modelName) != 0) {
        sprintf(msgStr, "The model name (%s) found in the %s file doesn't match the one (%s) you asked for in Driver.parm!",
                modnam, modelFileName, modelName); usrErr(msgStr);
        exit(-1);
    }
        /* Allocate memory for first basin */
    if ( (basins = ( basnDef *) malloc( (size_t) sizeof( basnDef ))) == NULL ) {
        printf( "Failed to allocate memory for first basin (%s)\n ", basins->basnTxt ) ;
        exit( -2 ) ;
    }
        /* allocate memory for array of pointers to basin atts */
    if ( (basn_list = 
          ( basnDef **) malloc( (size_t) sizeof( basnDef *) * (numBasn+1))) == NULL )
    {
        printf( "Failed to allocate memory for basin_list\n " ) ;
        exit( -2 ) ;
    };


    fgets( ss, 220, basInFile ); /* skip the column name header */
    
    while ( fgets( ss, 220, basInFile ) != NULL && !feof( basInFile ) )
    {
        line = ss;
        sscanf (line, "%d\t%s\t%d",&basnID, &basins->basnTxt,&basins->numIR);
        line = Scip( line, '\t' );line = Scip( line, '\t' );line = Scip( line, '\t' );
/* the indicator regions within a hydrologic basin are subscripted starting at 1,
   with the 0'th indicator region being the hydrologic basin itself.  Flok is
   used to check for allowable flows among basins/indicator-regions, to determine if user configured
   BIRs are OK (NOT used to constrain calculated flows, but only used to verify that no unallowed interbasin
   overland flow is occuring via some "leak" in the vector topology) */
        for (ii=0; ii<basins->numIR; ii++) {
            sscanf (line, "%d%", &basins->IR[ii]);
            basins->FLok[ii] = basins->IR[ii]; /* flow is allowed among IRegions in a particular hydro basin (family) */
            basins->numFLok++;
            line = Scip( line, ',' );
        }
        basnCnt++; /* count the number of basins&IRs to check that the # in the file is same as # defined on the map */

/* if there are any FlowOk Basin/Indicator-Region attached to this Basin/Indicator-Region, read them */
        while (1) {
            while ( *line != '#' && *line != '\0' ) line++;
            if(*line != '\0') {
                ++line;
                sscanf (line, "%d%", &basins->FLok[ii]);
                basins->numFLok++;
                ii++;
            }
            else break;
        }

        basn_list[basnID] = basins;
    
            /* Allocate memory for next basin */
        if ( ( basins = ( basnDef *) malloc( (size_t) sizeof(  basnDef ))) == NULL )
        {
            printf( "Failed to allocate memory for next basin (%s)\n ", basins->basnTxt ) ;
            exit( -2 ) ;
        }

     
    } /* end of reading basin lines */
    
    free ((char *)basins);
    fclose(basInFile);

    if (basnCnt != numBasn) { sprintf(msgStr, "Error - the %d basins read from basinIR does not match the %d basins in the basins map! Please fix the basinIR file.\n",
                                      basnCnt,numBasn); usrErr(msgStr); exit (-1); }
 
/* count the number of cells in the Basins/Indicator-Regions */
    for (ibas=numBasn;ibas>=0;ibas--) numCells[ibas] = 0;
    for(ix=0; ix<=s0+1; ix++) 
        for(iy=0; iy<=s1+1; iy++)
            if (ON_MAP[cellLoc= T(ix,iy)]) { 
                numCells[basn[cellLoc]]++; /* count the number of cells in each basin */
                numCells[0]++; /* count the number of cells in each basin */
            }
        /* whole system (basin 0) is calc'd independently, while each of the hydro basins are
           sums of their respective Indicator Regions */
    for (ibas=numBasn;ibas>=0;ibas--) {
        basins =  basn_list[ibas];
        basins->family = ibas; /* set the basin to initially be it's own family; below it may find that it is a child of a diff family */
        basins->parent = ibas; /* set the basin to initially be a childless parent */
        for (ii=0; ii<basins->numIR; ii++) {
        
            basn_list[basins->IR[ii]]->family = ibas; /* the hydrologic basin family name of this IRegion */
            basn_list[basins->IR[ii]]->parent = 0; /* this IR is a child, not a parent */
            numCells[ibas] += numCells[basins->IR[ii]]; /* add the IRegion cells to the parent basin #cells */
        }
        basins->conv_m3TOcm = conv_mTOcm/(numCells[ibas]*CELL_SIZE);
        basins->conv_kgTOmgm2 = conv_kgTOmg/(numCells[ibas]*CELL_SIZE);

    }
} /* end of BIRinit() */

Here is the call graph for this function:

void BIRoutfiles

(

void

)

Open files and create headers for BIR output.

Definition at line 1282 of file BudgStats.c.

References BIRavg1, BIRavg2, BIRavg3, BIRavg4, BIRavg5, BIRhydro, budget_P1, budget_P2, budget_P3, budget_P4, budget_P5, budget_Par1, budget_Par2, budget_Par3, budget_Par4, budget_Par5, budget_Pdead1, budget_Pdead2, budget_Pdead3, budget_Pdead4, budget_Pdead5, budget_Plive1, budget_Plive2, budget_Plive3, budget_Plive4, budget_Plive5, budget_Pwat1, budget_Pwat2, budget_Pwat3, budget_Pwat4, budget_Pwat5, budget_S1, budget_S2, budget_S3, budget_S4, budget_S5, budget_Wacr1, budget_Wacr2, budget_Wacr3, budget_Wacr4, budget_Wacr5, budget_Wcm1, budget_Wcm2, budget_Wcm3, budget_Wcm4, budget_Wcm5, CELL_SIZE, ESPmodeON, Min, modelFileName, modelName, modelVers, numBasn, numCells, OutputPath, ProjName, SimAlt, and SimModif.

{
    int Fnum,Fsets,ibasLow,ibasHigh,ibas;


    
/********/
/* For the budget & BIRavg files, we can have multiple sets of files, with
   >1 sets needed if a large (>12) number of Basins/Indicator-Regions are defined.  First,
   we open the files, then go to write headers for them */

    {/*Open the primary files for all of the budgets & BIRavgs */
    
/* v2.8 hydro Perf Measure summaries - is a first cut, TODO is re-organize it */
        sprintf( modelFileName, "%s/%s/Output/Budget/BIRhydro", OutputPath, ProjName ); 
        if ( ( BIRhydro = fopen( modelFileName, "w" ) ) ==  NULL ) 
        {printf( "Can't open BIRhydro file! " );exit(-1) ;} 

/* Indicator region avgs */
        sprintf( modelFileName, "%s/%s/Output/Budget/BIRavg1", OutputPath, ProjName ); 
        if ( ( BIRavg1 = fopen( modelFileName, "w" ) ) ==  NULL ) 
        {printf( "Can't open BIRavg1 file! " );exit(-1) ;} 
/* water budget/massCheck info - units in acre-feet */
        sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wacr1", OutputPath, ProjName ); 
        if ( ( budget_Wacr1 = fopen( modelFileName, "w" ) ) ==  NULL ) 
        {printf( "Can't open budg_Wacr1 file! " );exit(-1) ;} 
/* water budget/massCheck info - units in cm height */
        sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wcm1", OutputPath, ProjName ); 
        if ( ( budget_Wcm1 = fopen( modelFileName, "w" ) ) ==  NULL ) 
        {printf( "Can't open budg_Wcm1 file! " );exit(-1) ;}
/* Phosph budget/massCheck info for all P fractions (units=Mg) */
        sprintf( modelFileName, "%s/%s/Output/Budget/budg_P1", OutputPath, ProjName ); 
        if ( ( budget_P1 = fopen( modelFileName, "w" ) ) ==  NULL ) 
        {printf( "Can't open budg_P1 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for all P fractions (units=mg/m2) */
        sprintf( modelFileName, "%s/%s/Output/Budget/budg_Par1", OutputPath, ProjName ); 
        if ( ( budget_Par1 = fopen( modelFileName, "w" ) ) ==  NULL ) 
        {printf( "Can't open budg_Par1 file! " );exit(-1) ;} 
/* Salt budget/massCheck info */
        sprintf( modelFileName, "%s/%s/Output/Budget/budg_S1", OutputPath, ProjName ); 
        if ( ( budget_S1 = fopen( modelFileName, "w" ) ) ==  NULL ) 
        {printf( "Can't open budg_S1 file! " );exit(-1) ;} 
        if (!ESPmodeON) {
/* Phosph budget/massCheck info for live P fraction */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pliv1", OutputPath, ProjName ); 
            if ( ( budget_Plive1 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Pliv1 file! " );exit(-1) ;}
/* Phosph budget/massCheck info for dead P fraction */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pded1", OutputPath, ProjName ); 
            if ( ( budget_Pdead1 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Pded1 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for water-borne P fraction */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pwat1", OutputPath, ProjName ); 
            if ( ( budget_Pwat1 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Pwat1 file! " );exit(-1) ;}
        }


        if (numBasn>=13) {
/*Open the secondary files for all of the budgets & BIRavgs if we have more than 12 basins */
/* Indicator region avgs */
            sprintf( modelFileName, "%s/%s/Output/Budget/BIRavg2", OutputPath, ProjName ); 
            if ( ( BIRavg2 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            { printf( "Can't open BIRavg2 file! " ); exit(-1) ;} 
/* water budget/massCheck info - units in acre-feet */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wacr2", OutputPath, ProjName ); 
            if ( ( budget_Wacr2 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            { printf( "Can't open budg_Wacr2 file! " ); exit(-1) ;} 
/* water budget/massCheck info - units in cm height */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wcm2", OutputPath, ProjName ); 
            if ( ( budget_Wcm2 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Wcm2 file! " ); exit(-1) ;} 
/* Phosph budget/massCheck info for all P fractions (units=Mg) */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_P2", OutputPath, ProjName ); 
            if ( ( budget_P2 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_P2 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for all P fractions (units=mg/m2) */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Par2", OutputPath, ProjName ); 
            if ( ( budget_Par2 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Par2 file! " );exit(-1) ;} 
/* Salt budget/massCheck info */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_S2", OutputPath, ProjName ); 
            if ( ( budget_S2 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_S2 file! " );exit(-1) ;} 

            if (!ESPmodeON) {
/* Phosph budget/massCheck info for live P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pliv2", OutputPath, ProjName ); 
                if ( ( budget_Plive2 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pliv2 file! " );exit(-1) ;}
/* Phosph budget/massCheck info for dead P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pded2", OutputPath, ProjName ); 
                if ( ( budget_Pdead2 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pded2 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for water-borne P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pwat2", OutputPath, ProjName ); 
                if ( ( budget_Pwat2 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pwat2 file! " );exit(-1) ;} 
            }/* end of !ESPmodeON */
    
        } /* end of opening secondary files */

        
        if (numBasn>=26) {
/*Open the tertiary files for all of the budgets if we have more than 25 basins */
/* Indicator region avgs */
            sprintf( modelFileName, "%s/%s/Output/Budget/BIRavg3", OutputPath, ProjName ); 
            if ( ( BIRavg3 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            { printf( "Can't open BIRavg3 file! " ); exit(-1) ;} 
/* water budget/massCheck info - units in acre-feet */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wacr3", OutputPath, ProjName ); 
            if ( ( budget_Wacr3 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            { printf( "Can't open budg_Wacr3 file! " ); exit(-1) ;} 
/* water budget/massCheck info - units in cm height */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wcm3", OutputPath, ProjName ); 
            if ( ( budget_Wcm3 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Wcm3 file! " ); exit(-1) ;} 
/* Phosph budget/massCheck info for all P fractions (units=Mg) */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_P3", OutputPath, ProjName ); 
            if ( ( budget_P3 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_P3 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for all P fractions (units=mg/m2) */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Par3", OutputPath, ProjName ); 
            if ( ( budget_Par3 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Par3 file! " );exit(-1) ;} 
/* Salt budget/massCheck info */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_S3", OutputPath, ProjName ); 
            if ( ( budget_S3 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_S3 file! " );exit(-1) ;} 

            if (!ESPmodeON) {
/* Phosph budget/massCheck info for live P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pliv3", OutputPath, ProjName ); 
                if ( ( budget_Plive3 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pliv3 file! " );exit(-1) ;}
/* Phosph budget/massCheck info for dead P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pded3", OutputPath, ProjName ); 
                if ( ( budget_Pdead3 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pded3 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for water-borne P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pwat3", OutputPath, ProjName ); 
                if ( ( budget_Pwat3 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pwat3 file! " );exit(-1) ;} 
            }/* end of !ESPmodeON */
    
        } /* end of opening tertiary files */
        
        if (numBasn>=39) {
/*Open the fourth set of files for all of the budgets if we have more than 38 basins */
/* Indicator region avgs */
            sprintf( modelFileName, "%s/%s/Output/Budget/BIRavg4", OutputPath, ProjName ); 
            if ( ( BIRavg4 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            { printf( "Can't open BIRavg4 file! " ); exit(-1) ;} 
/* water budget/massCheck info - units in acre-feet */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wacr4", OutputPath, ProjName ); 
            if ( ( budget_Wacr4 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            { printf( "Can't open budg_Wacr4 file! " ); exit(-1) ;} 
/* water budget/massCheck info - units in cm height */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wcm4", OutputPath, ProjName ); 
            if ( ( budget_Wcm4 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Wcm4 file! " ); exit(-1) ;} 
/* Phosph budget/massCheck info for all P fractions (units=Mg) */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_P4", OutputPath, ProjName ); 
            if ( ( budget_P4 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_P4 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for all P fractions (units=mg/m2) */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Par4", OutputPath, ProjName ); 
            if ( ( budget_Par4 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Par4 file! " );exit(-1) ;} 
/* Salt budget/massCheck info */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_S4", OutputPath, ProjName ); 
            if ( ( budget_S4 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_S4 file! " );exit(-1) ;} 

            if (!ESPmodeON) {
/* Phosph budget/massCheck info for live P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pliv4", OutputPath, ProjName ); 
                if ( ( budget_Plive4 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pliv4 file! " );exit(-1) ;}
/* Phosph budget/massCheck info for dead P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pded4", OutputPath, ProjName ); 
                if ( ( budget_Pdead4 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pded4 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for water-borne P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pwat4", OutputPath, ProjName ); 
                if ( ( budget_Pwat4 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pwat4 file! " );exit(-1) ;} 
            }/* end of !ESPmodeON */
    
        } /* end of opening fourth set of files */
        
        if (numBasn>=52) {
/*Open the fifth set of files for all of the budgets if we have more than 51 basins */
/* Indicator region avgs */
            sprintf( modelFileName, "%s/%s/Output/Budget/BIRavg5", OutputPath, ProjName ); 
            if ( ( BIRavg5 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            { printf( "Can't open BIRavg5 file! " ); exit(-1) ;} 
/* water budget/massCheck info - units in acre-feet */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wacr5", OutputPath, ProjName ); 
            if ( ( budget_Wacr5 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            { printf( "Can't open budg_Wacr5 file! " ); exit(-1) ;} 
/* water budget/massCheck info - units in cm height */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Wcm5", OutputPath, ProjName ); 
            if ( ( budget_Wcm5 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Wcm5 file! " ); exit(-1) ;} 
/* Phosph budget/massCheck info for all P fractions (units=Mg) */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_P5", OutputPath, ProjName ); 
            if ( ( budget_P5 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_P5 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for all P fractions (units=mg/m2) */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_Par5", OutputPath, ProjName ); 
            if ( ( budget_Par5 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_Par5 file! " );exit(-1) ;} 
/* Salt budget/massCheck info */
            sprintf( modelFileName, "%s/%s/Output/Budget/budg_S5", OutputPath, ProjName ); 
            if ( ( budget_S5 = fopen( modelFileName, "w" ) ) ==  NULL ) 
            {printf( "Can't open budg_S5 file! " );exit(-1) ;} 

            if (!ESPmodeON) {
/* Phosph budget/massCheck info for live P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pliv5", OutputPath, ProjName ); 
                if ( ( budget_Plive5 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pliv5 file! " );exit(-1) ;}
/* Phosph budget/massCheck info for dead P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pded5", OutputPath, ProjName ); 
                if ( ( budget_Pdead5 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pded5 file! " );exit(-1) ;} 
/* Phosph budget/massCheck info for water-borne P fraction */
                sprintf( modelFileName, "%s/%s/Output/Budget/budg_Pwat5", OutputPath, ProjName ); 
                if ( ( budget_Pwat5 = fopen( modelFileName, "w" ) ) ==  NULL ) 
                {printf( "Can't open budg_Pwat5 file! " );exit(-1) ;} 
            }/* end of !ESPmodeON */
    
        } /* end of opening fifth set of files */
        
    } /* end of opening all files */



/********/
/* Now we need to print the headers to each set(s) of basin files */
/* First, figure out the number of files sets, and then loop thru that */
        /* there are 13 total basins printed per file (basin 0 is whole system,
           not counted in numBasn, but always printed out in first file) */
    if (numBasn>=52) { /* with more than 58 (plus whole-system basin == 59) basins: */
        Fsets=5;              /* we have five sets of basin files */
    }
    else if (numBasn>=39) { /* with more than 38 (plus whole-system basin == 39) basins: */
        Fsets=4;              /* we have four sets of basin files */
    }
    else if (numBasn>=26) { /* with more than 25 (plus whole-system basin == 26) basins: */
        Fsets=3;              /* we have three sets of basin files */
    }
    else if (numBasn>=13) { /* with more than 12 (plus whole-system basin == 13) basins: */
        Fsets=2;              /* we have two sets of basin files */
    }
    else {
        Fsets=1;       /* otherwise, just one set of files */
    }

    for (Fnum = 1; Fnum <= Fsets; Fnum++) { 
    
        if (Fnum == 1) { /* first file set */
            if (Fsets > 1) {
                ibasLow = 0;        
                ibasHigh = 12;
            }
            else {
                ibasLow = 0;
                ibasHigh = Min(12,numBasn);
            }
        }

        if (Fnum == 2) { /* second file set */
            if (Fsets > 2) {
                ibasLow = 13;        
                ibasHigh = 25;
            }
            else {
                ibasLow = 13;
                ibasHigh = Min(25,numBasn);
            }
        }

        if (Fnum == 3) { /* third file set */
            if (Fsets > 3) {
                ibasLow = 26;        
                ibasHigh = 38;
            }
            else {
                ibasLow = 26;
                ibasHigh = Min(38,numBasn);
            }
        }
        
        if (Fnum == 4) { /* fourth file set */
            if (Fsets > 4) {
                ibasLow = 39;        
                ibasHigh = 51;
            }
            else {
                ibasLow = 39;
                ibasHigh = Min(51,numBasn);
            }
        }
        

        else if (Fnum == 5) {
            ibasLow = 52;        
            ibasHigh = numBasn;
        }

/*****/
/* now print the 4 header lines for all of the budget & BIRavg files */

/* LINE 1&2: first header line, providing scenario ID; second line is units, etc. */
/* feb05 added two tabs at end of BIRavg header to accomodate sensitivity parm label & value */
        fprintf ( BIRhydro, 
                  "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): daily mean attributes. \nUnits = Stage_minus_LandElev (StgMinElev) == m, Surface_Velocity (BIR_Sf_vel) = m/d, DayFire == days, CLsf_avg == CL conc. in sfwat, g/L.\n          \t ", &modelName, &modelVers, &SimAlt, &SimModif ); 

        fprintf ( ((Fnum==5)?(BIRavg5):
                   ((Fnum==4)?(BIRavg4):
                   ((Fnum==3)?(BIRavg3):
                    ((Fnum==2)?(BIRavg2):
                     (BIRavg1) ) ) ) ), 
                  "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): daily mean attributes. \nUnits = Hydro depths== m, TP surface & pore water==mg/L, TP soil==mg/kg, noncalc&calc periph==gC/m2, mac==kgC/m2, LandElevation= m NGVD/NAVD+DATUM_DISTANCE(usually 6m).\n          \t\t\t ", &modelName, &modelVers, &SimAlt, &SimModif ); 
        fprintf ( ((Fnum==5)?(budget_Wacr5):
                   ((Fnum==4)?(budget_Wacr4):
                   ((Fnum==3)?(budget_Wacr3):
                    ((Fnum==2)?(budget_Wacr2):
                     (budget_Wacr1) ) ) ) ), 
                  "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): water budget and mass balance check. \nUnits = thousands of acre-feet per basin, with error (and cumulative net error) reporting in mm height across basin.\n          \t ", &modelName, &modelVers, &SimAlt, &SimModif ); 
        fprintf ( ((Fnum==5)?(budget_Wcm5):
                   ((Fnum==4)?(budget_Wcm4):
                   ((Fnum==3)?(budget_Wcm3):
                    ((Fnum==2)?(budget_Wcm2):
                     (budget_Wcm1) ) ) ) ), 
                  "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): water budget and mass balance check. \nUnits = cm per basin, with error (and cumulative net error) reporting in mm height across basin.\n          \t ", &modelName, &modelVers, &SimAlt, &SimModif ); 
        fprintf ( ((Fnum==5)?(budget_S5):
                   ((Fnum==4)?(budget_S4):
                   ((Fnum==3)?(budget_S3):
                    ((Fnum==2)?(budget_S2):
                     (budget_S1) ) ) ) ), 
                  "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): conservative tracer budget and mass balance check. \nUnits = metric tons (Mg) per basin, with error (and cumulative net error) reporting in ug/m2 in basin.\n          \t ", &modelName, &modelVers, &SimAlt, &SimModif ); 
        fprintf ( ((Fnum==5)?(budget_P5):
                   ((Fnum==4)?(budget_P4):
                   ((Fnum==3)?(budget_P3):
                    ((Fnum==2)?(budget_P2):
                     (budget_P1) ) ) ) ), 
                  "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): Total P budget and mass balance check for all fractions. \nUnits = metric tons (Mg) per basin, with error (and cumulative net error) reporting in ug/m2 in basin.\n          \t ", &modelName, &modelVers, &SimAlt, &SimModif ); 
        fprintf ( ((Fnum==5)?(budget_Par5):
                   ((Fnum==4)?(budget_Par4):
                   ((Fnum==3)?(budget_Par3):
                    ((Fnum==2)?(budget_Par2):
                     (budget_Par1) ) ) ) ), 
                  "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): Total P budget and mass balance check for all fractions. \nUnits = mg/m2 in basin, with error (and cumulative net error) reporting in ug/m2 in basin.\n          \t ", &modelName, &modelVers, &SimAlt, &SimModif ); 
        if (!ESPmodeON) {

            fprintf ( ((Fnum==5)?(budget_Plive5):
                       ((Fnum==4)?(budget_Plive4):
                       ((Fnum==3)?(budget_Plive3):
                        ((Fnum==2)?(budget_Plive2):
                         (budget_Plive1) ) ) ) ), 
                      "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): Total P budget and mass balance check for live fraction. \nUnits =  mg/m2 in basin, with error (and cumulative net error) ug/m2.\n          \t ", &modelName, &modelVers, &SimAlt, &SimModif ); 
            fprintf ( ((Fnum==5)?(budget_Pdead5):
                       ((Fnum==4)?(budget_Pdead4):
                       ((Fnum==3)?(budget_Pdead3):
                        ((Fnum==2)?(budget_Pdead2):
                         (budget_Pdead1) ) ) ) ), 
                      "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): Total P budget and mass balance check for dead, non-water-borne fraction. \nUnits =  mg/m2 in basin, with error (and cumulative net error) ug/m2.\n          \t ", &modelName, &modelVers, &SimAlt, &SimModif ); 
            fprintf ( ((Fnum==5)?(budget_Pwat5):
                       ((Fnum==4)?(budget_Pwat4):
                       ((Fnum==3)?(budget_Pwat3):
                        ((Fnum==2)?(budget_Pwat2):
                         (budget_Pwat1) ) ) ) ), 
                      "%s %s %s %s scenario: Basins/Indicator-Regions (BIR): Total P budget and mass balance check for water-borne fraction (some horiz I/O not shown - see budget for all combined fractions). \nUnits =  mg/m2 in basin, with error (and cumulative net error) ug/m2.\n          \t ", &modelName, &modelVers, &SimAlt, &SimModif ); 
        }

/* LINE 3: third header line, looping thru basins, providing basin ID and size */
        for (ibas = ibasHigh; ibas >= ibasLow; ibas--) 
        {
        /* v2.8 hydro Perf Measure summaries - is a first cut, TODO is re-organize it */
        fprintf ( BIRhydro, 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t",
                      ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) ); 

        fprintf ( ((Fnum==5)?(BIRavg5):
                  ((Fnum==4)?(BIRavg4):
                   ((Fnum==3)?(BIRavg3):
                    ((Fnum==2)?(BIRavg2):
                     (BIRavg1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t",
                      ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) ); 
        fprintf ( ((Fnum==5)?(budget_Wacr5):
                   ((Fnum==4)?(budget_Wacr4):
                   ((Fnum==3)?(budget_Wacr3):
                    ((Fnum==2)?(budget_Wacr2):
                     (budget_Wacr1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t",
                      ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) ); 
        fprintf ( ((Fnum==5)?(budget_Wcm5):
                   ((Fnum==4)?(budget_Wcm4):
                   ((Fnum==3)?(budget_Wcm3):
                    ((Fnum==2)?(budget_Wcm2):
                     (budget_Wcm1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t",
                      ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) ); 
        fprintf ( ((Fnum==5)?(budget_S5):
                   ((Fnum==4)?(budget_S4):
                   ((Fnum==3)?(budget_S3):
                    ((Fnum==2)?(budget_S2):
                     (budget_S1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t",
                      ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) ); 
            if (!ESPmodeON) {
                fprintf ( ((Fnum==5)?(budget_P5):
                          ((Fnum==4)?(budget_P4):
                           ((Fnum==3)?(budget_P3):
                            ((Fnum==2)?(budget_P2):
                             (budget_P1) ) ) ) ), 
                          "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t",
                          ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) );
                fprintf ( ((Fnum==5)?(budget_Par5):
                           ((Fnum==4)?(budget_Par4):
                           ((Fnum==3)?(budget_Par3):
                            ((Fnum==2)?(budget_Par2):
                             (budget_Par1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t",
                          ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) );
                fprintf ( ((Fnum==5)?(budget_Plive5):
                           ((Fnum==4)?(budget_Plive4):
                            ((Fnum==3)?(budget_Plive3):
                             ((Fnum==2)?(budget_Plive2):
                              (budget_Plive1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t",
                          ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) ); 
                fprintf ( ((Fnum==5)?(budget_Pdead5):
                           ((Fnum==4)?(budget_Pdead4):
                            ((Fnum==3)?(budget_Pdead3):
                             ((Fnum==2)?(budget_Pdead2):
                              (budget_Pdead1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t          \t        \t         \t         \t         \t         \t         \t         \t         \t",
                          ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) ); 
                fprintf ( ((Fnum==5)?(budget_Pwat5):
                           ((Fnum==4)?(budget_Pwat4):
                            ((Fnum==3)?(budget_Pwat3):
                             ((Fnum==2)?(budget_Pwat2):
                              (budget_Pwat1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t",
                          ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) ); 
            }
    
            else {
                fprintf ( ((Fnum==5)?(budget_P5):
                           ((Fnum==4)?(budget_P4):
                           ((Fnum==3)?(budget_P3):
                            ((Fnum==2)?(budget_P2):
                             (budget_P1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t",
                          ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) );
                fprintf ( ((Fnum==5)?(budget_Par5):
                           ((Fnum==4)?(budget_Par4):
                           ((Fnum==3)?(budget_Par3):
                            ((Fnum==2)?(budget_Par2):
                             (budget_Par1) ) ) ) ), 
                      "  BIR %2d =\t%6.1fmi^2,\t%6.1fkm^2\t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t         \t",
                          ibas,(numCells[ibas]*CELL_SIZE*3.8610039e-7),(numCells[ibas]*CELL_SIZE*1.0e-6) );
            }
        } /*end of loop for second header line */

/* LINE 4: beginning of fourth header line */
/* feb05 added two tabs prior to "Date" of BIRavg header to accomodate sensitivity parm label & value */
        fprintf ( BIRhydro, "\nDate\t" ); 

        fprintf ( ((Fnum==5)?(BIRavg5):
                   ((Fnum==4)?(BIRavg4):
                   ((Fnum==3)?(BIRavg3):
                    ((Fnum==2)?(BIRavg2):
                     (BIRavg1) ) ) ) ), "\nSParm\tSParmValu\t    Date\t" ); 
        fprintf ( ((Fnum==5)?(budget_Wacr5):
                   ((Fnum==4)?(budget_Wacr4):
                   ((Fnum==3)?(budget_Wacr3):
                    ((Fnum==2)?(budget_Wacr2):
                     (budget_Wacr1) ) ) ) ), "\n    Date\t" ); 
        fprintf ( ((Fnum==5)?(budget_Wcm5):
                   ((Fnum==4)?(budget_Wcm4):
                   ((Fnum==3)?(budget_Wcm3):
                    ((Fnum==2)?(budget_Wcm2):
                     (budget_Wcm1) ) ) ) ), "\n    Date\t" ); 
        fprintf ( ((Fnum==5)?(budget_S5):
                   ((Fnum==4)?(budget_S4):
                   ((Fnum==3)?(budget_S3):
                    ((Fnum==2)?(budget_S2):
                     (budget_S1) ) ) ) ), "\n    Date\t" ); 
        fprintf ( ((Fnum==5)?(budget_P5):
                   ((Fnum==4)?(budget_P4):
                   ((Fnum==3)?(budget_P3):
                    ((Fnum==2)?(budget_P2):
                     (budget_P1) ) ) ) ), "\n    Date\t" ); 
        fprintf ( ((Fnum==5)?(budget_Par5):
                   ((Fnum==4)?(budget_Par4):
                   ((Fnum==3)?(budget_Par3):
                    ((Fnum==2)?(budget_Par2):
                     (budget_Par1) ) ) ) ), "\n    Date\t" ); 
        if (!ESPmodeON) {
            fprintf ( ((Fnum==5)?(budget_Plive5):
                       ((Fnum==4)?(budget_Plive4):
                       ((Fnum==3)?(budget_Plive3):
                        ((Fnum==2)?(budget_Plive2):
                         (budget_Plive1) ) ) ) ), "\n    Date\t" ); 
            fprintf ( ((Fnum==5)?(budget_Pdead5):
                       ((Fnum==4)?(budget_Pdead4):
                       ((Fnum==3)?(budget_Pdead3):
                        ((Fnum==2)?(budget_Pdead2):
                         (budget_Pdead1) ) ) ) ), "\n    Date\t" ); 
            fprintf ( ((Fnum==5)?(budget_Pwat5):
                       ((Fnum==4)?(budget_Pwat4):
                       ((Fnum==3)?(budget_Pwat3):
                        ((Fnum==2)?(budget_Pwat2):
                         (budget_Pwat1) ) ) ) ), "\n    Date\t" ); 
        }

/* LINE 4: remainder of fourth header line, looping thru basins, providing column/variable ID attributes */
        for (ibas = ibasHigh; ibas >= ibasLow; ibas--) 
        {
        
        fprintf ( BIRhydro, 
                      "   StgMinElev_%d\t   Veloc_%d\t    DayFire_%d\t    CLsf_avg_%d\t",
                      ibas,ibas,ibas,ibas); 

        fprintf ( ((Fnum==5)?(BIRavg5):
                  ((Fnum==4)?(BIRavg4):
                   ((Fnum==3)?(BIRavg3):
                    ((Fnum==2)?(BIRavg2):
                     (BIRavg1) ) ) ) ), 
                      "   SfWat_%d\t   Unsat_%d\t    TPsf_%d\t  TPpore_%d\t  TPsoil_%d\t  NCperi_%d\t   Cperi_%d\t     Mac_%d\t    Elev_%d\t",
                      ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas); 
        fprintf ( ((Fnum==5)?(budget_Wacr5):
                   ((Fnum==4)?(budget_Wacr4):
                   ((Fnum==3)?(budget_Wacr3):
                    ((Fnum==2)?(budget_Wacr2):
                     (budget_Wacr1) ) ) ) ), 
                      "  VolOld_%d\t    Atmos_%d\t    Evap_%d\t  Transp_%d\t    Rchg_%d\t   StrIn_%d\t  StrOut_%d\t   OvlIn_%d\t  OvlOut_%d\t   SpgIn_%d\t  SpgOut_%d\t    GWin_%d\t   GWout_%d\t VolTarg_%d\t  VolNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                      ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas); 
        fprintf ( ((Fnum==5)?(budget_Wcm5):
                   ((Fnum==4)?(budget_Wcm4):
                   ((Fnum==3)?(budget_Wcm3):
                    ((Fnum==2)?(budget_Wcm2):
                     (budget_Wcm1) ) ) ) ), 
                      "  VolOld_%d\t    Atmos_%d\t    Evap_%d\t  Transp_%d\t    Rchg_%d\t   StrIn_%d\t  StrOut_%d\t   OvlIn_%d\t  OvlOut_%d\t   SpgIn_%d\t  SpgOut_%d\t    GWin_%d\t   GWout_%d\t VolTarg_%d\t  VolNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                      ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas); 
        fprintf ( ((Fnum==5)?(budget_S5):
                   ((Fnum==4)?(budget_S4):
                   ((Fnum==3)?(budget_S3):
                    ((Fnum==2)?(budget_S2):
                     (budget_S1) ) ) ) ), 
                      "  MasOld_%d\t    Atmos_%d\t   StrIn_%d\t  StrOut_%d\t   OvlIn_%d\t  OvlOut_%d\t   SpgIn_%d\t  SpgOut_%d\t    GWin_%d\t   GWout_%d\t MasTarg_%d\t  MasNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                      ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas); 
            if (!ESPmodeON) {
                fprintf ( ((Fnum==5)?(budget_P5):
                          ((Fnum==4)?(budget_P4):
                           ((Fnum==3)?(budget_P3):
                            ((Fnum==2)?(budget_P2):
                             (budget_P1) ) ) ) ), 
                      "  MasOld_%d\t    Atmos_%d\t   StrIn_%d\t  StrOut_%d\t   OvlIn_%d\t  OvlOut_%d\t   SpgIn_%d\t  SpgOut_%d\t    GWin_%d\t   GWout_%d\t MasTarg_%d\t  MasNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                          ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas);
                fprintf ( ((Fnum==5)?(budget_Par5):
                           ((Fnum==4)?(budget_Par4):
                           ((Fnum==3)?(budget_Par3):
                            ((Fnum==2)?(budget_Par2):
                             (budget_Par1) ) ) ) ), 
                      "  MasOld_%d\t    Atmos_%d\t   StrIn_%d\t  StrOut_%d\t   OvlIn_%d\t  OvlOut_%d\t   SpgIn_%d\t  SpgOut_%d\t    GWin_%d\t   GWout_%d\t MasTarg_%d\t  MasNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                          ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas);
                fprintf ( ((Fnum==5)?(budget_Plive5):
                           ((Fnum==4)?(budget_Plive4):
                            ((Fnum==3)?(budget_Plive3):
                             ((Fnum==2)?(budget_Plive2):
                              (budget_Plive1) ) ) ) ), 
                      "  MacBio_%d\t CPerBio_%d\t NCPerBio_%d\t  MacNPP_%d\t CPerGPP_%d\tNCPerGPP_%d\t MacMort_%d\t CalgMort_%d\t NCalgMort_%d\t MasTarg_%d\t  MasNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                          ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas); 
                fprintf ( ((Fnum==5)?(budget_Pdead5):
                           ((Fnum==4)?(budget_Pdead4):
                            ((Fnum==3)?(budget_Pdead3):
                             ((Fnum==2)?(budget_Pdead2):
                              (budget_Pdead1) ) ) ) ), 
                      "  MasOld_%d\tMac-soil_%d\tPer-soil_%d\t Decomp_%d\tSettl_to_%d\t Sorb_to_%d\t  Desorb_%d\t MasTarg_%d\t  MasNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                          ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas); 
                fprintf ( ((Fnum==5)?(budget_Pwat5):
                           ((Fnum==4)?(budget_Pwat4):
                            ((Fnum==3)?(budget_Pwat3):
                             ((Fnum==2)?(budget_Pwat2):
                              (budget_Pwat1) ) ) ) ), 
                      "  MasOld_%d\t  Atmos_%d\tSettl_fr_%d\t SfMiner_%d\tSedMiner_%d\t  AlgUpt_%d\t  MacUpt_%d\t  DeSorb_%d\t Sorb_to_%d\t   StrIn_%d\t  StrOut_%d\t MasTarg_%d\t  MasNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                          ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas); 
            }
            else {
                fprintf ( ((Fnum==5)?(budget_P5):
                           ((Fnum==4)?(budget_P4):
                           ((Fnum==3)?(budget_P3):
                            ((Fnum==2)?(budget_P2):
                             (budget_P1) ) ) ) ), 
                      "  MasOld_%d\t    Atmos_%d\t   Settl_%d\t   StrIn_%d\t  StrOut_%d\t   OvlIn_%d\t  OvlOut_%d\t   SpgIn_%d\t  SpgOut_%d\t    GWin_%d\t   GWout_%d\t MasTarg_%d\t  MasNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                          ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas);
                fprintf ( ((Fnum==5)?(budget_Par5):
                           ((Fnum==4)?(budget_Par4):
                           ((Fnum==3)?(budget_Par3):
                            ((Fnum==2)?(budget_Par2):
                             (budget_Par1) ) ) ) ), 
                      "  MasOld_%d\t    Atmos_%d\t   Settl_%d\t   StrIn_%d\t  StrOut_%d\t   OvlIn_%d\t  OvlOut_%d\t   SpgIn_%d\t  SpgOut_%d\t    GWin_%d\t   GWout_%d\t MasTarg_%d\t  MasNew_%d\t     Err_%d\t  SumErr_%d\t   InAvg_%d\t  OutAvg_%d\t",
                          ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas,ibas);
            }
        } /* end of loop for third header line */

    } /*end of printing all files' headers */

        
} /* end of BIRoutfiles */

void BIRstats_reset

(

void

)

Reset BIR (non-budget) statistics summations to zero.

Parameters:

ibas

Basin/Indicator-Region ID number

Definition at line 1028 of file BudgStats.c.

References BIRavg1, BIRavg2, BIRavg3, BIRavg4, BIRavg5, Cperi_avg, Elev_avg, Mac_avg, NCperi_avg, numBasn, Sfwat_avg, TPpore_avg, TPsf_avg, TPsoil_avg, and Unsat_avg.

{
    int ibas;
    
        for (ibas = numBasn; ibas >= 0; ibas--) {
            Sfwat_avg[ibas]=Unsat_avg[ibas]=TPsf_avg[ibas]=TPpore_avg[ibas]=TPsoil_avg[ibas]=
                NCperi_avg[ibas]=Cperi_avg[ibas]=Mac_avg[ibas]=Elev_avg[ibas]=0.0;
        }
        fflush (BIRavg1); 
        if (numBasn>=13) fflush (BIRavg2);
        if (numBasn>=26) fflush (BIRavg3); 
        if (numBasn>=39) fflush (BIRavg4); 
        if (numBasn>=52) fflush (BIRavg5); 

}

void BIRbudg_reset

(

void

)

Reset BIR budget summations to zero.

For ALL budgets, store the old total volume in array TOT_xxx_OLD and reset any summations and BIRavgs to 0.

Parameters:

ibas

Basin/Indicator-Region ID number

Definition at line 1066 of file BudgStats.c.

References budget_P1, budget_P2, budget_P3, budget_P4, budget_P5, budget_Par1, budget_Par2, budget_Par3, budget_Par4, budget_Par5, budget_Pdead1, budget_Pdead2, budget_Pdead3, budget_Pdead4, budget_Pdead5, budget_Plive1, budget_Plive2, budget_Plive3, budget_Plive4, budget_Plive5, budget_Pwat1, budget_Pwat2, budget_Pwat3, budget_Pwat4, budget_Pwat5, budget_S1, budget_S2, budget_S3, budget_S4, budget_S5, budget_Wacr1, budget_Wacr2, budget_Wacr3, budget_Wacr4, budget_Wacr5, budget_Wcm1, budget_Wcm2, budget_Wcm3, budget_Wcm4, budget_Wcm5, Calg_GPP, Calg_mort, dop_decomp, dop_desorb, dop_macIn, dop_sorbIn, ESPmodeON, EVAP, floc_decomp, floc_In, mac_mort, mac_NPP, NCalg_GPP, NCalg_mort, numBasn, P, P_ATMOS, P_Calg, P_CELL, P_DEAD, P_DEAD_CELL, P_DEAD_OLD, P_IN_GW, P_IN_OVL, P_IN_SPG, P_IN_STR, P_LIVE, P_LIVE_CELL, P_LIVE_OLD, P_MAC, P_NCalg, P_OLD, P_OUT_GW, P_OUT_OVL, P_OUT_SPG, P_OUT_STR, P_settl, P_WAT, P_WAT_CELL, P_WAT_OLD, RAIN, RCHG, S_IN_GW, S_IN_OVL, S_IN_SPG, S_IN_STR, S_OUT_GW, S_OUT_OVL, S_OUT_SPG, S_OUT_STR, SALT_ATMOS, SUMGW, SUMSF, SUMUW, TOT_P_CAN, TOT_S, TOT_S_CAN, TOT_S_CELL, TOT_S_OLD, TOT_VOL, TOT_VOL_CAN, TOT_VOL_OLD, TRANSP, VOL_IN_GW, VOL_IN_OVL, VOL_IN_SPG, VOL_IN_STR, VOL_OUT_GW, VOL_OUT_OVL, VOL_OUT_SPG, VOL_OUT_STR, wat_sedMiner, wat_sedUpt, wat_sfMiner, and wat_sfUpt.

{
    int ibas;
    
        for (ibas = numBasn; ibas >= 0; ibas--) {
            TOT_VOL_OLD[ibas] = TOT_VOL[ibas]; 
            TOT_S_OLD[ibas] = TOT_S[ibas]; 
            P_OLD[ibas] = P[ibas]; 
            if (!ESPmodeON) {
                P_LIVE_OLD[ibas] = P_LIVE[ibas]; 
                P_DEAD_OLD[ibas] = P_DEAD[ibas]; 
                P_WAT_OLD[ibas] = P_WAT[ibas];
            }
         
            SUMSF[ibas] = SUMGW[ibas] = SUMUW[ibas] = TOT_VOL[ibas] = TOT_VOL_CAN[ibas] =  0.0;
            RAIN[ibas] = VOL_IN_STR[ibas] = VOL_IN_OVL[ibas] = VOL_IN_SPG[ibas] = VOL_IN_GW[ibas] =  0.0;
            EVAP[ibas] = TRANSP[ibas] = RCHG[ibas] = VOL_OUT_STR[ibas] = VOL_OUT_OVL[ibas] = VOL_OUT_SPG[ibas] = VOL_OUT_GW[ibas] =  0.0;

            TOT_S[ibas] = TOT_S_CELL[ibas] = TOT_S_CAN[ibas] =  0.0;
            SALT_ATMOS[ibas] = S_IN_STR[ibas] = S_IN_OVL[ibas] = S_IN_SPG[ibas] = S_IN_GW[ibas] =  0.0;
            S_OUT_STR[ibas] = S_OUT_OVL[ibas] = S_OUT_SPG[ibas] = S_OUT_GW[ibas] =  0.0;

            P[ibas] = P_CELL[ibas] = TOT_P_CAN[ibas] =  0.0;
            P_ATMOS[ibas] = P_IN_STR[ibas] = P_IN_OVL[ibas] = P_IN_SPG[ibas] = P_IN_GW[ibas] =  0.0;
            P_OUT_STR[ibas] = P_OUT_OVL[ibas] = P_OUT_SPG[ibas] = P_OUT_GW[ibas] =  0.0;

            P_LIVE[ibas] = P_LIVE_CELL[ibas] = P_MAC[ibas] = P_Calg[ibas] = P_NCalg[ibas] = 0.0;
            Calg_GPP[ibas] = NCalg_GPP[ibas] = Calg_mort[ibas] = NCalg_mort[ibas] = 0.0;
            mac_NPP[ibas] = mac_mort[ibas] = 0.0;

            P_DEAD[ibas] = P_DEAD_CELL[ibas] = 0.0;
            dop_macIn[ibas] =  dop_sorbIn[ibas] = floc_In[ibas] = 0.0;
            dop_decomp[ibas] = dop_desorb[ibas] = floc_decomp[ibas] = 0.0;

            P_WAT[ibas] = P_WAT_CELL[ibas] = 0.0;
            wat_sfMiner[ibas] = wat_sedMiner[ibas] = wat_sfUpt[ibas] = wat_sedUpt[ibas] =  P_settl[ibas] = 0.0;

            
        }


        fflush (budget_Wacr1); 
        if (numBasn>=13) fflush (budget_Wacr2);
        if (numBasn>=26) fflush (budget_Wacr3); 
        if (numBasn>=39) fflush (budget_Wacr4); 
        if (numBasn>=52) fflush (budget_Wacr5); 

        fflush (budget_Wcm1); 
        if (numBasn>=13) fflush (budget_Wcm2); 
        if (numBasn>=26) fflush (budget_Wcm3); 
        if (numBasn>=39) fflush (budget_Wcm4); 
        if (numBasn>=52) fflush (budget_Wcm5); 

        fflush (budget_S1); 
        if (numBasn>=13) fflush (budget_S2); 
        if (numBasn>=26) fflush (budget_S3); 
        if (numBasn>=39) fflush (budget_S4); 
        if (numBasn>=52) fflush (budget_S5); 

        fflush (budget_P1); 
        if (numBasn>=13) fflush (budget_P2); 
        if (numBasn>=26) fflush (budget_P3); 
        if (numBasn>=39) fflush (budget_P4); 
        if (numBasn>=52) fflush (budget_P5); 

        fflush (budget_Par1); 
        if (numBasn>=13) fflush (budget_Par2); 
        if (numBasn>=26) fflush (budget_Par3); 
        if (numBasn>=39) fflush (budget_Par4); 
        if (numBasn>=52) fflush (budget_Par5); 

        if (!ESPmodeON) { 
            fflush (budget_Plive1);  
            if (numBasn>=13) fflush (budget_Plive2);  
            if (numBasn>=26) fflush (budget_Plive3); 
            if (numBasn>=39) fflush (budget_Plive4); 
            if (numBasn>=52) fflush (budget_Plive5); 

            fflush (budget_Pdead1);  
            if (numBasn>=13) fflush (budget_Pdead2);  
            if (numBasn>=26) fflush (budget_Pdead3); 
            if (numBasn>=39) fflush (budget_Pdead4); 
            if (numBasn>=52) fflush (budget_Pdead5); 

            fflush (budget_Pwat1);  
            if (numBasn>=13) fflush (budget_Pwat2);  
            if (numBasn>=26) fflush (budget_Pwat3); 
            if (numBasn>=39) fflush (budget_Pwat4); 
            if (numBasn>=52) fflush (budget_Pwat5); 
        } 
} /* end of BIRbudg_reset() */

void Cell_reset_avg

(

void

)

Zero the arrays holding selected variable averages in cells (after printing)/.

Definition at line 2065 of file BudgStats.c.

References BCmodel_sfwatAvg, C_Peri_mortAvg, C_Peri_nppAvg, C_Peri_PCAvg, C_PeriAvg, C_PeriNutCFAvg, C_PeriRespAvg, ETAvg, EvapAvg, Floc_fr_phBioAvg, HydRelDepPosNegAvg, LAI_effAvg, mac_nph_PCAvg, Mac_nphBioAvg, Mac_nphMortAvg, Mac_nppAvg, mac_ph_PCAvg, Mac_phBioAvg, Mac_phMortAvg, Mac_totBioAvg, MacNutCfAvg, MacWatCfAvg, Manning_nAvg, NC_Peri_mortAvg, NC_Peri_nppAvg, NC_PeriAvg, NC_PeriNutCFAvg, NC_PeriRespAvg, ON_MAP, PeriAvg, PeriLiteCFAvg, RainAvg, s0, s1, SaltSedAvg, SaltSfAvg, SedElevAvg, SF_WT_VEL_magAvg, SfWatAvg, T, TotHeadAvg, TP_settlAvg, TPSedMinAvg, TPSedUptAvg, TPSedWatAvg, TPSfMinAvg, TPSfUptAvg, TPSfWatAvg, TPSorbAvg, TPtoSOILAvg, TPtoVOLAvg, TranspAvg, UnsatMoistAvg, and UnsatZavg.

{
    int ix, iy, cellLoc; 

    for(ix=1; ix<=s0; ix++) 
        for(iy=1; iy<=s1; iy++) 
            if(ON_MAP[cellLoc= T(ix,iy)]) {
                TotHeadAvg[cellLoc] = 0.0;
                HydRelDepPosNegAvg[cellLoc] = 0.0;
                SfWatAvg[cellLoc] = 0.0;
                UnsatZavg[cellLoc] = 0.0;
                UnsatMoistAvg[cellLoc] = 0.0;
                RainAvg[cellLoc] = 0.0;
                EvapAvg[cellLoc] = 0.0;
                TranspAvg[cellLoc] = 0.0;
                ETAvg[cellLoc] = 0.0;
                SF_WT_VEL_magAvg[cellLoc] = 0.0;
                BCmodel_sfwatAvg[cellLoc] = 0.0;

                TPSfWatAvg[cellLoc] = 0.0;
                TPSfUptAvg[cellLoc] = 0.0;
                TPSfMinAvg[cellLoc] = 0.0;
                TP_settlAvg[cellLoc] = 0.0;
                TPSedWatAvg[cellLoc] = 0.0;
                TPSedUptAvg[cellLoc] = 0.0;
                TPSedMinAvg[cellLoc] = 0.0;
                TPSorbAvg[cellLoc] = 0.0;
                TPtoVOLAvg[cellLoc] = 0.0;
                TPtoSOILAvg[cellLoc] = 0.0;

                SaltSfAvg[cellLoc] = 0.0;
                SaltSedAvg[cellLoc] = 0.0;

                Floc_fr_phBioAvg[cellLoc]  = 0.0;

                NC_PeriAvg[cellLoc] = 0.0;
                NC_Peri_nppAvg[cellLoc] = 0.0;
                NC_Peri_mortAvg[cellLoc] = 0.0;
                NC_PeriRespAvg[cellLoc] = 0.0;
                NC_PeriNutCFAvg[cellLoc] = 0.0;
                C_Peri_PCAvg[cellLoc] = 0.0;
                C_PeriAvg[cellLoc] = 0.0;
                C_Peri_nppAvg[cellLoc] = 0.0;
                C_Peri_mortAvg[cellLoc] = 0.0;
                C_PeriRespAvg[cellLoc] = 0.0;
                C_PeriNutCFAvg[cellLoc] = 0.0;
                C_Peri_PCAvg[cellLoc] = 0.0;
                PeriAvg[cellLoc] = 0.0;
                PeriLiteCFAvg[cellLoc] = 0.0;

                Mac_nphBioAvg[cellLoc]  = 0.0;
                Mac_phBioAvg[cellLoc]  = 0.0;
                Mac_totBioAvg[cellLoc]  = 0.0;
                Mac_nppAvg[cellLoc]  = 0.0;
                Mac_nphMortAvg[cellLoc]  = 0.0;
                Mac_phMortAvg[cellLoc]  = 0.0;
                LAI_effAvg[cellLoc]  = 0.0;
                Manning_nAvg[cellLoc]  = 0.0;
                MacNutCfAvg[cellLoc]  = 0.0;
                MacWatCfAvg[cellLoc]  = 0.0;
                mac_nph_PCAvg[cellLoc]  = 0.0;
                mac_ph_PCAvg[cellLoc]  = 0.0;

                SedElevAvg[cellLoc]  = 0.0;
            }   
} /* end of Cell_reset_avg() */

void Cell_reset_hydper

(

void

)

Zero the array holding hydroperiod data in cells (after printing).

Definition at line 2050 of file BudgStats.c.

References HydPerAnn, ON_MAP, s0, s1, and T.

{
    int ix, iy, cellLoc; 

        for(ix=1; ix<=s0; ix++) 
            for(iy=1; iy<=s1; iy++) 
                if(ON_MAP[cellLoc= T(ix,iy)]) {
                    HydPerAnn[cellLoc] = 0.0;
                }
} 

void Flux_SWater	(	int	it,
		float *	SURFACE_WAT,
		float *	SED_ELEV,
		float *	HYD_MANNINGS_N,
		double *	STUF1,
		double *	STUF2,
		double *	STUF3,
		float *	SfWat_vel_day
	)

Surface water horizontal flux.

This is the alternating direction function that first fluxes water in the E/W direction and then in the N/S direction. It sweeps from left to right, then goes back from right to left, then goes from top to bottom and finally from bottom to top. This alternates every hyd_iter.

Surface water model boundary exchanges may only occur across cells designated with designated attribute in the boundary condition map file.

The surface water variable is actually updated in the Flux_SWstuff function

Parameters:

	it	Horizontal iteration number
	SURFACE_WAT	SURFACE_WAT
	SED_ELEV	SED_ELEV
	HYD_MANNINGS_N	HYD_MANNINGS_N
	STUF1	SALT_SURF_WT
	STUF2	DINdummy
	STUF3	TP_SF_WT
	SfWat_vel_day	SF_WT_VEL_mag

Remarks:

Surface water flow - levee interaction rules:
ON_MAP value: if running managed canal network, ON_MAP is modified in WatMgmt.c, beyond just in/out (true/false) of model active domain, to these values (expressed in integer format):

• 0 Not in model active domain
• 1 Allow flow in no direction
• 2 Allow flow to east<->west
• 3 Allow flow to south<->north
• 4 Allow flow in all directions

ON_MAP values in cases of cells interacting with water control structure interactions:

• 101 water control structure interaction (allow no flow)
• 102 water control structure interaction (allow flow to east<->west)
• 103 water control structure interaction (allow flow to south<->north)
• 104 water control structure interaction (allow all flow)

• 201 water control structure interaction (allow no flow)
• 202 water control structure interaction (allow flow to east<->west)
• 203 water control structure interaction (allow flow to south<->north)
• 204 water control structure interaction (allow all flow) etc.
  

The results of basic bitwise operations shown here (for those of us who don't routinely work in this mode):

• (ON_MAP) (ON_MAP-1) (ON_MAP-1)&1 (ON_MAP-1)&2
• \000 -1 1 2
• \001 0 0 0
• \002 1 1 0
• \003 2 0 2
• \004 3 1 2

Boundary condition flow allowances (read from BoundCond.BIN input map, values all within "ON_MAP" model domain):

• Value of (integer) BCondFlow:
• 1 Allow no flows external to model domain
• 3 Allow surface- and ground- water flows to/from external boundary cells
• 4 Allow groundwater (but not surface) flows to/from external boundary cells
• (9) Archaic, will remove (allowing groundwater flows, with static external stage conditions)

Variables local to function

ix, iy Model grid cell row, column, respectively
FFlux Water flux (m) between grid cells

Definition at line 121 of file Fluxes.c.

References BCondFlow, Flux_SWcells(), Flux_SWstuff(), ON_MAP, s0, s1, and T.

{ 
int ix, iy;
  float FFlux;


  
  /* check the donor and recipients cells for a) on-map, b) the cell attribute that allows sfwater
     boundary flow from the system and c) the attribute that indicates levee presence:
     the levee attribute of 1 (bitwise) allows flow to east;
     attribute of 2 (bitwise) allows flow to south (levee atts calc'd by WatMgmt.c) 
   */

  /* as always, x is row, y is column! */
  for(ix=1; ix<=s0; ix++) 
  {
    if (it%2)   /* alternate loop directions every other hyd_iter (it) */
    {
      for(iy=1; iy<=s1; iy++)  /* loop from west to east */
      {
        if( ( ON_MAP[T(ix,iy)] && ON_MAP[T(ix,iy+1)] && (int)(ON_MAP[T(ix,iy)]-1) & 1  ) || 
              BCondFlow[T(ix,iy+1)] == 3 ||  BCondFlow[T(ix,iy)] == 3  )
        {
          FFlux = Flux_SWcells(ix,iy,ix,iy+1,SURFACE_WAT,SED_ELEV,HYD_MANNINGS_N); 
          /* FFlux units = m */
          if (FFlux != 0.0) 
            Flux_SWstuff ( ix,iy,ix,iy+1,FFlux,SURFACE_WAT,STUF1,STUF2,STUF3,SfWat_vel_day);

        } /* endof if */
      } /* end of for */
    }  /* end of if */
     

    else 
    { 
      for(iy=s1; iy>=1; iy--)   /* loop from east to west */
        if( ( ON_MAP[T(ix,iy)] && ON_MAP[T(ix,iy-1)] && (int)(ON_MAP[T(ix,iy-1)]-1) & 1 ) || 
              BCondFlow[T(ix,iy-1)] == 3 || BCondFlow[T(ix,iy)] == 3  )
        {
          FFlux = Flux_SWcells(ix,iy-1,ix,iy,SURFACE_WAT,SED_ELEV,HYD_MANNINGS_N); 
                                /* FFlux units = m */
          if (FFlux != 0.0) 
            Flux_SWstuff ( ix,iy-1,ix,iy,FFlux,SURFACE_WAT,STUF1,STUF2,STUF3,SfWat_vel_day);

        }  /* end of if */
    }  /* end of else */
  }
        
  for(iy=1; iy<=s1; iy++) 
  {
    if (it%2)   /* alternate loop directions every other hyd_iter (it) */
    {
      for(ix=1; ix<=s0; ix++)  /* loop from north to south */
        if( ( ON_MAP[T(ix,iy)] && ON_MAP[T(ix+1,iy)]  && (int)(ON_MAP[T(ix,iy)]-1) & 2 ) ||
              BCondFlow[T(ix+1,iy)] == 3 || BCondFlow[T(ix,iy)] == 3  )
        { 
          FFlux = Flux_SWcells(ix,iy,ix+1,iy,SURFACE_WAT,SED_ELEV,HYD_MANNINGS_N); 
          /* FFlux units = m */
          if (FFlux != 0.0) 
            Flux_SWstuff ( ix,iy,ix+1,iy,FFlux,SURFACE_WAT,STUF1,STUF2,STUF3,SfWat_vel_day);
        }
    } 


    else 
    { 
      for(ix=s0; ix>=1; ix--)  /* loop from south to north */
        if( ( ON_MAP[T(ix,iy)] && ON_MAP[T(ix-1,iy)] && (int)(ON_MAP[T(ix-1,iy)]-1) & 2 ) ||
              BCondFlow[T(ix-1,iy)] == 3 || BCondFlow[T(ix,iy)] == 3  )
        {
             
          FFlux = Flux_SWcells(ix-1,iy,ix,iy,SURFACE_WAT,SED_ELEV,HYD_MANNINGS_N); 
          /* FFlux units = m */
          if (FFlux != 0.0) 
            Flux_SWstuff ( ix-1,iy,ix,iy,FFlux,SURFACE_WAT,STUF1,STUF2,STUF3,SfWat_vel_day);

        } /* end of if */
    } /* end of else */
  } /* end of for */

} /* end of function */

Here is the call graph for this function:

void Flux_GWater	(	int	it,
		float *	SatWat,
		float *	Unsat,
		float *	SfWat,
		float *	rate,
		float *	poros,
		float *	sp_yield,
		float *	elev,
		double *	gwSTUF1,
		double *	gwSTUF2,
		double *	gwSTUF3,
		double *	swSTUF1,
		double *	swSTUF2,
		double *	swSTUF3
	)

Groundwater fluxing routine.

This is the alternating direction function that first fluxes water in the E/W direction and then in the N/S direction. It sweeps from left to right, then goes back from right to left, then goes from top to bottom and finally from bottom to top. This alternates every iteration. Water is fluxed with mass conservation, allowing outflow from (no inflow to) the model system.

Parameters:

	it	Horizontal iteration number
	SatWat	SAT_WATER
	Unsat	UNSAT_WATER
	SfWat	SURFACE_WAT
	rate	HYD_RCCONDUCT
	poros	HP_HYD_POROSITY
	sp_yield	HP_HYD_SPEC_YIELD
	elev	SED_ELEV
	gwSTUF1	SALT_SED_WT
	gwSTUF2	DINdummy
	gwSTUF3	TP_SED_WT
	swSTUF1	SALT_SURF_WT
	swSTUF2	DINdummy
	swSTUF3	TP_SF_WT

Remarks:

Groundwater fluxing (this function) is called every other horizontal hyd_iter (it = int(hyd_iter-1)/2 ), or half as frequently as the surface water flow calculations.

Boundary condition flow allowances (read from BoundCond.BIN input map, values all within "ON_MAP" model domain): Value of (integer) BCondFlow:

• 1 Allow no flows external to model domain
• 3 Allow surface- and ground- water flows to/from external boundary cells
• 4 Allow groundwater (but not surface) flows to/from external boundary cells
• (9) Archaic, will remove (allowing groundwater flows, with static external stage conditions)

Definition at line 721 of file Fluxes.c.

References BCondFlow, Flux_GWcells(), ON_MAP, s0, s1, and T.

{ 
  int ix, iy; /* ix is row, iy is col! */
/* we only check the donor cell for on-map, allowing losses from the system */
 for(ix=1; ix<=s0; ix++) 
 {
     if (it%2) {  /* alternate loop directions every other iteration (it = int(hyd_iter-1)/2 ) */
     for(iy=1; iy<=s1; iy++)  /* loop from west to east */
             /* allow boundary flow if donor cell is marked 3 or higher (v2.5 had specific markings of 4 or 9, no longer pertinent in v2.6+) */
             if (( ON_MAP[T(ix,iy)] && ON_MAP[T(ix,iy+1)]) || 
                ((BCondFlow[T(ix,iy+1)]) > 2) || ((BCondFlow[T(ix,iy)]) > 2) ) 
         {
             Flux_GWcells(ix,iy,ix,iy+1,SatWat, Unsat, SfWat, rate, poros, sp_yield, elev,
                          gwSTUF1, gwSTUF2, gwSTUF3, swSTUF1, swSTUF2, swSTUF3); 
         }
     } 
             
     else { 
     for(iy=s1; iy>=1; iy--)   /* loop from east to west */
             /* allow boundary flow if donor cell is marked 3 or higher  (v2.5 had specific markings of 4 or 9, no longer pertinent in v2.6+) */
         if (( ON_MAP[T(ix,iy)] && ON_MAP[T(ix,iy-1)]) || 
                ((BCondFlow[T(ix,iy-1)]) > 2) || ((BCondFlow[T(ix,iy)]) > 2) ) 
         {
         
             Flux_GWcells(ix,iy,ix,iy-1,SatWat, Unsat, SfWat, rate, poros, sp_yield, elev,
                          gwSTUF1, gwSTUF2, gwSTUF3, swSTUF1, swSTUF2, swSTUF3); 
         }
     } 
 }
        
 for(iy=1; iy<=s1; iy++) 
 {
     if (it%2) {  /* alternate loop directions every other iteration (it = int(hyd_iter-1)/2 ) */
     for(ix=1; ix<=s0; ix++)  /* loop from north to south */
             /* allow boundary flow if donor cell is marked 3 or higher  (v2.5 had specific markings of 4 or 9, no longer pertinent in v2.6+) */
         if (( ON_MAP[T(ix,iy)] && ON_MAP[T(ix+1,iy)]) || 
                ((BCondFlow[T(ix+1,iy)]) > 2) || ((BCondFlow[T(ix,iy)]) > 2) ) 
         {
         
             Flux_GWcells(ix,iy,ix+1,iy,SatWat, Unsat, SfWat, rate, poros, sp_yield, elev,
                          gwSTUF1, gwSTUF2, gwSTUF3, swSTUF1, swSTUF2, swSTUF3); 
         }
         } 
     else { 
     for(ix=s0; ix>=1; ix--)  /* loop from south to north */
             /* allow boundary flow if donor cell is marked 3 or higher  (v2.5 had specific markings of 4 or 9, no longer pertinent in v2.6+) */
         if (( ON_MAP[T(ix,iy)] && ON_MAP[T(ix-1,iy)]) || 
                ((BCondFlow[T(ix-1,iy)]) > 2) || ((BCondFlow[T(ix,iy)]) > 2) ) 
         {
         
             Flux_GWcells(ix,iy,ix-1,iy,SatWat, Unsat, SfWat, rate, poros, sp_yield, elev,
                          gwSTUF1, gwSTUF2, gwSTUF3, swSTUF1, swSTUF2, swSTUF3); 
         }
     } 
 }

}

Here is the call graph for this function:

float* get_hab_parm	(	char *	s_parm_name,
		int	s_parm_relval,
		char *	parmName
	)

Read the input data file to get a habitat-specfic parameter array.

This gets an array of the targeted parameter, a value for each of (usually) multiple habitats.

Parameters:

	s_parm_name	Name of the sensitivity parameter being varied for this run
	s_parm_relval	Indicator of current value of relative range in sensitivity parm values: nominal (0), low (1), or high (2)
	parmName	String that identifies the parameter to be read in dbase file

Returns:

fTmp Array of values of single parameter across multiple habitats

Definition at line 671 of file Serial.c.

References dFile, EOL, EOS, False, get_Nth_parm(), gHabChar, goto_index(), habNumTot, match_Sparm(), MAX_NHAB, modelFileName, ModelPath, msgStr, ProgExec, ProjName, prog_attr::S_ParmVal, Scip(), TAB, True, usrErr(), and WriteMsg().

{
        int hIndex, end=0;
        FILE* parmFile;
        float* fTmp;
        char lline[2001], *line;
        int pLoc = -1;
        int foundParm= False;
        char parmNameHead[30];
        char modelFileName[300];
    char HabParmFile[300];
    char *fileAppend;
    extern ProgAttr *ProgExec;
    
        
        if ( (fTmp = (float*) malloc( MAX_NHAB * sizeof(float) ) ) == NULL) {
        sprintf(msgStr, "Failed to allocate memory for HabParm array.\n ") ;
        usrErr(msgStr);
        exit( -2 ) ;
        };
        fTmp[0] = 0.0;

    fileAppend = match_Sparm( s_parm_name, s_parm_relval, parmName);
        sprintf(HabParmFile,"HabParms_%s",fileAppend);
        sprintf(modelFileName,"%s/%s/Data/%s",ModelPath,ProjName,HabParmFile);
        parmFile = fopen(modelFileName,"r");
        if(parmFile==NULL) {fprintf(stdout,"\nERROR: Unable to open dBase file %s\n",modelFileName); exit(-1); }
        
     fgets(lline, 2000, parmFile); /* skip 1st header line  */
     fgets(lline, 2000, parmFile); /* read 2nd header line with column names */
     line=lline;

     while (!foundParm)  
     {
        sscanf( line,"%s",&parmNameHead);
        if (strcmp(parmName,parmNameHead) ==0) foundParm = True;
        pLoc++;
        if (*line == EOS || *line == EOL) {
           sprintf(msgStr,"ERROR: Could not find header tag of %s in HabParms dbase file.", parmName); 
           usrErr(msgStr); 
           exit(-1);
        }
        line = Scip( line, TAB );
     }
    
    sprintf(msgStr,"Parameter group: %s",parmName); 
    fflush(dFile); 
    WriteMsg(msgStr,1); 
        for( hIndex = 1; hIndex < MAX_NHAB; hIndex++) {
                goto_index (parmFile, gHabChar, hIndex); 
                fTmp[hIndex] = get_Nth_parm( parmFile, pLoc, &end, hIndex );
                if(end) break;
        }
        fclose(parmFile);
        habNumTot = hIndex-1;

        fflush(dFile); 
        /* TODO: this HARDCODES into the BIR (BIRavg) model output file ONLY, 
        the incorrect impression of running sensitivity on a single habitat ID 
        (hab 2 = sawgrass plain, ELMv2.4) */
    if (strcmp(s_parm_name,parmName) == 0) ProgExec->S_ParmVal = fTmp[2];
        return fTmp; 
}

Here is the call graph for this function:

float get_global_parm	(	char *	s_parm_name,
		int	s_parm_relval,
		char *	parmName
	)

Read the input data file to get a global parameter.

This gets the single global value of the targeted parameter.

Parameters:

	s_parm_name	Name of the sensitivity parameter being varied for this run
	s_parm_relval	Indicator of current value of relative range in sensitivity parm values: nominal (0), low (1), or high (2)
	parmName	String that identifies the parameter to be read in dbase file

Returns:

parmVal The value of the global parameter

Definition at line 775 of file Serial.c.

References Exit(), match_Sparm(), modelFileName, ModelPath, msgStr, ProgExec, ProjName, prog_attr::S_ParmVal, scan_forward(), usrErr(), and WriteMsg().

{
  int test;
  char modelFileName[300];
  FILE *parmFile;
  float parmVal;
  char parmNameHead[30];
  extern ProgAttr *ProgExec;


  char GlobalParmFile[50];
  char *fileAppend;
  
  fileAppend = match_Sparm( s_parm_name, s_parm_relval, parmName);
  sprintf(GlobalParmFile,"GlobalParms_%s",fileAppend);
  sprintf(modelFileName,"%s/%s/Data/%s",ModelPath,ProjName,GlobalParmFile);
  
  parmFile = fopen(modelFileName,"r");
  if(parmFile==NULL) { 
        sprintf(msgStr,"ERROR, can't open data file %s",modelFileName); 
    usrErr(msgStr);
        Exit(0); 
  }

  sprintf(parmNameHead,"%s=", parmName);
  scan_forward(parmFile,parmNameHead);
  if ( (test = fscanf(parmFile,"%f",&parmVal) ) <= 0 ) { 
    sprintf(msgStr,"ERROR in reading %s from %s; see Driver0.out debug file.", parmName, modelFileName); 
    usrErr(msgStr);
    Exit(0); 
  }
  sprintf(msgStr,"%s %f\n",parmNameHead, parmVal); 
  WriteMsg(msgStr,1); 

  fclose(parmFile);
  if (strcmp(s_parm_name,parmName) == 0) ProgExec->S_ParmVal = parmVal;
  return parmVal;
}

Here is the call graph for this function:

float get_modexperim_parm	(	char *	s_parm_name,
		int	s_parm_relval,
		char *	parmName
	)

Read the input data file to get a model experiment parameter.

This gets the single global value of the targeted parameter for special model experiments. (Added for ELM v2.6).

Parameters:

	s_parm_name	Name of the sensitivity parameter being varied for this run
	s_parm_relval	Indicator of current value of relative range in sensitivity parm values: nominal (0), low (1), or high (2)
	parmName	String that identifies the parameter to be read in dbase file

Returns:

parmVal The value of the (global) model experiment parameter

Definition at line 822 of file Serial.c.

References Exit(), match_Sparm(), modelFileName, ModelPath, msgStr, ProgExec, ProjName, prog_attr::S_ParmVal, scan_forward(), usrErr(), and WriteMsg().

{
  int test;
  char modelFileName[300];
  FILE *parmFile;
  float parmVal;
  char parmNameHead[30];
  extern ProgAttr *ProgExec;


  char ModExParmFile[50];
  char *fileAppend;
  
  fileAppend = match_Sparm( s_parm_name, s_parm_relval, parmName);
  sprintf(ModExParmFile,"ModExperimParms_%s",fileAppend);
  sprintf(modelFileName,"%s/%s/Data/%s",ModelPath,ProjName,ModExParmFile);
  
  parmFile = fopen(modelFileName,"r");
  if(parmFile==NULL) { 
        sprintf(msgStr,"ERROR, can't open data file %s",modelFileName); 
    usrErr(msgStr);
        Exit(0); 
  }

  sprintf(parmNameHead,"%s=", parmName);
  scan_forward(parmFile,parmNameHead);
  if ( (test = fscanf(parmFile,"%f",&parmVal) ) <= 0 ) { 
    sprintf(msgStr,"ERROR in reading %s from %s; see Driver0.out debug file.", parmName, modelFileName); 
    usrErr(msgStr);
    Exit(0); 
  }
  sprintf(msgStr,"%s %f\n",parmNameHead, parmVal); 
  WriteMsg(msgStr,1); 

  fclose(parmFile);
  if (strcmp(s_parm_name,parmName) == 0) ProgExec->S_ParmVal = parmVal;
  return parmVal;
}

Here is the call graph for this function:

int stage_data_wmm

(

float *

)

stage (depth) data array

Definition at line 31 of file stage_inp.c.

References conv_ftTOm, applicationStruct::dataELM, applicationStruct::day, debug, elm_OG_map, elm_wmm_map, initDataStruct(), mapGrids(), ModelPath, msgStr, printGridMap(), processData(), ProjName, applicationStruct::recRead, returnData(), s0, s1, SimTime, stage_binfilename, stage_struct, T, simTime::TIME, and usrErr().

{

  int i,j,k;
  int success = 1, fail = -1;
  int stat = success;
  char gridmapfilename[335];

  if(SimTime.TIME==0)  {      
/* elm_OG_map is data structure containing the mapping attributes at two scales */
    elm_wmm_map = elm_OG_map;

    if(elm_wmm_map == NULL) {
      sprintf(msgStr, "Mapping grids and setting up stage data...");
      usrErr (msgStr);

      sprintf(gridmapfilename, "%s%s/Data/gridmapping.txt", ModelPath, ProjName );   
      stat = mapGrids(gridmapfilename);
      elm_wmm_map = elm_OG_map;
    }

    if(debug > 4) {
      printGridMap();
      sprintf(msgStr,"stage_data_wmm==> Finished mapping grids");
      usrErr (msgStr);
    }

    sprintf(stage_binfilename, "%s%s/Data/BoundCond_stage.BIN", ModelPath, ProjName );
    /* initializing data structures, move pointer to initial date (gridmap.c) */
    stat = initDataStruct(stage_binfilename,&stage_struct);  

    if(debug > 4) {
      /*printELM2Grid_io(); */
      /*drawELM2Grid_io(); */
      sprintf(msgStr,"stage_data_wmm==> Finished initializing");
      usrErr (msgStr); 
    }

  } /* end of SimTime.TIME=0 */
  
  
  if(stage_struct.day >= stage_struct.recRead) {      /* process the data in batch */
      sprintf(msgStr,"Processing batch of stage data...");
      usrErr (msgStr); 
      stat = processData(stage_binfilename,&stage_struct);

      if(debug > 4 ) {
        /*printBatchData(stageWMM,gridio_batch_len,widCnt);*/ /* TODO: remove this printBatchData function when sure is no longer needed */
        sprintf(msgStr,"stage_data_wmm==> Finished processing data");
        usrErr (msgStr); 
      }
  } /* end of if */


  if(stage_struct.day < stage_struct.recRead) {      /* pass the data day by day */
    returnData(stageSME,&stage_struct); 

    for(i = 0; i < s0; i++) {
      for(j = 0; j < s1; j++) {
        k = i*s1+j;
        stageSME[T((i+1),(j+1))] = stage_struct.dataELM[k] * conv_ftTOm;  /* convert data from feet to meters */
      }
    } 

    if(debug > 4) {
      sprintf(msgStr,"stage_data_wmm==> Finished returning data");
      usrErr (msgStr); 
    }

  } /* end of if */
    
  return success;
}

Here is the call graph for this function:

int rain_data_wmm

(

float *

)

rainfall data array

Definition at line 26 of file rain_inp.c.

References conv_inTOtenths_mm, applicationStruct::dataELM, applicationStruct::day, debug, elm_OG_map, elm_wmm_map, initDataStruct(), mapGrids(), ModelPath, msgStr, printGridMap(), processData(), ProjName, rain_binfilename, rain_struct, applicationStruct::recRead, returnData(), s0, s1, SimTime, T, simTime::TIME, usrErr(), and usrErr0().

{

  int i,j,k; 
  int success = 1, fail = -1;
  int stat = success;
  char gridmapfilename[335];

  if(SimTime.TIME==0)  {      

     // cleanUp(*elm_wmm_map, rainSME);
      
                /* elm_OG_map is data structure containing the mapping attributes at two scales */
      elm_wmm_map = elm_OG_map;

      if(elm_wmm_map == NULL) {
          sprintf(msgStr, "Mapping grids and setting up rain data...");
          usrErr0(msgStr);
          
          sprintf(gridmapfilename, "%s%s/Data/gridmapping.txt", ModelPath, ProjName );   
          stat = mapGrids(gridmapfilename);
          elm_wmm_map = elm_OG_map;
      }

      if(debug > 4) {
          printGridMap();
          sprintf(msgStr,"rain_data_wmm==> Finished mapping grids");
          usrErr (msgStr);
      }

      sprintf(rain_binfilename, "%s%s/Data/rain.BIN", ModelPath, ProjName );

/* initializing data structures, move pointer to initial date (gridmap.c) */
      stat = initDataStruct(rain_binfilename,&rain_struct);

      if(debug > 4) {
              /* printELM2Grid_io(); */
              /*drawELM2Grid_io(); */
          sprintf(msgStr,"rain_data_wmm==> Finished initializing");
          usrErr (msgStr); 
      }

  } /* end of SimTime.TIME=0 */
  
  
  if(rain_struct.day >= rain_struct.recRead) {      /* process the data in batch */
      sprintf(msgStr,"\nProcessing batch of rain data...");
      usrErr (msgStr); 
      stat = processData(rain_binfilename,&rain_struct);

      if(debug > 4 ) {
              /*printBatchData(rainWMM,gridio_batch_len,widCnt);*/ /* TODO: remove this printBatchData function when sure is no longer needed */
          sprintf(msgStr,"rain_data_wmm==> Finished processing data");
          usrErr (msgStr); 
      }
  } /* end of if */


  if (rain_struct.day < rain_struct.recRead) {      /* pass the data day by day */
    returnData(rainSME,&rain_struct);   
    /* change the unit here */
    for(i = 0; i < s0; i++) {
      for(j = 0; j < s1; j++) {
        k = i*s1+j;
        rainSME[T((i+1),(j+1))] = rain_struct.dataELM[k] * conv_inTOtenths_mm;  /* convert data from inches to tenths of mm */
      }
    } 

    if(debug > 4) {
      sprintf(msgStr,"rain_data_wmm==> Finished returning data");
      usrErr (msgStr); 
    }

  } /* end of if */
    
  return success;
}

Here is the call graph for this function:

int evap_data_wmm

(

float *

)

potential ET data array

Definition at line 30 of file evap_inp.c.

References conv_inTOtenths_mm, applicationStruct::dataELM, applicationStruct::day, debug, elm_OG_map, elm_wmm_map, evap_binfilename, evap_struct, initDataStruct(), mapGrids(), ModelPath, msgStr, printGridMap(), processData(), ProjName, applicationStruct::recRead, returnData(), s0, s1, SimTime, T, simTime::TIME, and usrErr().

{

  int i,j,k;
  int success = 1, fail = -1;
  int stat = success;
  char gridmapfilename[335];

  if(SimTime.TIME==0)  {      
/* elm_OG_map is data structure containing the mapping attributes at two scales */
    elm_wmm_map = elm_OG_map;

    if(elm_wmm_map == NULL) {
      sprintf(msgStr, "Mapping grids and setting up pET data...");
      usrErr (msgStr);

      sprintf(gridmapfilename, "%s%s/Data/gridmapping.txt", ModelPath, ProjName );   
      stat = mapGrids(gridmapfilename);
      elm_wmm_map = elm_OG_map;
    }

    if(debug > 4) {
      printGridMap();
      sprintf(msgStr,"evap_data_wmm==> Finished mapping grids");
      usrErr (msgStr);
    }

    sprintf(evap_binfilename, "%s%s/Data/ETp.BIN", ModelPath, ProjName );
    /* initializing data structures, move pointer to initial date (gridmap.c) */
    stat = initDataStruct(evap_binfilename,&evap_struct);  

    if(debug > 4) {
      /*printELM2Grid_io(); */
      /*drawELM2Grid_io(); */
      sprintf(msgStr,"evap_data_wmm==> Finished initializing");
      usrErr (msgStr); 
    }

  } /* end of SimTime.TIME=0 */
  
  
  if(evap_struct.day >= evap_struct.recRead) {      /* process the data in batch */
      sprintf(msgStr,"Processing batch of pET data...");
      usrErr (msgStr); 
      stat = processData(evap_binfilename,&evap_struct);

      if(debug > 4 ) {
        /*printBatchData(evapWMM,gridio_batch_len,widCnt);*/ /* TODO: remove this printBatchData function when sure is no longer needed */
        sprintf(msgStr,"evap_data_wmm==> Finished processing data");
        usrErr (msgStr); 
      }
  } /* end of if */


  if(evap_struct.day < evap_struct.recRead) {      /* pass the data day by day */
    returnData(evapSME,&evap_struct); 

    for(i = 0; i < s0; i++) {
      for(j = 0; j < s1; j++) {
        k = i*s1+j;
        evapSME[T((i+1),(j+1))] = evap_struct.dataELM[k] * conv_inTOtenths_mm; /* convert data from inches to tenths of mm */  
      }
    } 

    if(debug > 4) {
      sprintf(msgStr,"evap_data_wmm==> Finished returning data");
      usrErr (msgStr); 
    }

  } /* end of if */
    
  return success;
}

Here is the call graph for this function:

---

Variable Documentation

float DAYJUL

A "julian" day counter within a 365 day "year"

Definition at line 31 of file unitmod.h.

Referenced by cell_dyn1(), CellAvg(), gen_output(), and init_eqns().

float LATRAD

Non-spatial solar radiation intermediate variables.

These (unmodified) complex calculations were developed, tested, and published for global applications by Nikolov & Zeller (1992).
LATRAD Regional latitude calculated in radians
SOLALPHA Intermediate calculation
SOLALTCORR Intermediate calculation (altitude correction)
SOLBETA Intermediate calculation
SOLCOSDEC Intermediate calculation
SOLDEC Intermediate calculation
SOLDEC1 Intermediate calculation
SOLELEV_SINE Intermediate calculation
SOLRADATMOS Solar radiation in upper atmosphere (cal/cm2/d)
SOLRISSET_HA Intermediate calculation
SOLRISSET_HA1 Intermediate calculation

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn1(), and init_eqns().

float SOLALPHA

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn7(), and init_eqns().

float SOLALTCORR

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn1(), cell_dyn7(), and init_eqns().

float SOLBETA

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn7(), and init_eqns().

float SOLCOSDEC

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn1(), and init_eqns().

float SOLDEC

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn1(), and init_eqns().

float SOLDEC1

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn1(), and init_eqns().

float SOLELEV_SINE

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn1(), and init_eqns().

float SOLRADATMOS

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn1(), cell_dyn7(), and init_eqns().

float SOLRISSET_HA

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn1(), and init_eqns().

float SOLRISSET_HA1

Definition at line 49 of file unitmod.h.

Referenced by cell_dyn1(), and init_eqns().

float dispParm_scaled

Definition at line 53 of file unitmod.h.

float GP_BC_SfWat_add

Model experiment (global) parameter. _Units_: m; _Brief_: ***add (pos or neg) value to Surface Water Depth in Boundary Condition cells outside model domain; _Extended_: used for very long time scale and/or very fine spatial scale subregional apps, where standard gridIO data are not useful

Definition at line 56 of file unitmod.h.

Referenced by Flux_SWcells(), and ReadModExperimParms().

float GP_BC_SfWat_addHi

Model experiment (global) parameter. _Units_: m; _Brief_: ***when SfWat > target, this depth value is used in non-linear fcn to add (pos or neg) value to Surface Water Depth in Boundary Condition cells outside model domain; _Extended_: used for very long time scale and/or very fine spatial scale subregional apps, where standard gridIO data are not useful

Definition at line 57 of file unitmod.h.

Referenced by Flux_SWcells(), and ReadModExperimParms().

float GP_BC_SatWat_add

Model experiment (global) parameter. _Units_: m; _Brief_: ***add (pos or neg) value to Saturated (ground) Water Depth in Boundary Condition cells outside model domain; _Extended_: used for very long time scale and/or very fine spatial scale subregional apps, where standard gridIO data are not useful

Definition at line 58 of file unitmod.h.

Referenced by Flux_GWcells(), and ReadModExperimParms().

float GP_BC_SfWat_targ

Model experiment (global) parameter. _Units_: m; _Brief_: ***maximum Surface Water Depth target in Boundary Condition cells inside model domain; _Extended_: used for very long time scale and/or very fine spatial scale subregional apps, where standard gridIO data are not useful

Definition at line 59 of file unitmod.h.

Referenced by Flux_SWcells(), and ReadModExperimParms().

int GP_BC_InputRow

Model experiment (global) parameter. _Units_: dimless; _Brief_: ***model grid row# below which (i.e., to north) the _SfWat_add parm is added, and above which (to south) the depth is subtracted; _Extended_: a "research" kluge for now - used for very long time scale and/or very fine spatial scale subregional apps, where standard gridIO data are not useful

Definition at line 60 of file unitmod.h.

Referenced by Flux_GWcells(), Flux_SWcells(), and ReadModExperimParms().

float GP_BC_Pconc

Model experiment (global) parameter. _Units_: ug/L; _Brief_: ***Phosphorus conc. in surface or ground water Boundary Condition inflows from outside model domain; _Extended_: new for v2.6

Definition at line 61 of file unitmod.h.

Referenced by Flux_SWstuff(), and ReadModExperimParms().

float GP_BC_Sconc

Model experiment (global) parameter. _Units_: g/L; _Brief_: ***Salt (tracer, usually chloride) conc. in surface or ground water Boundary Condition inflows from outside model domain; _Extended_: new for v2.6

Definition at line 62 of file unitmod.h.

Referenced by Flux_SWstuff(), and ReadModExperimParms().

float g7[11][2]

Initial value:

 { {0.0000000,0.0000000},{0.1000000,0.0200000},{0.2000000,0.0400000},{0.3000000,0.0700000},
    {0.4000000,0.1250000},{0.5000000,0.2150000},{0.6000000,0.3450000},{0.7000000,0.5750000},
    {0.8000000,0.8550000},{0.9000000,0.9850000},{1.0000000,1.0000000} }

g7 data for graph7 - empirical data of a (0-1) control function, the proportion (dependent var, second of each pair) of maximum vertical water infiltration rate through soil as a function of soil moisture proportion (0-1) (independent var, first of each pair)

Definition at line 66 of file unitmod.h.

Referenced by graph7().

float g8[11][2]

Initial value:

 { {0.0000000,0.0050000},{0.1000000,0.0100000},{0.2000000,0.0400000},{0.3000000,0.1000000},
    {0.4000000,0.2800000},{0.5000000,0.7150000},{0.6000000,0.8650000},{0.7000000,0.9350000},
    {0.8000000,0.9750000},{0.9000000,0.9950000},{1.0000000,1.0000000} }

g8 data for graph8 - empirical data of a (0-1) control function, the proportion (dependent var, second of each pair) of water available to plants as a function of proportion (0-1) of water available upper soil profile (independent var, first of each pair) (generally, simply 1:1 relationship)

Definition at line 70 of file unitmod.h.

Referenced by graph8().

int CalMonOut

The outstep interval (in Model.outList input file) used to denote output intervals of 1-calendar-month instead of selectable-julian-day

Definition at line 32 of file driver_utilities.h.

Referenced by gen_output(), and readViewParms().

PTSeriesList* pTSList6

Definition at line 151 of file unitmod.h.

Referenced by PtInterp_read().

PTSeriesList* pTSList5

Definition at line 152 of file unitmod.h.

Referenced by PtInterp_read().

PTSeriesList* pTSList4

Definition at line 153 of file unitmod.h.

Referenced by PtInterp_read().

PTSeriesList* pTSList3

Definition at line 154 of file unitmod.h.

Referenced by cell_dyn1(), and PtInterp_read().

PTSeriesList* pTSList2

Definition at line 156 of file unitmod.h.

Referenced by cell_dyn1(), and PtInterp_read().

float Timestep0 = 1.0

Definition at line 158 of file unitmod.h.

float TMod0 = 0

Definition at line 158 of file unitmod.h.

int NPtTS0 = 0

Definition at line 158 of file unitmod.h.

int TIndex0 = 0

Definition at line 158 of file unitmod.h.

float Timestep1 = 1.0

Definition at line 159 of file unitmod.h.

float TMod1 = 0

Definition at line 159 of file unitmod.h.

int NPtTS1 = 0

Definition at line 159 of file unitmod.h.

int TIndex1 = 0

Definition at line 159 of file unitmod.h.

float Timestep2 = 1.0

Definition at line 160 of file unitmod.h.

Referenced by cell_dyn1(), and PtInterp_read().

float TMod2 = 0

Definition at line 160 of file unitmod.h.

int NPtTS2 = 0

Definition at line 160 of file unitmod.h.

Referenced by cell_dyn1(), and PtInterp_read().

int TIndex2 = 0

Definition at line 160 of file unitmod.h.

Referenced by PtInterp_read().

float Timestep3 = 1.0

Definition at line 161 of file unitmod.h.

Referenced by cell_dyn1(), and PtInterp_read().

float TMod3 = 0

Definition at line 161 of file unitmod.h.

int NPtTS3 = 0

Definition at line 161 of file unitmod.h.

Referenced by cell_dyn1(), and PtInterp_read().

int TIndex3 = 0

Definition at line 161 of file unitmod.h.

Referenced by PtInterp_read().

float Timestep4 = 1.0

Definition at line 162 of file unitmod.h.

Referenced by PtInterp_read().

float TMod4 = 0

Definition at line 162 of file unitmod.h.

int NPtTS4 = 0

Definition at line 162 of file unitmod.h.

Referenced by PtInterp_read().

int TIndex4 = 0

Definition at line 162 of file unitmod.h.

Referenced by PtInterp_read().

float Timestep5 = 1.0

Definition at line 163 of file unitmod.h.

Referenced by PtInterp_read().

float TMod5 = 0

Definition at line 163 of file unitmod.h.

int NPtTS5 = 0

Definition at line 163 of file unitmod.h.

Referenced by PtInterp_read().

int TIndex5 = 0

Definition at line 163 of file unitmod.h.

Referenced by PtInterp_read().

float Timestep6 = 1.0

Definition at line 164 of file unitmod.h.

Referenced by PtInterp_read().

float TMod6 = 0

Definition at line 164 of file unitmod.h.

int NPtTS6 = 0

Definition at line 164 of file unitmod.h.

Referenced by PtInterp_read().

int TIndex6 = 0

Definition at line 164 of file unitmod.h.

Referenced by PtInterp_read().

basnDef** basn_list

Basin/Indicator Region data

Definition at line 31 of file budgstats.h.

basnDef* basins

Basin/Indicator Region data

Definition at line 32 of file budgstats.h.

int WatMgmtOn

boolean flag indicating water management mode

Definition at line 34 of file generic_driver.h.

Referenced by Flux_SWstuff(), get_parmf(), horizFlow(), and main().

int ESPmodeON

boolean flag indicating Everglades Settling-of Phosphorus mode. A mode with all biol/chem (non-hydro) modules turned off, running only a net settling rate module that reproduces equations and data from the SFWMD's old Everglades Water Quality Model (EWQM). Done only for comparision to full ecological ELM - ESP doesn't work very well!!

Definition at line 31 of file generic_driver.h.

Referenced by BIRbudg_date(), BIRbudg_print(), BIRbudg_reset(), BIRbudg_sum(), BIRbudg_sumFinal(), BIRoutfiles(), get_parmf(), init_static_data(), and main().

int HabSwitchOn

boolean flag indicating habitat succession mode

Definition at line 35 of file generic_driver.h.

Referenced by cell_dyn1(), get_parmf(), and main().

int avgPrint

boolean flag to indicate if recurring-averages is to be printed at current time

Definition at line 81 of file generic_driver.h.

Referenced by CellAvg(), gen_output(), and track_time().

char* OutputPath

base pathname for all model output (user input)

Definition at line 42 of file driver_utilities.h.

char * ProjName

Definition at line 40 of file driver_utilities.h.