void patch_daily_I(
struct world_object *world,
struct basin_object *basin,
struct hillslope_object *hillslope,
struct zone_object *zone,
struct patch_object *patch,
struct command_line_object *command_line,
struct tec_entry *event,
struct date current_date)
{
/*--------------------------------------------------------------*/
/* Local Function Declarations. */
/*--------------------------------------------------------------*/
void canopy_stratum_daily_I(
struct world_object *,
struct basin_object *,
struct hillslope_object *,
struct zone_object *,
struct patch_object *,
struct canopy_strata_object *,
struct command_line_object *,
struct tec_entry *,
struct date);
double compute_layer_field_capacity(
int,
int,
double,
double,
double,
double,
double,
double,
double,
double,
double);
double compute_delta_water(
int,
double,
double,
double,
double,
double);
double compute_z_final(
int,
double,
double,
double,
double,
double);
int update_rootzone_moist(
struct patch_object *,
struct rooting_zone_object *,
struct command_line_object *);
double compute_capillary_rise(
int,
double,
double,
double,
double,
double);
double compute_potential_exfiltration(
int,
double,
double,
double,
double,
double,
double,
double,
double);
double compute_soil_water_potential(
int,
int,
double,
double,
double,
double,
double,
double,
double,
double,
double,
double);
int compute_potential_decomp(
double,
double,
double,
double,
double,
struct soil_c_object *,
struct soil_n_object *,
struct litter_c_object *,
struct litter_n_object *,
struct cdayflux_patch_struct *,
struct ndayflux_patch_struct *);
void sort_patch_layers(struct patch_object *);
void update_litter_interception_capacity (double,
double,
struct litter_c_object *,
struct litter_object *);
int zero_patch_daily_flux(
struct patch_object *,
struct cdayflux_patch_struct *,
struct ndayflux_patch_struct *);
long julday( struct date);
/*--------------------------------------------------------------*/
/* Local variable definition. */
/*--------------------------------------------------------------*/
int layer, inx;
int stratum;
double cnt, count, theta;
double edible_leafc, grazing_mean_nc, grazing_Closs;
struct canopy_strata_object *strata;
struct dated_sequence clim_event;
/*--------------------------------------------------------------*/
/* zero out daily fluxes */
/*--------------------------------------------------------------*/
if (zero_patch_daily_flux(patch, &(patch[0].cdf), &(patch[0].ndf))){
fprintf(stderr,
"Error in zero_patch_daily_flux() from patch_daily_I.c... Exiting\n");
exit(EXIT_FAILURE);
}
/*-----------------------------------------------------*/
/* Compute potential saturation for rootzone layer */
/*-----------------------------------------------------*/
if (patch[0].rootzone.depth > ZERO) {
patch[0].rootzone.potential_sat = compute_delta_water(
command_line[0].verbose_flag,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].rootzone.depth, 0.0);
if (patch[0].rootzone.potential_sat > ZERO)
if (patch[0].sat_deficit_z > patch[0].rootzone.depth)
patch[0].rootzone.S = patch[0].rz_storage/patch[0].rootzone.potential_sat;
else
patch[0].rootzone.S = min((patch[0].rz_storage + patch[0].rootzone.potential_sat - patch[0].sat_deficit)/patch[0].rootzone.potential_sat,1.0);
else
patch[0].rootzone.S = 0.0;
}
else {
patch[0].rootzone.potential_sat = 0.0;
patch[0].rootzone.S = 0.0;
}
if (patch[0].sat_deficit < ZERO)
patch[0].S = 1.0;
else
patch[0].S = (patch[0].rz_storage+patch[0].unsat_storage)/patch[0].sat_deficit;
/*--------------------------------------------------------------*/
/* compute standard deviation of theta based on soil parameters */
/* assume no decay of porosity here */
/*--------------------------------------------------------------*/
theta = patch[0].S * patch[0].soil_defaults[0][0].porosity_0;
patch[0].theta_std = (patch[0].soil_defaults[0][0].theta_mean_std_p2*theta*theta +
patch[0].soil_defaults[0][0].theta_mean_std_p1*theta);
/*--------------------------------------------------------------*/
/* compute new field capacity */
/*--------------------------------------------------------------*/
if (patch[0].sat_deficit_z < patch[0].rootzone.depth) {
patch[0].rootzone.field_capacity = compute_layer_field_capacity(
command_line[0].verbose_flag,
patch[0].soil_defaults[0][0].theta_psi_curve,
patch[0].soil_defaults[0][0].psi_air_entry,
patch[0].soil_defaults[0][0].pore_size_index,
patch[0].soil_defaults[0][0].p3,
patch[0].soil_defaults[0][0].p4,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].sat_deficit_z,
patch[0].rootzone.depth, 0.0);
patch[0].field_capacity = 0.0;
}
else {
patch[0].rootzone.field_capacity = compute_layer_field_capacity(
command_line[0].verbose_flag,
patch[0].soil_defaults[0][0].theta_psi_curve,
patch[0].soil_defaults[0][0].psi_air_entry,
patch[0].soil_defaults[0][0].pore_size_index,
patch[0].soil_defaults[0][0].p3,
patch[0].soil_defaults[0][0].p4,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].sat_deficit_z,
patch[0].rootzone.depth, 0.0);
patch[0].field_capacity = compute_layer_field_capacity(
command_line[0].verbose_flag,
patch[0].soil_defaults[0][0].theta_psi_curve,
patch[0].soil_defaults[0][0].psi_air_entry,
patch[0].soil_defaults[0][0].pore_size_index,
patch[0].soil_defaults[0][0].p3,
patch[0].soil_defaults[0][0].p4,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].sat_deficit_z,
patch[0].sat_deficit_z, 0.0) - patch[0].rootzone.depth;
}
/*--------------------------------------------------------------*/
/* Estimate potential cap rise. */
/* limited to water in sat zone. */
/*--------------------------------------------------------------*/
patch[0].potential_cap_rise = compute_capillary_rise(
command_line[0].verbose_flag,
patch[0].sat_deficit_z,
patch[0].soil_defaults[0][0].psi_air_entry,
patch[0].soil_defaults[0][0].pore_size_index,
patch[0].soil_defaults[0][0].mz_v,
patch[0].soil_defaults[0][0].Ksat_0_v );
if (patch[0].potential_cap_rise < ZERO)
patch[0].potential_cap_rise = 0.0;
patch[0].cap_rise=0.0;
/*--------------------------------------------------------------*/
/* Compute the max exfiltration rate. */
/* */
/* First check if we are saturated. If so the */
/* potential exfiltration rate is the capillary rise rate. */
/* */
/* If we are within the active unsat zone then we assume */
/* that the potential exfiltration rate is the minimum of */
/* the computed exfiltration rate and the potential cap */
/* rise - i.e. hydrologic connectivity between surface and */
/* water table. */
/* */
/*--------------------------------------------------------------*/
if ( patch[0].sat_deficit_z <= patch[0].soil_defaults[0][0].psi_air_entry ){
patch[0].potential_exfiltration = patch[0].potential_cap_rise;
}
else{
if ( patch[0].soil_defaults[0][0].active_zone_z < patch[0].sat_deficit_z ){
/*--------------------------------------------------------------*/
/* Estimate potential exfiltration from active zone */
/*--------------------------------------------------------------*/
patch[0].potential_exfiltration = compute_potential_exfiltration(
command_line[0].verbose_flag,
patch[0].rootzone.S,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].Ksat_0_v,
patch[0].soil_defaults[0][0].mz_v,
patch[0].soil_defaults[0][0].psi_air_entry,
patch[0].soil_defaults[0][0].pore_size_index,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].porosity_0);
}
else {
/*--------------------------------------------------------------*/
/* Estimate potential exfiltration from active zone */
/*--------------------------------------------------------------*/
patch[0].potential_exfiltration = compute_potential_exfiltration(
command_line[0].verbose_flag,
patch[0].rootzone.S,
patch[0].sat_deficit_z,
patch[0].soil_defaults[0][0].Ksat_0_v,
patch[0].soil_defaults[0][0].mz_v,
patch[0].soil_defaults[0][0].psi_air_entry,
patch[0].soil_defaults[0][0].pore_size_index,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].porosity_0);
}
}
/*-----------------------------------------------------*/
/* Check for any grazing activity from a land use default file */
/*-----------------------------------------------------*/
if (patch[0].base_stations != NULL) {
inx = patch[0].base_stations[0][0].dated_input[0].grazing_Closs.inx;
if (inx > -999) {
clim_event = patch[0].base_stations[0][0].dated_input[0].grazing_Closs.seq[inx];
while (julday(clim_event.edate) < julday(current_date)) {
patch[0].base_stations[0][0].dated_input[0].grazing_Closs.inx += 1;
inx = patch[0].base_stations[0][0].dated_input[0].grazing_Closs.inx;
clim_event = patch[0].base_stations[0][0].dated_input[0].grazing_Closs.seq[inx];
}
if ((clim_event.edate.year != 0) && ( julday(clim_event.edate) == julday(current_date)) ) {
grazing_Closs = clim_event.value;
}
else grazing_Closs = 0.0;
}
else grazing_Closs = patch[0].landuse_defaults[0][0].grazing_Closs;
}
else grazing_Closs = patch[0].landuse_defaults[0][0].grazing_Closs;
patch[0].grazing_Closs = grazing_Closs;
/*--------------------------------------------------------------*/
/* Cycle through the canopy layers. */
/*--------------------------------------------------------------*/
edible_leafc = 0.0;
grazing_mean_nc = 0.0;
cnt = 0;
for ( layer=0 ; layer<patch[0].num_layers; layer++ ){
/*--------------------------------------------------------------*/
/* Cycle through the canopy strata */
/*--------------------------------------------------------------*/
for ( stratum=0 ; stratum<patch[0].layers[layer].count; stratum++ ){
strata = patch[0].canopy_strata[(patch[0].layers[layer].strata[stratum])];
patch[0].preday_rain_stored += strata->cover_fraction * strata->rain_stored;
patch[0].preday_snow_stored += strata->cover_fraction * strata->snow_stored;
if ((strata[0].defaults[0][0].epc.edible == 1) && (strata[0].cs.leafc > ZERO)) {
edible_leafc += strata->cs.leafc * strata->cover_fraction;
cnt += 1;
grazing_mean_nc += strata->ns.leafn/strata->cs.leafc * strata->cover_fraction;
}
canopy_stratum_daily_I(
world,
basin,
hillslope,
zone,
patch,
patch[0].canopy_strata[(patch[0].layers[layer].strata[stratum])],
command_line,
event,
current_date );
}
}
patch[0].grazing_Closs = min(edible_leafc, patch[0].grazing_Closs);
if (cnt > 0)
patch[0].grazing_mean_nc = grazing_mean_nc / cnt;
/*--------------------------------------------------------------*/
/* Calculate effective patch lai from stratum */
/* - for later use by zone_daily_F */
/* Accumulate root biomass for patch soil -
/* required for N updake from soil */
/* also determine total plant carbon */
/* - if grow option is specified */
/*--------------------------------------------------------------*/
patch[0].effective_lai = 0.0;
patch[0].soil_cs.frootc = 0.0;
patch[0].rootzone.depth = 0.0;
count = 0.0;
for ( stratum=0 ; stratum<patch[0].num_canopy_strata; stratum++){
patch[0].effective_lai += patch[0].canopy_strata[stratum][0].epv.proj_lai;
if (command_line[0].grow_flag > 0) {
patch[0].soil_cs.frootc
+= patch[0].canopy_strata[stratum][0].cover_fraction
* patch[0].canopy_strata[stratum][0].cs.frootc;
patch[0].preday_totalc
+= patch[0].canopy_strata[stratum][0].cover_fraction
* patch[0].canopy_strata[stratum][0].cs.preday_totalc;
patch[0].preday_totaln
+= patch[0].canopy_strata[stratum][0].cover_fraction
* patch[0].canopy_strata[stratum][0].ns.preday_totaln;
}
patch[0].rootzone.depth = max(patch[0].rootzone.depth,
patch[0].canopy_strata[stratum][0].rootzone.depth);
}
patch[0].effective_lai = patch[0].effective_lai / patch[0].num_canopy_strata;
/*--------------------------------------------------------------*/
/* re-sort patch layers to account for any changes in */
/* height */
/*------------------------------------------------------------------------*/
sort_patch_layers(patch);
/*------------------------------------------------------------------------*/
/* compute current soil moisture potential */
/* do this before nitrogen updake occurs later in the day */
/*------------------------------------------------------------------------*/
patch[0].psi = compute_soil_water_potential(
command_line[0].verbose_flag,
patch[0].soil_defaults[0][0].theta_psi_curve,
patch[0].Tsoil,
-1.0*patch[0].soil_defaults[0][0].psi_max,
-10.0,
patch[0].soil_defaults[0][0].psi_air_entry,
patch[0].soil_defaults[0][0].pore_size_index,
patch[0].soil_defaults[0][0].p3,
patch[0].soil_defaults[0][0].p4,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].S);
if (command_line[0].grow_flag > 0) {
/*--------------------------------------------------------------*/
/* update litter interception capacity */
/*--------------------------------------------------------------*/
update_litter_interception_capacity(
patch[0].litter.moist_coef,
patch[0].litter.density,
&(patch[0].litter_cs),
&(patch[0].litter));
if (compute_potential_decomp(
patch[0].Tsoil,
patch[0].soil_defaults[0][0].psi_max,
patch[0].soil_defaults[0][0].psi_air_entry,
patch[0].rootzone.S,
patch[0].theta_std,
&(patch[0].soil_cs),
&(patch[0].soil_ns),
&(patch[0].litter_cs),
&(patch[0].litter_ns),
&(patch[0].cdf),
&(patch[0].ndf)
) != 0){
fprintf(stderr,"fATAL ERROR: in compute_potential_decomp() ... Exiting\n");
exit(EXIT_FAILURE);
}
}
return;
}/*end patch_daily_I.c*/
void input_new_strata(
struct command_line_object *command_line,
FILE *world_file,
int num_world_base_stations,
struct base_station_object **world_base_stations,
struct default_object *defaults,
struct patch_object *patch,
struct canopy_strata_object *canopy_strata)
{
/*--------------------------------------------------------------*/
/* Local function definition. */
/*--------------------------------------------------------------*/
struct base_station_object *assign_base_station(
int ,
int ,
struct base_station_object **);
int compute_annual_turnover(struct epconst_struct,
struct epvar_struct *,
struct cstate_struct *);
int compute_annual_litfall(
struct epconst_struct,
struct phenology_struct *,
struct cstate_struct *,
int);
int update_rooting_depth(
struct rooting_zone_object *,
double,
double,
double,
double);
double compute_delta_water(
int,
double,
double,
double,
double,
double);
double compute_lwp_predawn(
int,
int,
double,
double,
double,
double,
double,
double,
double,
double,
double,
double);
void *alloc( size_t,
char *,
char *);
param *readtag_worldfile(int *,
FILE *,
char *);
/*--------------------------------------------------------------*/
/* Local variable definition. */
/*--------------------------------------------------------------*/
int base_stationID;
int i, dtmp, num_lines;
char record[MAXSTR];
double rootc, ltmp;
int paramCnt=0;
param *paramPtr=NULL;
/*--------------------------------------------------------------*/
/* Read in the next canopy strata record for this patch. */
/*--------------------------------------------------------------*/
paramPtr = readtag_worldfile(¶mCnt,world_file,"Canopy_Strata");
dtmp = getIntWorldfile(¶mCnt,¶mPtr,"veg_parm_ID","%d",canopy_strata[0].veg_parm_ID,1);
if (dtmp > 0) canopy_strata[0].veg_parm_ID = dtmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cover_fraction","%lf",canopy_strata[0].cover_fraction,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cover_fraction = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"gap_fraction","%lf",canopy_strata[0].gap_fraction,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].gap_fraction = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"rootzone.depth","%lf",canopy_strata[0].rootzone.depth,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].rootzone.depth = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"snow_stored","%lf",canopy_strata[0].snow_stored,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].snow_stored = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"rain_stored","%lf",canopy_strata[0].rain_stored,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].rain_stored = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.cpool","%lf",canopy_strata[0].cs.cpool,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.cpool = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.leafc","%lf",canopy_strata[0].cs.leafc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.leafc = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.dead_leafc","%lf",canopy_strata[0].cs.dead_leafc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.dead_leafc = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.leafc_store","%lf",canopy_strata[0].cs.leafc_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.leafc_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.leafc_transfer","%lf",canopy_strata[0].cs.leafc_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.leafc_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.live_stemc","%lf",canopy_strata[0].cs.live_stemc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.live_stemc = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.livestemc_store","%lf",canopy_strata[0].cs.livestemc_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.livestemc_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.livestemc_transfer","%lf",canopy_strata[0].cs.livestemc_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.livestemc_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.dead_stemc","%lf",canopy_strata[0].cs.dead_stemc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.dead_stemc = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.deadstemc_store","%lf",canopy_strata[0].cs.deadstemc_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.deadstemc_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.deadstemc_transfer","%lf",canopy_strata[0].cs.deadstemc_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.deadstemc_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.live_crootc","%lf",canopy_strata[0].cs.live_crootc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.live_crootc = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.livecrootc_store","%lf",canopy_strata[0].cs.livecrootc_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.livecrootc_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.livecrootc_transfer","%lf",canopy_strata[0].cs.livecrootc_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.livecrootc_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.dead_crootc","%lf",canopy_strata[0].cs.dead_crootc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.dead_crootc = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.deadcrootc_store","%lf",canopy_strata[0].cs.deadcrootc_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.deadcrootc_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.deadcrootc_transfer","%lf",canopy_strata[0].cs.deadcrootc_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.deadcrootc_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.frootc","%lf",canopy_strata[0].cs.frootc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.frootc = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.frootc_store","%lf",canopy_strata[0].cs.frootc_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.frootc_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.frootc_transfer","%lf",canopy_strata[0].cs.frootc_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.frootc_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.cwdc","%lf",canopy_strata[0].cs.cwdc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.cwdc = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"epv.prev_leafcalloc","%lf",canopy_strata[0].epv.prev_leafcalloc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].epv.prev_leafcalloc = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.npool","%lf",canopy_strata[0].ns.npool,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.npool = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.leafn","%lf",canopy_strata[0].ns.leafn,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.leafn = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.dead_leafn","%lf",canopy_strata[0].ns.dead_leafn,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.dead_leafn = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.leafn_store","%lf",canopy_strata[0].ns.leafn_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.leafn_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.leafn_transfer","%lf",canopy_strata[0].ns.leafn_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.leafn_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.live_stemn","%lf",canopy_strata[0].ns.live_stemn,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.live_stemn = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.livestemn_store","%lf",canopy_strata[0].ns.livestemn_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.livestemn_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.livestemn_transfer","%lf",canopy_strata[0].ns.livestemn_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.livestemn_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.dead_stemn","%lf",canopy_strata[0].ns.dead_stemn,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.dead_stemn = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.deadstemn_store","%lf",canopy_strata[0].ns.deadstemn_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.deadstemn_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.deadstemn_transfer","%lf",canopy_strata[0].ns.deadstemn_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.deadstemn_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.live_crootn","%lf",canopy_strata[0].ns.live_crootn,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.live_crootn = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.livecrootn_store","%lf",canopy_strata[0].ns.livecrootn_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.livecrootn_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.livecrootn_transfer","%lf",canopy_strata[0].ns.livecrootn_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.livecrootn_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.dead_crootn","%lf",canopy_strata[0].ns.dead_crootn,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.dead_crootn = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.deadcrootn_store","%lf",canopy_strata[0].ns.deadcrootn_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.deadcrootn_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.deadcrootn_transfer","%lf",canopy_strata[0].ns.deadcrootn_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.deadcrootn_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.frootn","%lf",canopy_strata[0].ns.frootn,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.frootn = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.frootn_store","%lf",canopy_strata[0].ns.frootn_store,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.frootn_store = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.frootn_transfer","%lf",canopy_strata[0].ns.frootn_transfer,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.frootn_transfer = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.cwdn","%lf",canopy_strata[0].ns.cwdn,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.cwdn = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"ns.retransn","%lf",canopy_strata[0].ns.retransn,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].ns.retransn = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"cs.age","%lf",canopy_strata[0].cs.age,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].cs.age = ltmp;
/*--------------------------------------------------------------*/
/* intialized annual flux variables */
/*--------------------------------------------------------------*/
ltmp = getIntWorldfile(¶mCnt,¶mPtr,"epv.wstress_days","%d",canopy_strata[0].epv.wstress_days,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].epv.wstress_days = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"epv.max_fparabs","%lf",canopy_strata[0].epv.max_fparabs,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].epv.max_fparabs = ltmp;
ltmp = getDoubleWorldfile(¶mCnt,¶mPtr,"epv.min_vwc","%lf",canopy_strata[0].epv.min_vwc,1);
if (fabs(ltmp - NULLVAL) >= ONE) canopy_strata[0].epv.min_vwc = ltmp;
dtmp = getIntWorldfile(¶mCnt,¶mPtr,"n_basestations","%d",canopy_strata[0].num_base_stations,0);
/*--------------------------------------------------------------*/
/* Assign defaults for this canopy_strata */
/*--------------------------------------------------------------*/
if (canopy_strata[0].veg_parm_ID > 0) {
i=0;
while (defaults[0].stratum[i].ID != canopy_strata[0].veg_parm_ID) {
i++;
/*--------------------------------------------------------------*/
/* Report an error if no match was found. Otherwise assign */
/* the default to point to this canopy_strata. */
/*--------------------------------------------------------------*/
if ( i>= defaults[0].num_stratum_default_files ){
fprintf(stderr,
"\nFATAL ERROR: in construct_canopy_strata, canopy_strata default ID %d not found.\n" ,
canopy_strata[0].veg_parm_ID);
exit(EXIT_FAILURE);
}
} /* end-while */
canopy_strata[0].defaults[0] = &defaults[0].stratum[i];
}
/*--------------------------------------------------------------*/
/* zero all long term sinks */
/*--------------------------------------------------------------*/
canopy_strata[0].cs.gpsn_src = 0.0;
canopy_strata[0].cs.leaf_mr_snk = 0.0;
canopy_strata[0].cs.leaf_gr_snk = 0.0;
canopy_strata[0].cs.livestem_mr_snk = 0.0;
canopy_strata[0].cs.livestem_gr_snk = 0.0;
canopy_strata[0].cs.deadstem_gr_snk = 0.0;
canopy_strata[0].cs.livecroot_mr_snk = 0.0;
canopy_strata[0].cs.livecroot_gr_snk = 0.0;
canopy_strata[0].cs.deadcroot_gr_snk = 0.0;
canopy_strata[0].cs.froot_mr_snk = 0.0;
canopy_strata[0].cs.froot_gr_snk = 0.0;
canopy_strata[0].cs.nppcum = 0.0;
/*--------------------------------------------------------------*/
/* determine current lai and height based on current leaf carbon */
/* we need to initialize the sunlit/shaded proportions of LAI here */
/* (these will later be updated in update_phenology */
/* using Chen;s method */
/*--------------------------------------------------------------*/
canopy_strata[0].epv.proj_sla_sunlit = canopy_strata[0].defaults[0][0].epc.proj_sla;
canopy_strata[0].epv.proj_sla_shade = canopy_strata[0].defaults[0][0].epc.proj_sla *
canopy_strata[0].defaults[0][0].epc.shade_sla_mult;
if ( canopy_strata[0].cs.leafc <= 1.0/canopy_strata[0].epv.proj_sla_sunlit) {
canopy_strata[0].epv.proj_lai = canopy_strata[0].cs.leafc *
canopy_strata[0].epv.proj_sla_sunlit;
canopy_strata[0].epv.proj_lai_sunlit = canopy_strata[0].epv.proj_lai;
canopy_strata[0].epv.proj_lai_shade = 0.0;
}
else {
canopy_strata[0].epv.proj_lai = 1.0 + ( canopy_strata[0].cs.leafc -
1.0/canopy_strata[0].epv.proj_sla_sunlit) *
canopy_strata[0].epv.proj_sla_shade;
canopy_strata[0].epv.proj_lai_sunlit = 1.0;
canopy_strata[0].epv.proj_lai_shade = canopy_strata[0].epv.proj_lai - 1.0;
}
canopy_strata[0].epv.all_lai = canopy_strata[0].epv.proj_lai *
canopy_strata[0].defaults[0][0].epc.lai_ratio;
canopy_strata[0].epv.max_proj_lai = canopy_strata[0].epv.proj_lai;
if (canopy_strata[0].defaults[0][0].epc.veg_type == TREE)
canopy_strata[0].epv.height =
canopy_strata[0].defaults[0][0].epc.height_to_stem_coef
* pow((canopy_strata[0].cs.live_stemc+canopy_strata[0].cs.dead_stemc),
canopy_strata[0].defaults[0][0].epc.height_to_stem_exp);
else
canopy_strata[0].epv.height =
canopy_strata[0].defaults[0][0].epc.height_to_stem_coef
* pow((canopy_strata[0].cs.leafc + canopy_strata[0].cs.dead_leafc),
canopy_strata[0].defaults[0][0].epc.height_to_stem_exp);
/*--------------------------------------------------------------*/
/* calculate all sided and project pai from max projected lai */
/*--------------------------------------------------------------*/
if (canopy_strata[0].defaults[0][0].epc.veg_type == TREE) {
canopy_strata[0].epv.proj_pai = canopy_strata[0].epv.proj_lai
+ canopy_strata[0].defaults[0][0].epc.proj_swa
* (canopy_strata[0].cs.live_stemc
+ canopy_strata[0].cs.dead_stemc);
canopy_strata[0].epv.all_pai = canopy_strata[0].epv.all_lai
+ canopy_strata[0].defaults[0][0].epc.proj_swa
* (canopy_strata[0].cs.live_stemc
+ canopy_strata[0].cs.dead_stemc);
}
else {
canopy_strata[0].epv.proj_pai = canopy_strata[0].epv.proj_lai;
canopy_strata[0].epv.all_pai = canopy_strata[0].epv.all_lai;
}
/*--------------------------------------------------------------*/
/* initializae turnovers and litterfall */
/*--------------------------------------------------------------*/
if (compute_annual_turnover(canopy_strata[0].defaults[0][0].epc,
&(canopy_strata[0].epv),
&(canopy_strata[0].cs)) ){
fprintf(stderr,"FATAL ERROR: in compute_annual_turnover() ... Exiting\n");
exit(EXIT_FAILURE);
}
if (compute_annual_litfall(canopy_strata[0].defaults[0][0].epc,
&(canopy_strata[0].phen),
&(canopy_strata[0].cs), command_line[0].grow_flag) ){
fprintf(stderr,"FATAL ERROR: in compute_annual_litfall() ... Exiting\n");
exit(EXIT_FAILURE);
}
/*--------------------------------------------------------------*/
/* compute new rooting depth based on current root carbon */
/*--------------------------------------------------------------*/
if ( command_line[0].grow_flag != 0) {
rootc = canopy_strata[0].cs.frootc+canopy_strata[0].cs.live_crootc+canopy_strata[0].cs.dead_crootc;
if (rootc > ZERO){
if (update_rooting_depth(
&(canopy_strata[0].rootzone),
rootc,
canopy_strata[0].defaults[0][0].epc.root_growth_direction,
canopy_strata[0].defaults[0][0].epc.root_distrib_parm,
patch[0].soil_defaults[0][0].effective_soil_depth)){
fprintf(stderr,
"FATAL ERROR: in compute_rooting_depth() from construct_canopy_strata()\n");
exit(EXIT_FAILURE);
}
}
}
patch[0].rootzone.depth = max(patch[0].rootzone.depth, canopy_strata[0].rootzone.depth);
/*--------------------------------------------------------------*/
/* set phenology timing if static allocation */
/*--------------------------------------------------------------*/
if (canopy_strata[0].defaults[0][0].epc.phenology_flag == STATIC ) {
canopy_strata[0].phen.expand_startday =
canopy_strata[0].defaults[0][0].epc.day_leafon;
canopy_strata[0].phen.expand_stopday =
canopy_strata[0].phen.expand_startday
+ canopy_strata[0].defaults[0][0].epc.ndays_expand;
canopy_strata[0].phen.litfall_startday =
canopy_strata[0].defaults[0][0].epc.day_leafoff;
canopy_strata[0].phen.litfall_stopday =
canopy_strata[0].phen.litfall_startday
+ canopy_strata[0].defaults[0][0].epc.ndays_litfall;
if (canopy_strata[0].phen.expand_stopday > 365)
canopy_strata[0].phen.expand_stopday -= 365;
if (canopy_strata[0].phen.litfall_stopday > 365)
canopy_strata[0].phen.litfall_stopday -= 365;
/*---------------------------------------------------------------*/
/* assume this is 365 for now since we don't know when next */
/* year's growing season will start */
/*---------------------------------------------------------------*/
canopy_strata[0].phen.nretdays = 365;
}
else if (canopy_strata[0].defaults[0][0].epc.phenology_flag == DROUGHT ) {
canopy_strata[0].phen.expand_startday =
canopy_strata[0].defaults[0][0].epc.day_leafon;
canopy_strata[0].phen.expand_stopday =
canopy_strata[0].phen.expand_startday
+ canopy_strata[0].defaults[0][0].epc.ndays_expand;
canopy_strata[0].phen.litfall_startday =
canopy_strata[0].defaults[0][0].epc.day_leafoff;
canopy_strata[0].phen.litfall_stopday =
canopy_strata[0].phen.litfall_startday
+ canopy_strata[0].defaults[0][0].epc.ndays_litfall;
if (canopy_strata[0].phen.expand_stopday > 365)
canopy_strata[0].phen.expand_stopday -= 365;
if (canopy_strata[0].phen.litfall_stopday > 365)
canopy_strata[0].phen.litfall_stopday -= 365;
/*---------------------------------------------------------------*/
/* assume this is 365 for now since we don't know when next */
/* year's growing season will start */
/*---------------------------------------------------------------*/
canopy_strata[0].phen.nretdays = 365;
canopy_strata[0].phen.gwseasonday = -1;
canopy_strata[0].phen.lfseasonday = -1;
canopy_strata[0].phen.pheno_flag = 0;
}
else {
fprintf(stderr,"\nFATAL ERROR - construct_canopy_stratum.c");
fprintf(stderr,"\n phenology flag must be set to 0 for STATIC");
fprintf(stderr,"\n since dynamic phenology timing not yet implemented");
exit(EXIT_FAILURE);
}
/*--------------------------------------------------------------*/
/* initialize runnning average of psi using current day psi */
/*--------------------------------------------------------------*/
if (canopy_strata[0].rootzone.depth > ZERO)
canopy_strata[0].rootzone.potential_sat = compute_delta_water(
command_line[0].verbose_flag,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].soil_depth,
canopy_strata[0].rootzone.depth,
0.0);
canopy_strata[0].rootzone.S = min(patch[0].rz_storage / canopy_strata[0].rootzone.potential_sat, 1.0);
canopy_strata[0].epv.psi = compute_lwp_predawn(
command_line[0].verbose_flag,
patch[0].soil_defaults[0][0].theta_psi_curve,
patch[0].Tsoil,
canopy_strata[0].defaults[0][0].epc.psi_open,
canopy_strata[0].defaults[0][0].epc.psi_close,
patch[0].soil_defaults[0][0].psi_air_entry,
patch[0].soil_defaults[0][0].pore_size_index,
patch[0].soil_defaults[0][0].p3,
patch[0].soil_defaults[0][0].p4,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
canopy_strata[0].rootzone.S);
canopy_strata[0].epv.psi_ravg = canopy_strata[0].epv.psi;
/*--------------------------------------------------------------*/
/* for now initialize these accumuling variables */
/*--------------------------------------------------------------*/
if (fabs(ltmp - NULLVAL) >= ONE) {
canopy_strata[0].epv.wstress_days = 0;
canopy_strata[0].epv.max_fparabs = 0.0;
canopy_strata[0].epv.min_vwc = 1.0;
//canopy_strata[0].cs.age = 0;
canopy_strata[0].cs.num_resprout = 0;
}
/*--------------------------------------------------------------*/
/* Read in the number of strata base stations */
/*--------------------------------------------------------------*/
/* fscanf(world_file,"%d",&(dtmp));
read_record(world_file, record);*/
if (dtmp > 0) {
canopy_strata[0].num_base_stations = dtmp;
/*--------------------------------------------------------------*/
/* Allocate a list of base stations for this strata. */
/*--------------------------------------------------------------*/
canopy_strata[0].base_stations = (struct base_station_object **)
alloc(canopy_strata[0].num_base_stations *
sizeof(struct base_station_object *),"base_stations",
"construct_canopy_strata");
/*--------------------------------------------------------------*/
/* Read each base_station ID and then point to that base_statio*/
/*--------------------------------------------------------------*/
for (i=0 ; i<canopy_strata[0].num_base_stations; i++){
fscanf(world_file,"%d",&(base_stationID));
read_record(world_file, record);
/*--------------------------------------------------------------*/
/* Point to the appropriate base station in the base */
/* station list for this world. */
/* */
/*--------------------------------------------------------------*/
canopy_strata[0].base_stations[i] = assign_base_station(
base_stationID,
num_world_base_stations,
world_base_stations);
} /*end for*/
}
if(paramPtr!=NULL){
free(paramPtr);
}
return;
} /*end input_new_strata.c*/
void update_drainage_road(
struct patch_object *patch,
struct command_line_object *command_line,
double time_int,
int verbose_flag)
{
/*--------------------------------------------------------------*/
/* Local function definition. */
/*--------------------------------------------------------------*/
double compute_delta_water(
int,
double,
double,
double,
double,
double);
double compute_N_leached(int,
double,
double,
double,
double,
double,
double,
double,
double,
double,
double,
double,
double, double *);
double compute_varbased_flow(
int,
double,
double,
double,
double,
double *);
double recompute_gamma(
struct patch_object *,
double);
double compute_varbased_returnflow(
double,
double,
double,
struct litter_object *);
/*--------------------------------------------------------------*/
/* Local variable definition. */
/*--------------------------------------------------------------*/
int i, j,k,d;
double m, Ksat, return_flow;
double NO3_leached_to_patch, NO3_leached_to_stream, NO3_surface_leached_to_stream; /* kg/m2 */
double NH4_leached_to_patch, NH4_leached_to_stream, NH4_surface_leached_to_stream; /* kg/m2 */
double N_leached_total; /* kg/m2 */
double DON_leached_to_patch, DON_leached_to_stream, DON_surface_leached_to_stream; /* kg/m2 */
double DON_leached_total; /* kg/m2 */
double DOC_leached_to_patch, DOC_leached_to_stream, DOC_surface_leached_to_stream; /* kg/m2 */
double DOC_leached_total; /* kg/m2 */
double route_to_stream; /* m3 */
double route_to_patch; /* m3 */
double road_int_depth; /* m of H2O */
double available_sat_water, route_total; /* m3 */
double Qin, Qout, Qstr_total; /* m */
double total_gamma, percent_loss;
double Nin, Nout; /* kg/m2 */
double percent_tobe_routed;
struct patch_object *neigh;
DOC_leached_to_patch = 0.0;
DOC_leached_to_stream = 0.0;
DOC_surface_leached_to_stream = 0.0;
DON_leached_to_patch = 0.0;
DON_leached_to_stream = 0.0;
DON_surface_leached_to_stream = 0.0;
NH4_leached_to_patch = 0.0;
NH4_leached_to_stream = 0.0;
NH4_surface_leached_to_stream = 0.0;
NO3_leached_to_patch = 0.0;
NO3_leached_to_stream = 0.0;
NO3_surface_leached_to_stream = 0.0;
route_to_stream = 0.0;
route_to_patch = 0.0;
return_flow=0.0;
/*--------------------------------------------------------------*/
/* m and K are multiplied by sensitivity analysis variables */
/*--------------------------------------------------------------*/
m = patch[0].m ;
Ksat = patch[0].soil_defaults[0][0].Ksat_0 ;
d=0;
/*--------------------------------------------------------------*/
/* recalculate gamma based on current saturation deficits */
/* to account the effect of changes in water table slope */
/*--------------------------------------------------------------*/
total_gamma = recompute_gamma(patch, patch[0].innundation_list[d].gamma);
available_sat_water = max(((patch[0].soil_defaults[0][0].soil_water_cap
- max(patch[0].sat_deficit,0.0))
* patch[0].area),0.0);
/*--------------------------------------------------------------*/
/* for roads, saturated throughflow beneath road cut */
/* is routed to downslope patches; saturated throughflow */
/* above the cut and overland flow is routed to the stream */
/*--------------------------------------------------------------*/
/*--------------------------------------------------------------*/
/* calculate water_equivalent depth of road */
/*--------------------------------------------------------------*/
road_int_depth = compute_delta_water(
verbose_flag,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].road_cut_depth,
0.0);
if (road_int_depth > patch[0].sat_deficit) {
/*------------------------------------------------------------*/
/* calculate amuount of water output to patches */
/*-----------------------------------------------------------*/
route_to_patch = time_int * compute_varbased_flow(
patch[0].num_soil_intervals,
patch[0].std * command_line[0].std_scale,
road_int_depth,
total_gamma,
patch[0].soil_defaults[0][0].interval_size,
patch[0].transmissivity_profile);
/*-----------------------------------------------------------*/
/* calculate amuount of water output to stream */
/*-----------------------------------------------------------*/
route_to_stream = time_int * compute_varbased_flow(
patch[0].num_soil_intervals,
patch[0].std * command_line[0].std_scale,
patch[0].sat_deficit,
total_gamma,
patch[0].soil_defaults[0][0].interval_size,
patch[0].transmissivity_profile) - route_to_patch;
if (route_to_patch < 0.0) route_to_patch = 0.0;
if (route_to_stream < 0.0) route_to_stream = 0.0;
if ((route_to_stream + route_to_patch) > available_sat_water) {
route_to_patch *= (available_sat_water)/(route_to_patch + route_to_stream);
route_to_stream *= (available_sat_water)/(route_to_patch + route_to_stream);
}
/*--------------------------------------------------------------*/
/* compute Nitrogen leaching amount */
/*--------------------------------------------------------------*/
if (command_line[0].grow_flag > 0) {
NO3_leached_to_patch = compute_N_leached(
verbose_flag,
patch[0].soil_ns.nitrate,
route_to_patch / patch[0].area,
road_int_depth,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].N_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].NO3_adsorption_rate,
patch[0].transmissivity_profile);
NO3_leached_to_stream = compute_N_leached(
verbose_flag,
patch[0].soil_ns.nitrate,
route_to_stream / patch[0].area,
patch[0].sat_deficit,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].N_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].NO3_adsorption_rate,
patch[0].transmissivity_profile) -
NO3_leached_to_patch;
if (NO3_leached_to_stream < 0.0) NO3_leached_to_stream = 0.0;
patch[0].soil_ns.NO3_Qout += (NO3_leached_to_patch + NO3_leached_to_stream);
NH4_leached_to_patch = compute_N_leached(
verbose_flag,
patch[0].soil_ns.sminn,
route_to_patch / patch[0].area,
road_int_depth,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].N_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].NH4_adsorption_rate,
patch[0].transmissivity_profile);
NH4_leached_to_stream = compute_N_leached(
verbose_flag,
patch[0].soil_ns.nitrate,
route_to_stream / patch[0].area,
patch[0].sat_deficit,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].N_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].NH4_adsorption_rate,
patch[0].transmissivity_profile) -
NH4_leached_to_patch;
if (NH4_leached_to_stream < 0.0) NH4_leached_to_stream = 0.0;
patch[0].soil_ns.NH4_Qout += (NH4_leached_to_patch + NH4_leached_to_stream);
DON_leached_to_patch = compute_N_leached(
verbose_flag,
patch[0].soil_ns.DON,
route_to_patch / patch[0].area,
road_int_depth,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].DOM_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].DON_adsorption_rate,
patch[0].transmissivity_profile);
DON_leached_to_stream = compute_N_leached(
verbose_flag,
patch[0].soil_ns.DON,
route_to_stream / patch[0].area,
patch[0].sat_deficit,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].DOM_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].DON_adsorption_rate,
patch[0].transmissivity_profile) -
DON_leached_to_patch;
if (DON_leached_to_stream < 0.0) DON_leached_to_stream = 0.0;
patch[0].soil_ns.DON_Qout += (DON_leached_to_patch + DON_leached_to_stream);
DOC_leached_to_patch = compute_N_leached(
verbose_flag,
patch[0].soil_cs.DOC,
route_to_patch / patch[0].area,
road_int_depth,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].DOM_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].DOC_adsorption_rate,
patch[0].transmissivity_profile);
DOC_leached_to_stream = compute_N_leached(
verbose_flag,
patch[0].soil_cs.DOC,
route_to_stream / patch[0].area,
patch[0].sat_deficit,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].DOM_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].DOC_adsorption_rate,
patch[0].transmissivity_profile) -
DOC_leached_to_patch;
if (DOC_leached_to_stream < 0.0) DOC_leached_to_stream = 0.0;
patch[0].soil_cs.DOC_Qout += (DOC_leached_to_patch + DOC_leached_to_stream);
}
patch[0].Qout += ((route_to_patch + route_to_stream) / patch[0].area);
}
/*--------------------------------------------------------------*/
/* if road is below the water_table - no routing to the stream */
/*--------------------------------------------------------------*/
else {
route_to_stream = 0.0;
route_to_patch = time_int * compute_varbased_flow(
patch[0].num_soil_intervals,
patch[0].std * command_line[0].std_scale,
patch[0].sat_deficit,
total_gamma,
patch[0].soil_defaults[0][0].interval_size,
patch[0].transmissivity_profile);
if (route_to_patch < 0.0) route_to_patch = 0.0;
if (route_to_patch > available_sat_water)
route_to_patch = available_sat_water;
/*--------------------------------------------------------------*/
/* compute Nitrogen leaching amount */
/*--------------------------------------------------------------*/
if (command_line[0].grow_flag > 0) {
NO3_leached_to_patch = compute_N_leached(
verbose_flag,
patch[0].soil_ns.nitrate,
route_to_patch / patch[0].area,
patch[0].sat_deficit,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].N_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].NO3_adsorption_rate,
patch[0].transmissivity_profile);
NO3_leached_to_stream = 0.0;
patch[0].soil_ns.NO3_Qout += (NO3_leached_to_patch + NO3_leached_to_stream);
NH4_leached_to_patch = compute_N_leached(
verbose_flag,
patch[0].soil_ns.sminn,
route_to_patch / patch[0].area,
patch[0].sat_deficit,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].N_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].NH4_adsorption_rate,
patch[0].transmissivity_profile);
NH4_leached_to_stream = 0.0;
patch[0].soil_ns.NH4_Qout += (NH4_leached_to_patch + NH4_leached_to_stream);
DON_leached_to_patch = compute_N_leached(
verbose_flag,
patch[0].soil_ns.DON,
route_to_patch / patch[0].area,
patch[0].sat_deficit,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].DOM_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].DON_adsorption_rate,
patch[0].transmissivity_profile);
DON_leached_to_stream = 0.0;
patch[0].soil_ns.DON_Qout += (DON_leached_to_patch + DON_leached_to_stream);
DOC_leached_to_patch = compute_N_leached(
verbose_flag,
patch[0].soil_cs.DOC,
route_to_patch / patch[0].area,
patch[0].sat_deficit,
patch[0].soil_defaults[0][0].soil_water_cap,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].DOM_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].DOC_adsorption_rate,
patch[0].transmissivity_profile);
DOC_leached_to_stream = 0.0;
patch[0].soil_cs.DOC_Qout += (DOC_leached_to_patch + DOC_leached_to_stream);
}
patch[0].Qout += ((route_to_patch + route_to_stream) / patch[0].area);
}
/*--------------------------------------------------------------*/
/* calculate any return flow associated with this patch */
/* and route any infiltration excess */
/* return flow is flow leaving patch (i.e surface_Qout) */
/* note that return flow that becomes detention storage */
/* is added to surface_Qin */
/* similarly with associated nitrogen */
/* note we move unsat_storage into saturated storage in this case */
/* saturated zone will be updated in compute_subsurface_routing */
/* i.e becomes part of Qout */
/*--------------------------------------------------------------*/
if ((patch[0].sat_deficit-patch[0].rz_storage-patch[0].unsat_storage) < -1.0*ZERO) {
return_flow = compute_varbased_returnflow(patch[0].std * command_line[0].std_scale,
patch[0].rz_storage+patch[0].unsat_storage,
patch[0].sat_deficit, &(patch[0].litter));
patch[0].detention_store += return_flow;
patch[0].sat_deficit += (return_flow - (patch[0].unsat_storage+patch[0].rz_storage));;
patch[0].unsat_storage = 0.0;
patch[0].rz_storage = 0.0;
}
/*--------------------------------------------------------------*/
/* calculated any N-transport associated with return flow */
/* -note available N reduced by what has already been */
/* lost in subsurface flow routing */
/* - note only nitrate is assumed to follow return flow */
/*--------------------------------------------------------------*/
if (command_line[0].grow_flag > 0) {
Nout = compute_N_leached(
verbose_flag,
patch[0].soil_ns.nitrate - NO3_leached_to_patch,
return_flow,
0.0,
0.0,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].N_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].NO3_adsorption_rate,
patch[0].transmissivity_profile);
patch[0].surface_NO3 += Nout;
patch[0].soil_ns.NO3_Qout += Nout;
Nout = compute_N_leached(
verbose_flag,
patch[0].soil_ns.sminn- NH4_leached_to_patch,
return_flow,
0.0,
0.0,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].N_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].NH4_adsorption_rate,
patch[0].transmissivity_profile);
patch[0].surface_NH4 += Nout;
patch[0].soil_ns.NH4_Qout += Nout;
Nout = compute_N_leached(
verbose_flag,
patch[0].soil_ns.DON - DON_leached_to_patch,
return_flow,
0.0,
0.0,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].DOM_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].DON_adsorption_rate,
patch[0].transmissivity_profile);
patch[0].surface_DON += Nout;
patch[0].soil_ns.DON_Qout += Nout;
Nout = compute_N_leached(
verbose_flag,
patch[0].soil_cs.DOC - DOC_leached_to_patch,
return_flow,
0.0,
0.0,
m,
total_gamma / patch[0].area * time_int,
patch[0].soil_defaults[0][0].porosity_0,
patch[0].soil_defaults[0][0].porosity_decay,
patch[0].soil_defaults[0][0].DOM_decay_rate,
patch[0].soil_defaults[0][0].active_zone_z,
patch[0].soil_defaults[0][0].soil_depth,
patch[0].soil_defaults[0][0].DOC_adsorption_rate,
patch[0].transmissivity_profile);
patch[0].surface_DOC += Nout;
patch[0].soil_cs.DOC_Qout += Nout;
}
/*--------------------------------------------------------------*/
/* route water and nitrogen lossed due to infiltration excess */
/* note we assume that this happens before return_flow losses */
/*--------------------------------------------------------------*/
if ((patch[0].detention_store > patch[0].soil_defaults[0][0].detention_store_size) &&
(patch[0].detention_store > ZERO) ) {
Qout = (patch[0].detention_store - patch[0].soil_defaults[0][0].detention_store_size);
if (command_line[0].grow_flag > 0) {
Nout = (min(1.0, (Qout/ patch[0].detention_store))) * patch[0].surface_NO3;
patch[0].surface_NO3 -= Nout;
patch[0].next_stream[0].streamflow_NO3 += (Nout * patch[0].area / patch[0].next_stream[0].area);
Nout = (min(1.0, (Qout/ patch[0].detention_store))) * patch[0].surface_NH4;
patch[0].surface_NH4 -= Nout;
patch[0].next_stream[0].streamflow_NH4 += (Nout * patch[0].area / patch[0].next_stream[0].area);
Nout = (min(1.0, (Qout/ patch[0].detention_store))) * patch[0].surface_DON;
patch[0].surface_DON -= Nout;
patch[0].next_stream[0].streamflow_DON += (Nout * patch[0].area / patch[0].next_stream[0].area);
Nout = (min(1.0, (Qout/ patch[0].detention_store))) * patch[0].surface_DOC;
patch[0].surface_DOC -= Nout;
patch[0].next_stream[0].streamflow_DOC += (Nout * patch[0].area / patch[0].next_stream[0].area);
}
patch[0].next_stream[0].streamflow += (Qout * patch[0].area / patch[0].next_stream[0].area);
patch[0].detention_store -= Qout;
}
/*--------------------------------------------------------------*/
/* route flow to neighbours */
/* route n_leaching if grow flag specfied */
/*--------------------------------------------------------------*/
/*--------------------------------------------------------------*/
/* routing to stream i.e. diversion routing */
/* note all surface flows go to the stream */
/*--------------------------------------------------------------*/
patch[0].next_stream[0].streamflow += (route_to_stream) / patch[0].next_stream[0].area;
patch[0].next_stream[0].surface_Qin += (route_to_stream) / patch[0].next_stream[0].area;
if (command_line[0].grow_flag > 0) {
Nin = (DON_leached_to_stream * patch[0].area) / patch[0].next_stream[0].area;
patch[0].next_stream[0].streamflow_DON += Nin;
Nin = (DOC_leached_to_stream * patch[0].area) / patch[0].next_stream[0].area;
patch[0].next_stream[0].streamflow_DOC += Nin;
Nin = (NO3_leached_to_stream * patch[0].area) / patch[0].next_stream[0].area;
patch[0].next_stream[0].streamflow_NO3 += Nin;
Nin = (NH4_leached_to_stream * patch[0].area) / patch[0].next_stream[0].area;
patch[0].next_stream[0].streamflow_NH4 += Nin;
}
/*--------------------------------------------------------------*/
/* route flow to neighbours */
/* route n_leaching if grow flag specfied */
/*--------------------------------------------------------------*/
/*--------------------------------------------------------------*/
/* regular downslope routing */
/*--------------------------------------------------------------*/
d=0;
for (j = 0; j < patch[0].innundation_list[d].num_neighbours; j++) {
neigh = patch[0].innundation_list[d].neighbours[j].patch;
/*--------------------------------------------------------------*/
/* first transfer subsurface water and nitrogen */
/*--------------------------------------------------------------*/
Qin = (patch[0].innundation_list[d].neighbours[j].gamma * route_to_patch) / neigh[0].area;
if (command_line[0].grow_flag > 0) {
Nin = (patch[0].innundation_list[d].neighbours[j].gamma * NO3_leached_to_patch * patch[0].area)
/ neigh[0].area;
neigh[0].soil_ns.NO3_Qin += Nin;
Nin = (patch[0].innundation_list[d].neighbours[j].gamma * NH4_leached_to_patch * patch[0].area)
/ neigh[0].area;
neigh[0].soil_ns.NH4_Qin += Nin;
Nin = (patch[0].innundation_list[d].neighbours[j].gamma * DON_leached_to_patch * patch[0].area)
/ neigh[0].area;
neigh[0].soil_ns.DON_Qin += Nin;
Nin = (patch[0].innundation_list[d].neighbours[j].gamma * DOC_leached_to_patch * patch[0].area)
/ neigh[0].area;
neigh[0].soil_cs.DOC_Qin += Nin;
}
neigh[0].Qin += Qin;
}
} /*end update_drainage_road.c*/
struct soil_default *construct_soil_defaults(
int num_default_files,
char **default_files,
struct command_line_object *command_line)
{
/*--------------------------------------------------------------*/
/* Local function definition. */
/*--------------------------------------------------------------*/
void *alloc( size_t,
char *,
char *);
double compute_delta_water(int, double, double, double, double, double);
/*--------------------------------------------------------------*/
/* Local variable definition. */
/*--------------------------------------------------------------*/
int strbufLen = 256;
int filenameLen = 1024;
int i;
double ftmp,soil;
FILE *default_file;
char strbuf[strbufLen];
char outFilename[filenameLen];
char *newrecord;
char record[MAXSTR];
struct soil_default *default_object_list;
void *alloc( size_t, char *, char *);
param *paramPtr = NULL;
int paramCnt = 0;
/*--------------------------------------------------------------*/
/* Allocate an array of default objects. */
/*--------------------------------------------------------------*/
default_object_list = (struct soil_default *)
alloc(num_default_files * sizeof(struct soil_default),"default_object_list",
"construct_soil_defaults");
/*--------------------------------------------------------------*/
/* Loop through the default files list. */
/*--------------------------------------------------------------*/
for (i=0 ; i<num_default_files; i++){
/*--------------------------------------------------------------*/
/* Try to open the ith default file. */
/*--------------------------------------------------------------*/
//if ( (default_file = fopen( default_files[i], "r")) == NULL ){
// fprintf(stderr,"FATAL ERROR:in construct_soil_defaults",
// "unable to open defaults file %d.\n",i);
// exit(EXIT_FAILURE);
//} /*end if*/
printf("Reading %s\n", default_files[i]);
paramCnt = 0;
if (paramPtr != NULL)
free(paramPtr);
paramPtr = readParamFile(¶mCnt, default_files[i]);
/*--------------------------------------------------------------*/
/* read the ith default file into the ith object. */
/*--------------------------------------------------------------*/
default_object_list[i].ID = getIntParam(¶mCnt, ¶mPtr, "patch_default_ID", "%d", 3, 1);
default_object_list[i].theta_psi_curve = getIntParam(¶mCnt, ¶mPtr, "theta_psi_curve", "%d", 1.0, 1);
default_object_list[i].Ksat_0 = getDoubleParam(¶mCnt, ¶mPtr, "Ksat_0", "%lf", 3.0, 1);
default_object_list[i].m = getDoubleParam(¶mCnt, ¶mPtr, "m", "%lf", 0.12, 1);
default_object_list[i].porosity_0 = getDoubleParam(¶mCnt, ¶mPtr, "porosity_0", "%lf", 0.435, 1);
default_object_list[i].porosity_decay = getDoubleParam(¶mCnt, ¶mPtr, "porosity_decay", "%lf", 4000.0, 1);
default_object_list[i].p3 = getDoubleParam(¶mCnt, ¶mPtr, "P3", "%lf", 0.0, 1); // param name upper case in param file
default_object_list[i].pore_size_index = getDoubleParam(¶mCnt, ¶mPtr, "pore_size_index", "%lf", 0.204, 1);
default_object_list[i].psi_air_entry = getDoubleParam(¶mCnt, ¶mPtr, "psi_air_entry", "%lf", 0.218, 1);
default_object_list[i].psi_max = getDoubleParam(¶mCnt, ¶mPtr, "psi_max", "%lf", 0.01, 1);
default_object_list[i].soil_depth = getDoubleParam(¶mCnt, ¶mPtr, "soil_depth", "%lf", 200.0, 1);
default_object_list[i].m_z = getDoubleParam(¶mCnt, ¶mPtr, "m_z", "%lf", 0.4, 1);
default_object_list[i].detention_store_size = getDoubleParam(¶mCnt, ¶mPtr, "detention_store_size", "%lf", 0.0, 1);
default_object_list[i].deltaz = getDoubleParam(¶mCnt, ¶mPtr, "deltaZ", "%lf", 1.0, 1); // param name contains uppercase "Z" in param file
default_object_list[i].active_zone_z = getDoubleParam(¶mCnt, ¶mPtr, "active_zone_z", "%lf", 10.0, 1);
if (abs(default_object_list[i].active_zone_z - default_object_list[i].soil_depth) > 0.5) {
printf("\nNote that soil depth used for biogeochem cycling (active zone z)");
printf("\nis more than 0.5 meter different from hydrologic soil depth");
printf("\nfor soil default file: %s\n", default_files[i] );
}
default_object_list[i].maximum_snow_energy_deficit = getDoubleParam(¶mCnt, ¶mPtr, "maximum_snow_energy_deficit", "%lf", -10.0, 1);
default_object_list[i].snow_water_capacity = getDoubleParam(¶mCnt, ¶mPtr, "snow_water_capacity", "%lf", 0.0, 1);
default_object_list[i].snow_light_ext_coef = getDoubleParam(¶mCnt, ¶mPtr, "snow_light_ext_coef", "%lf", 10000.0, 1);
default_object_list[i].snow_melt_Tcoef = getDoubleParam(¶mCnt, ¶mPtr, "snow_melt_Tcoef", "%lf", 0.05, 1);
/*
default_object_list[i].snow_melt_Tcoef *= command_line[0].tmp_value;
*/
default_object_list[i].max_heat_capacity = getDoubleParam(¶mCnt, ¶mPtr, "max_heat_capacity", "%lf", 0.0, 1);
default_object_list[i].min_heat_capacity = getDoubleParam(¶mCnt, ¶mPtr, "min_heat_capacity", "%lf", 0.0, 1);
default_object_list[i].albedo = getDoubleParam(¶mCnt, ¶mPtr, "albedo", "%lf", 0.28, 1);
default_object_list[i].NO3_adsorption_rate = getDoubleParam(¶mCnt, ¶mPtr, "NO3_adsorption_rate", "%lf", 0.0, 1);
default_object_list[i].N_decay_rate = getDoubleParam(¶mCnt, ¶mPtr, "N_decay", "%lf", 0.12, 1);
/*
if (command_line[0].tmp_value > ZERO)
default_object_list[i].N_decay_rate *= command_line[0].tmp_value;
*/
default_object_list[i].soil_type.sand = getDoubleParam(¶mCnt, ¶mPtr, "sand", "%lf", 0.7, 1);
default_object_list[i].soil_type.silt = getDoubleParam(¶mCnt, ¶mPtr, "silt", "%lf", 0.2, 1);
default_object_list[i].soil_type.clay = getDoubleParam(¶mCnt, ¶mPtr, "clay", "%lf", 0.1, 1);
soil = default_object_list[i].soil_type.sand
+ default_object_list[i].soil_type.silt
+ default_object_list[i].soil_type.clay;
if (abs(soil - 1.0) > ZERO) {
fprintf(stderr,
"FATAL ERROR:in construct_soil_defaults\n proportion sand, silt, clay = %f\n\n", soil);
printf("\n %d - %f %f %f %f \n",
default_object_list[i].ID,
default_object_list[i].N_decay_rate,
default_object_list[i].soil_type.sand,
default_object_list[i].soil_type.silt,
default_object_list[i].soil_type.clay);
} /*end if*/
if (command_line[0].gw_flag > 0) {
default_object_list[i].sat_to_gw_coeff = getDoubleParam(¶mCnt, ¶mPtr, "sat_to_gw_coeff", "%lf", 1.0, 1);
default_object_list[i].sat_to_gw_coeff *= command_line[0].sat_to_gw_coeff_mult;
}
/*--------------------------------------------------------------*/
/* vertical soil m and K are initized using soil default */
/* but sensitivity analysis -s is not applied to them */
/* use -sv to change these parameters */
/*--------------------------------------------------------------*/
default_object_list[i].m_v = default_object_list[i].m;
default_object_list[i].mz_v = default_object_list[i].m_z;
default_object_list[i].Ksat_0_v = default_object_list[i].Ksat_0;
/*--------------------------------------------------------------*/
/* sensitivity adjustment of vertical drainage soil paramters */
/*--------------------------------------------------------------*/
if (command_line[0].vsen_flag > 0) {
default_object_list[i].m_v *= command_line[0].vsen[M];
default_object_list[i].mz_v *= command_line[0].vsen[M];
default_object_list[i].Ksat_0_v *= command_line[0].vsen[K];
}
/*--------------------------------------------------------------*/
/* sensitivity adjustment of soil drainage paramters */
/*--------------------------------------------------------------*/
if (command_line[0].sen_flag > 0) {
default_object_list[i].m *= command_line[0].sen[M];
default_object_list[i].m_z *= command_line[0].sen[M];
default_object_list[i].Ksat_0 *= command_line[0].sen[K];
default_object_list[i].soil_depth *= command_line[0].sen[SOIL_DEPTH];
}
/*--------------------------------------------------------------*/
/* calculate water_equivalent depth of soil */
/*--------------------------------------------------------------*/
default_object_list[i].soil_water_cap = compute_delta_water(
0, default_object_list[i].porosity_0,
default_object_list[i].porosity_decay,
default_object_list[i].soil_depth,
default_object_list[i].soil_depth,
0.0);
/*--------------------------------------------------------------*/
/* initialization of optional default file parms */
/*--------------------------------------------------------------*/
default_object_list[i].theta_mean_std_p1 = getDoubleParam(¶mCnt, ¶mPtr, "theta_mean_std_p1", "%lf", 0.0, 1);
default_object_list[i].theta_mean_std_p2 = getDoubleParam(¶mCnt, ¶mPtr, "theta_mean_std_p2", "%lf", 0.0, 1);
default_object_list[i].gl_c = getDoubleParam(¶mCnt, ¶mPtr, "gl_c", "%lf", 0.0062, 1);
default_object_list[i].gsurf_slope = getDoubleParam(¶mCnt, ¶mPtr, "gsurf_slope ", "%lf", 0.01, 1);
default_object_list[i].gsurf_intercept = getDoubleParam(¶mCnt, ¶mPtr, "gsurf_intercept", "%lf", 0.001, 1);
default_object_list[i].p4 = getDoubleParam(¶mCnt, ¶mPtr, "p4", "%lf", -1.5, 1);
default_object_list[i].DOM_decay_rate = getDoubleParam(¶mCnt, ¶mPtr, "DOM_decay_rate", "%lf", 0.05, 1);
default_object_list[i].NH4_adsorption_rate = getDoubleParam(¶mCnt, ¶mPtr, "NH4_adsorption_rate", "%lf", 0.000005, 1);
default_object_list[i].DON_production_rate = getDoubleParam(¶mCnt, ¶mPtr, "DON_production_rate", "%lf", 0.03, 1);
default_object_list[i].DOC_adsorption_rate = getDoubleParam(¶mCnt, ¶mPtr, "DOC_adsorption_rate", "%lf", 0.000023, 1);
default_object_list[i].DON_adsorption_rate = getDoubleParam(¶mCnt, ¶mPtr, "DON_adsorption_rate", "%lf", 0.000001, 1);
default_object_list[i].interval_size = getDoubleParam(¶mCnt, ¶mPtr, "interval_size", "%lf", INTERVAL_SIZE, 1);
/*--------------------------------------------------------------*/
/* sensitivity adjustment of vertical drainage soil paramters */
/* an scale Pore size index and psi air entry or other parameters */
/* that control moisture retention (if curve 3 is used) */
/*--------------------------------------------------------------*/
if (command_line[0].vsen_alt_flag > 0) {
if (default_object_list[i].theta_psi_curve != 3) {
default_object_list[i].psi_air_entry *= command_line[0].vsen_alt[PA];
default_object_list[i].pore_size_index *= command_line[0].vsen_alt[PO];
if (default_object_list[0].pore_size_index >= 1.0) {
printf("\n Sensitivity analysis giving Pore Size Index > 1.0, not allowed, setting to 1.0\n");
default_object_list[i].pore_size_index = 0.999;
}
}
else {
default_object_list[i].p3 *= command_line[0].vsen_alt[PA];
default_object_list[i].p4 *= command_line[0].vsen_alt[PO];
}
}
/*--------------------------------------------------------------*/
/* Close the ith default file. */
/*--------------------------------------------------------------*/
memset(strbuf, '\0', strbufLen);
strcpy(strbuf, default_files[i]);
char *s = strbuf;
char *y = NULL;
char *token = NULL;
char filename[256];
// Store filename portion of path in 't'
while ((token = strtok(s, "/")) != NULL) {
// Save the latest component of the filename
strcpy(filename, token);
s = NULL;
}
// Remove the file extension, if one exists
memset(strbuf, '\0', strbufLen);
strcpy(strbuf, filename);
free(s);
s = strbuf;
token = strtok(s, ".");
if (token != NULL) {
strcpy(filename, token);
}
memset(outFilename, '\0', filenameLen);
// Concatenate the output prefix with the filename of the input .def file
// and "_soil.params"
if (command_line[0].output_prefix != NULL) {
strcat(outFilename, command_line[0].output_prefix);
if (filename != NULL) {
strcat(outFilename, "_");
strcat(outFilename, filename);
}
strcat(outFilename, "_soil.params");
}
else {
if (filename != NULL) {
strcat(outFilename, "_");
strcat(outFilename, filename);
}
strcat(outFilename, "soil.params");
}
printParams(paramCnt, paramPtr, outFilename);
} /*end for*/
return(default_object_list);
} /*end construct_soil_defaults*/
