diff --git a/SW_Defines.h b/SW_Defines.h index 779777765..3273d07d7 100644 --- a/SW_Defines.h +++ b/SW_Defines.h @@ -33,7 +33,6 @@ #define MAX_LAYERS 25 #define MAX_TRANSP_REGIONS 4 #define MAX_ST_RGR 100 -#define NVEGTYPES 4 #define MAX_NYEAR 2500 /**< An integer representing the max calendar year that is supported. The number just needs to be reasonable, it is an artifical limit. */ @@ -64,16 +63,24 @@ #define SW_MIN 0 #define SW_MAX 1 +/* indices to vegetation types */ +#define NVEGTYPES 4 +#define SW_TREES 0 +#define SW_SHRUB 1 +#define SW_FORBS 2 +#define SW_GRASS 3 + + /*------------ DON'T CHANGE ANYTHING BELOW THIS LINE ------------*/ /* Macros to simplify and add consistency to common tasks */ /* Note the loop var must be declared as LyrIndex */ #define ForEachSoilLayer(i) for((i)=0; (i) < SW_Site.n_layers; (i)++) #define ForEachEvapLayer(i) for((i)=0; (i) < SW_Site.n_evap_lyrs; (i)++) -#define ForEachTreeTranspLayer(i) for((i)=0; (i) < SW_Site.n_transp_lyrs_tree; (i)++) -#define ForEachShrubTranspLayer(i) for((i)=0; (i) < SW_Site.n_transp_lyrs_shrub; (i)++) -#define ForEachGrassTranspLayer(i) for((i)=0; (i) < SW_Site.n_transp_lyrs_grass; (i)++) -#define ForEachForbTranspLayer(i) for((i)=0; (i) < SW_Site.n_transp_lyrs_forb; (i)++) +#define ForEachTreeTranspLayer(i) for((i)=0; (i) < SW_Site.n_transp_lyrs[SW_TREES]; (i)++) +#define ForEachShrubTranspLayer(i) for((i)=0; (i) < SW_Site.n_transp_lyrs[SW_SHRUB]; (i)++) +#define ForEachGrassTranspLayer(i) for((i)=0; (i) < SW_Site.n_transp_lyrs[SW_GRASS]; (i)++) +#define ForEachForbTranspLayer(i) for((i)=0; (i) < SW_Site.n_transp_lyrs[SW_FORBS]; (i)++) #define ForEachTranspRegion(r) for((r)=0; (r) < SW_Site.n_transp_rgn; (r)++) /* define m as Months */ #define ForEachMonth(m) for((m)=Jan; (m) <= Dec; (m)++) diff --git a/SW_Flow.c b/SW_Flow.c index fa5d7525e..520c79c16 100644 --- a/SW_Flow.c +++ b/SW_Flow.c @@ -330,10 +330,10 @@ void SW_Water_Flow(void) { } /* Sum cumulative intercepted components */ - SW_Soilwat.tree_int = tree_h2o; - SW_Soilwat.shrub_int = shrub_h2o; - SW_Soilwat.forb_int = forb_h2o; - SW_Soilwat.grass_int = grass_h2o; + SW_Soilwat.int_veg[SW_TREES] = tree_h2o; + SW_Soilwat.int_veg[SW_SHRUB] = shrub_h2o; + SW_Soilwat.int_veg[SW_FORBS] = forb_h2o; + SW_Soilwat.int_veg[SW_GRASS] = grass_h2o; SW_Soilwat.litter_int = litter_h2o; tree_h2o_qum[Today] = tree_h2o_qum[Yesterday] + tree_h2o; @@ -435,7 +435,7 @@ void SW_Water_Flow(void) { soil_evap_rate_tree = 0.; } - transp_weighted_avg(&swpot_avg_tree, SW_Site.n_transp_rgn, SW_Site.n_transp_lyrs_tree, lyrTrRegions_Tree, lyrTranspCo_Tree, lyrSWCBulk); + transp_weighted_avg(&swpot_avg_tree, SW_Site.n_transp_rgn, SW_Site.n_transp_lyrs[SW_TREES], lyrTrRegions_Tree, lyrTranspCo_Tree, lyrSWCBulk); pot_transp(&transp_rate_tree, swpot_avg_tree, SW_VegProd.tree.biolive_daily[doy], SW_VegProd.tree.biodead_daily[doy], transp_tree, SW_Soilwat.pet, SW_Site.transp.xinflec, SW_Site.transp.slope, SW_Site.transp.yinflec, SW_Site.transp.range, SW_VegProd.tree.shade_scale, SW_VegProd.tree.shade_deadmax, @@ -459,7 +459,7 @@ void SW_Water_Flow(void) { soil_evap_rate_shrub = 0.; } - transp_weighted_avg(&swpot_avg_shrub, SW_Site.n_transp_rgn, SW_Site.n_transp_lyrs_shrub, lyrTrRegions_Shrub, lyrTranspCo_Shrub, lyrSWCBulk); + transp_weighted_avg(&swpot_avg_shrub, SW_Site.n_transp_rgn, SW_Site.n_transp_lyrs[SW_SHRUB], lyrTrRegions_Shrub, lyrTranspCo_Shrub, lyrSWCBulk); pot_transp(&transp_rate_shrub, swpot_avg_shrub, SW_VegProd.shrub.biolive_daily[doy], SW_VegProd.shrub.biodead_daily[doy], transp_shrub, SW_Soilwat.pet, SW_Site.transp.xinflec, SW_Site.transp.slope, SW_Site.transp.yinflec, SW_Site.transp.range, SW_VegProd.shrub.shade_scale, SW_VegProd.shrub.shade_deadmax, @@ -484,7 +484,7 @@ void SW_Water_Flow(void) { soil_evap_rate_forb = 0.; } - transp_weighted_avg(&swpot_avg_forb, SW_Site.n_transp_rgn, SW_Site.n_transp_lyrs_forb, lyrTrRegions_Forb, lyrTranspCo_Forb, lyrSWCBulk); + transp_weighted_avg(&swpot_avg_forb, SW_Site.n_transp_rgn, SW_Site.n_transp_lyrs[SW_FORBS], lyrTrRegions_Forb, lyrTranspCo_Forb, lyrSWCBulk); pot_transp(&transp_rate_forb, swpot_avg_forb, SW_VegProd.forb.biolive_daily[doy], SW_VegProd.forb.biodead_daily[doy], transp_forb, SW_Soilwat.pet, SW_Site.transp.xinflec, SW_Site.transp.slope, SW_Site.transp.yinflec, SW_Site.transp.range, SW_VegProd.forb.shade_scale, SW_VegProd.forb.shade_deadmax, @@ -509,7 +509,7 @@ void SW_Water_Flow(void) { soil_evap_rate_grass = 0.; } - transp_weighted_avg(&swpot_avg_grass, SW_Site.n_transp_rgn, SW_Site.n_transp_lyrs_grass, lyrTrRegions_Grass, lyrTranspCo_Grass, lyrSWCBulk); + transp_weighted_avg(&swpot_avg_grass, SW_Site.n_transp_rgn, SW_Site.n_transp_lyrs[SW_GRASS], lyrTrRegions_Grass, lyrTranspCo_Grass, lyrSWCBulk); pot_transp(&transp_rate_grass, swpot_avg_grass, SW_VegProd.grass.biolive_daily[doy], SW_VegProd.grass.biodead_daily[doy], transp_grass, SW_Soilwat.pet, SW_Site.transp.xinflec, SW_Site.transp.slope, SW_Site.transp.yinflec, SW_Site.transp.range, SW_VegProd.grass.shade_scale, SW_VegProd.grass.shade_deadmax, @@ -567,10 +567,10 @@ void SW_Water_Flow(void) { evap_fromSurface(&litter_h2o_qum[Today], &surface_evap_litter_rate, &SW_Soilwat.aet); evap_fromSurface(&standingWater[Today], &surface_evap_standingWater_rate, &SW_Soilwat.aet); - SW_Soilwat.tree_evap = surface_evap_tree_rate; - SW_Soilwat.shrub_evap = surface_evap_shrub_rate; - SW_Soilwat.forb_evap = surface_evap_forb_rate; - SW_Soilwat.grass_evap = surface_evap_grass_rate; + SW_Soilwat.evap_veg[SW_TREES] = surface_evap_tree_rate; + SW_Soilwat.evap_veg[SW_SHRUB] = surface_evap_shrub_rate; + SW_Soilwat.evap_veg[SW_FORBS] = surface_evap_forb_rate; + SW_Soilwat.evap_veg[SW_GRASS] = surface_evap_grass_rate; SW_Soilwat.litter_evap = surface_evap_litter_rate; SW_Soilwat.surfaceWater_evap = surface_evap_standingWater_rate; @@ -591,13 +591,13 @@ void SW_Water_Flow(void) { remove_from_soil(lyrSWCBulk, lyrEvap_Tree, &SW_Soilwat.aet, SW_Site.n_evap_lyrs, lyrEvapCo, soil_evap_rate_tree, lyrSWCBulk_HalfWiltpts); /* remove transp from swc */ - remove_from_soil(lyrSWCBulk, lyrTransp_Tree, &SW_Soilwat.aet, SW_Site.n_transp_lyrs_tree, lyrTranspCo_Tree, transp_rate_tree, lyrSWCBulk_atSWPcrit_Tree); + remove_from_soil(lyrSWCBulk, lyrTransp_Tree, &SW_Soilwat.aet, SW_Site.n_transp_lyrs[SW_TREES], lyrTranspCo_Tree, transp_rate_tree, lyrSWCBulk_atSWPcrit_Tree); } else { /* Set daily array to zero, no evaporation or transpiration */ LyrIndex i; for (i = 0; i < SW_Site.n_evap_lyrs;) lyrEvap_Tree[i++] = 0.; - for (i = 0; i < SW_Site.n_transp_lyrs_tree;) + for (i = 0; i < SW_Site.n_transp_lyrs[SW_TREES];) lyrTransp_Tree[i++] = 0.; } @@ -607,13 +607,13 @@ void SW_Water_Flow(void) { remove_from_soil(lyrSWCBulk, lyrEvap_Shrub, &SW_Soilwat.aet, SW_Site.n_evap_lyrs, lyrEvapCo, soil_evap_rate_shrub, lyrSWCBulk_HalfWiltpts); /* remove transp from swc */ - remove_from_soil(lyrSWCBulk, lyrTransp_Shrub, &SW_Soilwat.aet, SW_Site.n_transp_lyrs_shrub, lyrTranspCo_Shrub, transp_rate_shrub, lyrSWCBulk_atSWPcrit_Shrub); + remove_from_soil(lyrSWCBulk, lyrTransp_Shrub, &SW_Soilwat.aet, SW_Site.n_transp_lyrs[SW_SHRUB], lyrTranspCo_Shrub, transp_rate_shrub, lyrSWCBulk_atSWPcrit_Shrub); } else { /* Set daily array to zero, no evaporation or transpiration */ LyrIndex i; for (i = 0; i < SW_Site.n_evap_lyrs;) lyrEvap_Shrub[i++] = 0.; - for (i = 0; i < SW_Site.n_transp_lyrs_shrub;) + for (i = 0; i < SW_Site.n_transp_lyrs[SW_SHRUB];) lyrTransp_Shrub[i++] = 0.; } @@ -623,13 +623,13 @@ void SW_Water_Flow(void) { remove_from_soil(lyrSWCBulk, lyrEvap_Forb, &SW_Soilwat.aet, SW_Site.n_evap_lyrs, lyrEvapCo, soil_evap_rate_forb, lyrSWCBulk_HalfWiltpts); /* remove transp from swc */ - remove_from_soil(lyrSWCBulk, lyrTransp_Forb, &SW_Soilwat.aet, SW_Site.n_transp_lyrs_forb, lyrTranspCo_Forb, transp_rate_forb, lyrSWCBulk_atSWPcrit_Forb); + remove_from_soil(lyrSWCBulk, lyrTransp_Forb, &SW_Soilwat.aet, SW_Site.n_transp_lyrs[SW_FORBS], lyrTranspCo_Forb, transp_rate_forb, lyrSWCBulk_atSWPcrit_Forb); } else { /* Set daily array to zero, no evaporation or transpiration */ LyrIndex i; for (i = 0; i < SW_Site.n_evap_lyrs;) lyrEvap_Forb[i++] = 0.; - for (i = 0; i < SW_Site.n_transp_lyrs_forb;) + for (i = 0; i < SW_Site.n_transp_lyrs[SW_FORBS];) lyrTransp_Forb[i++] = 0.; } @@ -639,13 +639,13 @@ void SW_Water_Flow(void) { remove_from_soil(lyrSWCBulk, lyrEvap_Grass, &SW_Soilwat.aet, SW_Site.n_evap_lyrs, lyrEvapCo, soil_evap_rate_grass, lyrSWCBulk_HalfWiltpts); /* remove transp from swc */ - remove_from_soil(lyrSWCBulk, lyrTransp_Grass, &SW_Soilwat.aet, SW_Site.n_transp_lyrs_grass, lyrTranspCo_Grass, transp_rate_grass, lyrSWCBulk_atSWPcrit_Grass); + remove_from_soil(lyrSWCBulk, lyrTransp_Grass, &SW_Soilwat.aet, SW_Site.n_transp_lyrs[SW_GRASS], lyrTranspCo_Grass, transp_rate_grass, lyrSWCBulk_atSWPcrit_Grass); } else { /* Set daily array to zero, no evaporation or transpiration */ LyrIndex i; for (i = 0; i < SW_Site.n_evap_lyrs;) lyrEvap_Grass[i++] = 0.; - for (i = 0; i < SW_Site.n_transp_lyrs_grass;) + for (i = 0; i < SW_Site.n_transp_lyrs[SW_GRASS];) lyrTransp_Grass[i++] = 0.; } @@ -729,18 +729,18 @@ static void records2arrays(void) { if (SW_Model.doy == SW_Model.firstdoy) { ForEachSoilLayer(i) { - lyrTrRegions_Tree[i] = SW_Site.lyr[i]->my_transp_rgn_tree; - lyrTrRegions_Forb[i] = SW_Site.lyr[i]->my_transp_rgn_forb; - lyrTrRegions_Shrub[i] = SW_Site.lyr[i]->my_transp_rgn_shrub; - lyrTrRegions_Grass[i] = SW_Site.lyr[i]->my_transp_rgn_grass; + lyrTrRegions_Tree[i] = SW_Site.lyr[i]->my_transp_rgn[SW_TREES]; + lyrTrRegions_Forb[i] = SW_Site.lyr[i]->my_transp_rgn[SW_FORBS]; + lyrTrRegions_Shrub[i] = SW_Site.lyr[i]->my_transp_rgn[SW_SHRUB]; + lyrTrRegions_Grass[i] = SW_Site.lyr[i]->my_transp_rgn[SW_GRASS]; lyrSWCBulk_FieldCaps[i] = SW_Site.lyr[i]->swcBulk_fieldcap; lyrWidths[i] = SW_Site.lyr[i]->width; lyrSWCBulk_Wiltpts[i] = SW_Site.lyr[i]->swcBulk_wiltpt; lyrSWCBulk_HalfWiltpts[i] = SW_Site.lyr[i]->swcBulk_wiltpt / 2.; - lyrSWCBulk_atSWPcrit_Tree[i] = SW_Site.lyr[i]->swcBulk_atSWPcrit_tree; - lyrSWCBulk_atSWPcrit_Forb[i] = SW_Site.lyr[i]->swcBulk_atSWPcrit_forb; - lyrSWCBulk_atSWPcrit_Shrub[i] = SW_Site.lyr[i]->swcBulk_atSWPcrit_shrub; - lyrSWCBulk_atSWPcrit_Grass[i] = SW_Site.lyr[i]->swcBulk_atSWPcrit_grass; + lyrSWCBulk_atSWPcrit_Tree[i] = SW_Site.lyr[i]->swcBulk_atSWPcrit[SW_TREES]; + lyrSWCBulk_atSWPcrit_Forb[i] = SW_Site.lyr[i]->swcBulk_atSWPcrit[SW_FORBS]; + lyrSWCBulk_atSWPcrit_Shrub[i] = SW_Site.lyr[i]->swcBulk_atSWPcrit[SW_SHRUB]; + lyrSWCBulk_atSWPcrit_Grass[i] = SW_Site.lyr[i]->swcBulk_atSWPcrit[SW_GRASS]; lyrSWCBulk_Mins[i] = SW_Site.lyr[i]->swcBulk_min; lyrpsisMatric[i] = SW_Site.lyr[i]->psisMatric; lyrthetasMatric[i] = SW_Site.lyr[i]->thetasMatric; @@ -759,22 +759,22 @@ static void records2arrays(void) { ForEachTreeTranspLayer(i) { - lyrTranspCo_Tree[i] = SW_Site.lyr[i]->transp_coeff_tree; + lyrTranspCo_Tree[i] = SW_Site.lyr[i]->transp_coeff[SW_TREES]; } ForEachShrubTranspLayer(i) { - lyrTranspCo_Shrub[i] = SW_Site.lyr[i]->transp_coeff_shrub; + lyrTranspCo_Shrub[i] = SW_Site.lyr[i]->transp_coeff[SW_SHRUB]; } ForEachForbTranspLayer(i) { - lyrTranspCo_Forb[i] = SW_Site.lyr[i]->transp_coeff_forb; + lyrTranspCo_Forb[i] = SW_Site.lyr[i]->transp_coeff[SW_FORBS]; } ForEachGrassTranspLayer(i) { - lyrTranspCo_Grass[i] = SW_Site.lyr[i]->transp_coeff_grass; + lyrTranspCo_Grass[i] = SW_Site.lyr[i]->transp_coeff[SW_GRASS]; } ForEachEvapLayer(i) @@ -794,10 +794,10 @@ static void arrays2records(void) { { SW_Soilwat.swcBulk[Today][i] = lyrSWCBulk[i]; SW_Soilwat.drain[i] = lyrDrain[i]; - SW_Soilwat.hydred_tree[i] = lyrHydRed_Tree[i]; - SW_Soilwat.hydred_shrub[i] = lyrHydRed_Shrub[i]; - SW_Soilwat.hydred_forb[i] = lyrHydRed_Forb[i]; - SW_Soilwat.hydred_grass[i] = lyrHydRed_Grass[i]; + SW_Soilwat.hydred[SW_TREES][i] = lyrHydRed_Tree[i]; + SW_Soilwat.hydred[SW_SHRUB][i] = lyrHydRed_Shrub[i]; + SW_Soilwat.hydred[SW_FORBS][i] = lyrHydRed_Forb[i]; + SW_Soilwat.hydred[SW_GRASS][i] = lyrHydRed_Grass[i]; SW_Soilwat.sTemp[i] = lyrsTemp[i]; } SW_Soilwat.surfaceTemp = surfaceTemp[Today]; @@ -808,22 +808,22 @@ static void arrays2records(void) { ForEachTreeTranspLayer(i) { - SW_Soilwat.transpiration_tree[i] = lyrTransp_Tree[i]; + SW_Soilwat.transpiration[SW_TREES][i] = lyrTransp_Tree[i]; } ForEachShrubTranspLayer(i) { - SW_Soilwat.transpiration_shrub[i] = lyrTransp_Shrub[i]; + SW_Soilwat.transpiration[SW_SHRUB][i] = lyrTransp_Shrub[i]; } ForEachForbTranspLayer(i) { - SW_Soilwat.transpiration_forb[i] = lyrTransp_Forb[i]; + SW_Soilwat.transpiration[SW_FORBS][i] = lyrTransp_Forb[i]; } ForEachGrassTranspLayer(i) { - SW_Soilwat.transpiration_grass[i] = lyrTransp_Grass[i]; + SW_Soilwat.transpiration[SW_GRASS][i] = lyrTransp_Grass[i]; } ForEachEvapLayer(i) diff --git a/SW_Output.c b/SW_Output.c index 98c6d4a2c..34d6e29a4 100644 --- a/SW_Output.c +++ b/SW_Output.c @@ -2844,16 +2844,16 @@ static void get_transp(OutPeriod pd) switch (pd) { case eSW_Day: - val[i] = v->dysum.transp_tree[i]; + val[i] = v->dysum.transp[SW_TREES][i]; break; case eSW_Week: - val[i] = v->wkavg.transp_tree[i]; + val[i] = v->wkavg.transp[SW_TREES][i]; break; case eSW_Month: - val[i] = v->moavg.transp_tree[i]; + val[i] = v->moavg.transp[SW_TREES][i]; break; case eSW_Year: - val[i] = v->yravg.transp_tree[i]; + val[i] = v->yravg.transp[SW_TREES][i]; break; } } @@ -2862,19 +2862,19 @@ static void get_transp(OutPeriod pd) { case eSW_Day: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Day][SW_Output[eSW_Transp].dy_row + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 1)] = v->dysum.transp_tree[i]; + p_rOUT[eSW_Transp][eSW_Day][SW_Output[eSW_Transp].dy_row + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 1)] = v->dysum.transp[SW_TREES][i]; break; case eSW_Week: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Week][SW_Output[eSW_Transp].wk_row + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 1)] = v->wkavg.transp_tree[i]; + p_rOUT[eSW_Transp][eSW_Week][SW_Output[eSW_Transp].wk_row + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 1)] = v->wkavg.transp[SW_TREES][i]; break; case eSW_Month: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Month][SW_Output[eSW_Transp].mo_row + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 1)] = v->moavg.transp_tree[i]; + p_rOUT[eSW_Transp][eSW_Month][SW_Output[eSW_Transp].mo_row + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 1)] = v->moavg.transp[SW_TREES][i]; break; case eSW_Year: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Year][SW_Output[eSW_Transp].yr_row + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 1)] = v->yravg.transp_tree[i]; + p_rOUT[eSW_Transp][eSW_Year][SW_Output[eSW_Transp].yr_row + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 1)] = v->yravg.transp[SW_TREES][i]; break; } #endif @@ -2918,16 +2918,16 @@ static void get_transp(OutPeriod pd) switch (pd) { case eSW_Day: - val[i] = v->dysum.transp_shrub[i]; + val[i] = v->dysum.transp[SW_SHRUB][i]; break; case eSW_Week: - val[i] = v->wkavg.transp_shrub[i]; + val[i] = v->wkavg.transp[SW_SHRUB][i]; break; case eSW_Month: - val[i] = v->moavg.transp_shrub[i]; + val[i] = v->moavg.transp[SW_SHRUB][i]; break; case eSW_Year: - val[i] = v->yravg.transp_shrub[i]; + val[i] = v->yravg.transp[SW_SHRUB][i]; break; } } @@ -2936,19 +2936,19 @@ static void get_transp(OutPeriod pd) { case eSW_Day: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Day][SW_Output[eSW_Transp].dy_row + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 2)] = v->dysum.transp_shrub[i]; + p_rOUT[eSW_Transp][eSW_Day][SW_Output[eSW_Transp].dy_row + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 2)] = v->dysum.transp[SW_SHRUB][i]; break; case eSW_Week: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Week][SW_Output[eSW_Transp].wk_row + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 2)] = v->wkavg.transp_shrub[i]; + p_rOUT[eSW_Transp][eSW_Week][SW_Output[eSW_Transp].wk_row + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 2)] = v->wkavg.transp[SW_SHRUB][i]; break; case eSW_Month: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Month][SW_Output[eSW_Transp].mo_row + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 2)] = v->moavg.transp_shrub[i]; + p_rOUT[eSW_Transp][eSW_Month][SW_Output[eSW_Transp].mo_row + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 2)] = v->moavg.transp[SW_SHRUB][i]; break; case eSW_Year: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Year][SW_Output[eSW_Transp].yr_row + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 2)] = v->yravg.transp_shrub[i]; + p_rOUT[eSW_Transp][eSW_Year][SW_Output[eSW_Transp].yr_row + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 2)] = v->yravg.transp[SW_SHRUB][i]; break; } #endif @@ -2992,16 +2992,16 @@ static void get_transp(OutPeriod pd) switch (pd) { case eSW_Day: - val[i] = v->dysum.transp_forb[i]; + val[i] = v->dysum.transp[SW_FORBS][i]; break; case eSW_Week: - val[i] = v->wkavg.transp_forb[i]; + val[i] = v->wkavg.transp[SW_FORBS][i]; break; case eSW_Month: - val[i] = v->moavg.transp_forb[i]; + val[i] = v->moavg.transp[SW_FORBS][i]; break; case eSW_Year: - val[i] = v->yravg.transp_forb[i]; + val[i] = v->yravg.transp[SW_FORBS][i]; break; } } @@ -3010,19 +3010,19 @@ static void get_transp(OutPeriod pd) { case eSW_Day: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Day][SW_Output[eSW_Transp].dy_row + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 3)] = v->dysum.transp_forb[i]; + p_rOUT[eSW_Transp][eSW_Day][SW_Output[eSW_Transp].dy_row + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 3)] = v->dysum.transp[SW_FORBS][i]; break; case eSW_Week: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Week][SW_Output[eSW_Transp].wk_row + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 3)] = v->wkavg.transp_forb[i]; + p_rOUT[eSW_Transp][eSW_Week][SW_Output[eSW_Transp].wk_row + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 3)] = v->wkavg.transp[SW_FORBS][i]; break; case eSW_Month: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Month][SW_Output[eSW_Transp].mo_row + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 3)] = v->moavg.transp_forb[i]; + p_rOUT[eSW_Transp][eSW_Month][SW_Output[eSW_Transp].mo_row + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 3)] = v->moavg.transp[SW_FORBS][i]; break; case eSW_Year: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Year][SW_Output[eSW_Transp].yr_row + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 3)] = v->yravg.transp_forb[i]; + p_rOUT[eSW_Transp][eSW_Year][SW_Output[eSW_Transp].yr_row + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 3)] = v->yravg.transp[SW_FORBS][i]; break; } #endif @@ -3067,16 +3067,16 @@ static void get_transp(OutPeriod pd) switch (pd) { case eSW_Day: - val[i] = v->dysum.transp_grass[i]; + val[i] = v->dysum.transp[SW_GRASS][i]; break; case eSW_Week: - val[i] = v->wkavg.transp_grass[i]; + val[i] = v->wkavg.transp[SW_GRASS][i]; break; case eSW_Month: - val[i] = v->moavg.transp_grass[i]; + val[i] = v->moavg.transp[SW_GRASS][i]; break; case eSW_Year: - val[i] = v->yravg.transp_grass[i]; + val[i] = v->yravg.transp[SW_GRASS][i]; break; } } @@ -3085,22 +3085,22 @@ static void get_transp(OutPeriod pd) { case eSW_Day: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Day][SW_Output[eSW_Transp].dy_row + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 4)] = v->dysum.transp_grass[i]; + p_rOUT[eSW_Transp][eSW_Day][SW_Output[eSW_Transp].dy_row + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 4)] = v->dysum.transp[SW_GRASS][i]; SW_Output[eSW_Transp].dy_row++; break; case eSW_Week: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Week][SW_Output[eSW_Transp].wk_row + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 4)] = v->wkavg.transp_grass[i]; + p_rOUT[eSW_Transp][eSW_Week][SW_Output[eSW_Transp].wk_row + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 4)] = v->wkavg.transp[SW_GRASS][i]; SW_Output[eSW_Transp].wk_row++; break; case eSW_Month: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Month][SW_Output[eSW_Transp].mo_row + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 4)] = v->moavg.transp_grass[i]; + p_rOUT[eSW_Transp][eSW_Month][SW_Output[eSW_Transp].mo_row + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 4)] = v->moavg.transp[SW_GRASS][i]; SW_Output[eSW_Transp].mo_row++; break; case eSW_Year: ForEachSoilLayer(i) - p_rOUT[eSW_Transp][eSW_Year][SW_Output[eSW_Transp].yr_row + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 4)] = v->yravg.transp_grass[i]; + p_rOUT[eSW_Transp][eSW_Year][SW_Output[eSW_Transp].yr_row + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 4)] = v->yravg.transp[SW_GRASS][i]; SW_Output[eSW_Transp].yr_row++; break; } @@ -3220,37 +3220,37 @@ static void get_evapSurface(OutPeriod pd) { case eSW_Day: val_tot = v->dysum.total_evap; - val_tree = v->dysum.tree_evap; - val_forb = v->dysum.forb_evap; - val_shrub = v->dysum.shrub_evap; - val_grass = v->dysum.grass_evap; + val_tree = v->dysum.evap_veg[SW_TREES]; + val_forb = v->dysum.evap_veg[SW_FORBS]; + val_shrub = v->dysum.evap_veg[SW_SHRUB]; + val_grass = v->dysum.evap_veg[SW_GRASS]; val_litter = v->dysum.litter_evap; val_water = v->dysum.surfaceWater_evap; break; case eSW_Week: val_tot = v->wkavg.total_evap; - val_tree = v->wkavg.tree_evap; - val_forb = v->wkavg.forb_evap; - val_shrub = v->wkavg.shrub_evap; - val_grass = v->wkavg.grass_evap; + val_tree = v->wkavg.evap_veg[SW_TREES]; + val_forb = v->wkavg.evap_veg[SW_FORBS]; + val_shrub = v->wkavg.evap_veg[SW_SHRUB]; + val_grass = v->wkavg.evap_veg[SW_GRASS]; val_litter = v->wkavg.litter_evap; val_water = v->wkavg.surfaceWater_evap; break; case eSW_Month: val_tot = v->moavg.total_evap; - val_tree = v->moavg.tree_evap; - val_forb = v->moavg.forb_evap; - val_shrub = v->moavg.shrub_evap; - val_grass = v->moavg.grass_evap; + val_tree = v->moavg.evap_veg[SW_TREES]; + val_forb = v->moavg.evap_veg[SW_FORBS]; + val_shrub = v->moavg.evap_veg[SW_SHRUB]; + val_grass = v->moavg.evap_veg[SW_GRASS]; val_litter = v->moavg.litter_evap; val_water = v->moavg.surfaceWater_evap; break; case eSW_Year: val_tot = v->yravg.total_evap; - val_tree = v->yravg.tree_evap; - val_forb = v->yravg.forb_evap; - val_shrub = v->yravg.shrub_evap; - val_grass = v->yravg.grass_evap; + val_tree = v->yravg.evap_veg[SW_TREES]; + val_forb = v->yravg.evap_veg[SW_FORBS]; + val_shrub = v->yravg.evap_veg[SW_SHRUB]; + val_grass = v->yravg.evap_veg[SW_GRASS]; val_litter = v->yravg.litter_evap; val_water = v->yravg.surfaceWater_evap; break; @@ -3269,10 +3269,10 @@ static void get_evapSurface(OutPeriod pd) p[delta + dy_nrow * 0] = SW_Model.simyear; p[delta + dy_nrow * 1] = SW_Model.doy; p[delta + dy_nrow * 2] = v->dysum.total_evap; - p[delta + dy_nrow * 3] = v->dysum.tree_evap; - p[delta + dy_nrow * 4] = v->dysum.shrub_evap; - p[delta + dy_nrow * 5] = v->dysum.forb_evap; - p[delta + dy_nrow * 6] = v->dysum.grass_evap; + p[delta + dy_nrow * 3] = v->dysum.evap_veg[SW_TREES]; + p[delta + dy_nrow * 4] = v->dysum.evap_veg[SW_SHRUB]; + p[delta + dy_nrow * 5] = v->dysum.evap_veg[SW_FORBS]; + p[delta + dy_nrow * 6] = v->dysum.evap_veg[SW_GRASS]; p[delta + dy_nrow * 7] = v->dysum.litter_evap; p[delta + dy_nrow * 8] = v->dysum.surfaceWater_evap; SW_Output[eSW_EvapSurface].dy_row++; @@ -3283,10 +3283,10 @@ static void get_evapSurface(OutPeriod pd) p[delta + wk_nrow * 0] = SW_Model.simyear; p[delta + wk_nrow * 1] = (SW_Model.week + 1) - tOffset; p[delta + wk_nrow * 2] = v->wkavg.total_evap; - p[delta + wk_nrow * 3] = v->wkavg.tree_evap; - p[delta + wk_nrow * 4] = v->wkavg.shrub_evap; - p[delta + wk_nrow * 5] = v->wkavg.forb_evap; - p[delta + wk_nrow * 6] = v->wkavg.grass_evap; + p[delta + wk_nrow * 3] = v->wkavg.evap_veg[SW_TREES]; + p[delta + wk_nrow * 4] = v->wkavg.evap_veg[SW_SHRUB]; + p[delta + wk_nrow * 5] = v->wkavg.evap_veg[SW_FORBS]; + p[delta + wk_nrow * 6] = v->wkavg.evap_veg[SW_GRASS]; p[delta + wk_nrow * 7] = v->wkavg.litter_evap; p[delta + wk_nrow * 8] = v->wkavg.surfaceWater_evap; SW_Output[eSW_EvapSurface].wk_row++; @@ -3297,10 +3297,10 @@ static void get_evapSurface(OutPeriod pd) p[delta + mo_nrow * 0] = SW_Model.simyear; p[delta + mo_nrow * 1] = (SW_Model.month + 1) - tOffset; p[delta + mo_nrow * 2] = v->moavg.total_evap; - p[delta + mo_nrow * 3] = v->moavg.tree_evap; - p[delta + mo_nrow * 4] = v->moavg.shrub_evap; - p[delta + mo_nrow * 5] = v->moavg.forb_evap; - p[delta + mo_nrow * 6] = v->moavg.grass_evap; + p[delta + mo_nrow * 3] = v->moavg.evap_veg[SW_TREES]; + p[delta + mo_nrow * 4] = v->moavg.evap_veg[SW_SHRUB]; + p[delta + mo_nrow * 5] = v->moavg.evap_veg[SW_FORBS]; + p[delta + mo_nrow * 6] = v->moavg.evap_veg[SW_GRASS]; p[delta + mo_nrow * 7] = v->moavg.litter_evap; p[delta + mo_nrow * 8] = v->moavg.surfaceWater_evap; SW_Output[eSW_EvapSurface].mo_row++; @@ -3310,10 +3310,10 @@ static void get_evapSurface(OutPeriod pd) p = p_rOUT[eSW_EvapSurface][eSW_Year]; // set shorthand copy of 'p_rOUT' pointer p[delta + yr_nrow * 0] = SW_Model.simyear; p[delta + yr_nrow * 1] = v->yravg.total_evap; - p[delta + yr_nrow * 2] = v->yravg.tree_evap; - p[delta + yr_nrow * 3] = v->yravg.shrub_evap; - p[delta + yr_nrow * 4] = v->yravg.forb_evap; - p[delta + yr_nrow * 5] = v->yravg.grass_evap; + p[delta + yr_nrow * 2] = v->yravg.evap_veg[SW_TREES]; + p[delta + yr_nrow * 3] = v->yravg.evap_veg[SW_SHRUB]; + p[delta + yr_nrow * 4] = v->yravg.evap_veg[SW_FORBS]; + p[delta + yr_nrow * 5] = v->yravg.evap_veg[SW_GRASS]; p[delta + yr_nrow * 6] = v->yravg.litter_evap; p[delta + yr_nrow * 7] = v->yravg.surfaceWater_evap; SW_Output[eSW_EvapSurface].yr_row++; @@ -3337,34 +3337,34 @@ static void get_interception(OutPeriod pd) { case eSW_Day: val_tot = v->dysum.total_int; - val_tree = v->dysum.tree_int; - val_forb = v->dysum.forb_int; - val_shrub = v->dysum.shrub_int; - val_grass = v->dysum.grass_int; + val_tree = v->dysum.int_veg[SW_TREES]; + val_forb = v->dysum.int_veg[SW_FORBS]; + val_shrub = v->dysum.int_veg[SW_SHRUB]; + val_grass = v->dysum.int_veg[SW_GRASS]; val_litter = v->dysum.litter_int; break; case eSW_Week: val_tot = v->wkavg.total_int; - val_tree = v->wkavg.tree_int; - val_forb = v->wkavg.forb_int; - val_shrub = v->wkavg.shrub_int; - val_grass = v->wkavg.grass_int; + val_tree = v->wkavg.int_veg[SW_TREES]; + val_forb = v->wkavg.int_veg[SW_FORBS]; + val_shrub = v->wkavg.int_veg[SW_SHRUB]; + val_grass = v->wkavg.int_veg[SW_GRASS]; val_litter = v->wkavg.litter_int; break; case eSW_Month: val_tot = v->moavg.total_int; - val_tree = v->moavg.tree_int; - val_forb = v->moavg.forb_int; - val_shrub = v->moavg.shrub_int; - val_grass = v->moavg.grass_int; + val_tree = v->moavg.int_veg[SW_TREES]; + val_forb = v->moavg.int_veg[SW_FORBS]; + val_shrub = v->moavg.int_veg[SW_SHRUB]; + val_grass = v->moavg.int_veg[SW_GRASS]; val_litter = v->moavg.litter_int; break; case eSW_Year: val_tot = v->yravg.total_int; - val_tree = v->yravg.tree_int; - val_forb = v->yravg.forb_int; - val_shrub = v->yravg.shrub_int; - val_grass = v->yravg.grass_int; + val_tree = v->yravg.int_veg[SW_TREES]; + val_forb = v->yravg.int_veg[SW_FORBS]; + val_shrub = v->yravg.int_veg[SW_SHRUB]; + val_grass = v->yravg.int_veg[SW_GRASS]; val_litter = v->yravg.litter_int; break; } @@ -3382,10 +3382,10 @@ static void get_interception(OutPeriod pd) p[delta + dy_nrow * 0] = SW_Model.simyear; p[delta + dy_nrow * 1] = SW_Model.doy; p[delta + dy_nrow * 2] = v->dysum.total_int; - p[delta + dy_nrow * 3] = v->dysum.tree_int; - p[delta + dy_nrow * 4] = v->dysum.shrub_int; - p[delta + dy_nrow * 5] = v->dysum.forb_int; - p[delta + dy_nrow * 6] = v->dysum.grass_int; + p[delta + dy_nrow * 3] = v->dysum.int_veg[SW_TREES]; + p[delta + dy_nrow * 4] = v->dysum.int_veg[SW_SHRUB]; + p[delta + dy_nrow * 5] = v->dysum.int_veg[SW_FORBS]; + p[delta + dy_nrow * 6] = v->dysum.int_veg[SW_GRASS]; p[delta + dy_nrow * 7] = v->dysum.litter_int; SW_Output[eSW_Interception].dy_row++; break; @@ -3395,10 +3395,10 @@ static void get_interception(OutPeriod pd) p[delta + wk_nrow * 0] = SW_Model.simyear; p[delta + wk_nrow * 1] = (SW_Model.week + 1) - tOffset; p[delta + wk_nrow * 2] = v->wkavg.total_int; - p[delta + wk_nrow * 3] = v->wkavg.tree_int; - p[delta + wk_nrow * 4] = v->wkavg.shrub_int; - p[delta + wk_nrow * 5] = v->wkavg.forb_int; - p[delta + wk_nrow * 6] = v->wkavg.grass_int; + p[delta + wk_nrow * 3] = v->wkavg.int_veg[SW_TREES]; + p[delta + wk_nrow * 4] = v->wkavg.int_veg[SW_SHRUB]; + p[delta + wk_nrow * 5] = v->wkavg.int_veg[SW_FORBS]; + p[delta + wk_nrow * 6] = v->wkavg.int_veg[SW_GRASS]; p[delta + wk_nrow * 7] = v->wkavg.litter_int; SW_Output[eSW_Interception].wk_row++; break; @@ -3408,10 +3408,10 @@ static void get_interception(OutPeriod pd) p[delta + mo_nrow * 0] = SW_Model.simyear; p[delta + mo_nrow * 1] = (SW_Model.month + 1) - tOffset; p[delta + mo_nrow * 2] = v->moavg.total_int; - p[delta + mo_nrow * 3] = v->moavg.tree_int; - p[delta + mo_nrow * 4] = v->moavg.shrub_int; - p[delta + mo_nrow * 5] = v->moavg.forb_int; - p[delta + mo_nrow * 6] = v->moavg.grass_int; + p[delta + mo_nrow * 3] = v->moavg.int_veg[SW_TREES]; + p[delta + mo_nrow * 4] = v->moavg.int_veg[SW_SHRUB]; + p[delta + mo_nrow * 5] = v->moavg.int_veg[SW_FORBS]; + p[delta + mo_nrow * 6] = v->moavg.int_veg[SW_GRASS]; p[delta + mo_nrow * 7] = v->moavg.litter_int; SW_Output[eSW_Interception].mo_row++; break; @@ -3420,10 +3420,10 @@ static void get_interception(OutPeriod pd) p = p_rOUT[eSW_Interception][eSW_Year]; // set shorthand copy of 'p_rOUT' pointer p[delta + yr_nrow * 0] = SW_Model.simyear; p[delta + yr_nrow * 1] = v->yravg.total_int; - p[delta + yr_nrow * 2] = v->yravg.tree_int; - p[delta + yr_nrow * 3] = v->yravg.shrub_int; - p[delta + yr_nrow * 4] = v->yravg.forb_int; - p[delta + yr_nrow * 5] = v->yravg.grass_int; + p[delta + yr_nrow * 2] = v->yravg.int_veg[SW_TREES]; + p[delta + yr_nrow * 3] = v->yravg.int_veg[SW_SHRUB]; + p[delta + yr_nrow * 4] = v->yravg.int_veg[SW_FORBS]; + p[delta + yr_nrow * 5] = v->yravg.int_veg[SW_GRASS]; p[delta + yr_nrow * 6] = v->yravg.litter_int; SW_Output[eSW_Interception].yr_row++; break; @@ -3619,16 +3619,16 @@ static void get_hydred(OutPeriod pd) switch (pd) { case eSW_Day: - val = v->dysum.hydred_tree[i]; + val = v->dysum.hydred[SW_TREES][i]; break; case eSW_Week: - val = v->wkavg.hydred_tree[i]; + val = v->wkavg.hydred[SW_TREES][i]; break; case eSW_Month: - val = v->moavg.hydred_tree[i]; + val = v->moavg.hydred[SW_TREES][i]; break; case eSW_Year: - val = v->yravg.hydred_tree[i]; + val = v->yravg.hydred[SW_TREES][i]; break; } @@ -3640,16 +3640,16 @@ static void get_hydred(OutPeriod pd) switch (pd) { case eSW_Day: - val = v->dysum.hydred_shrub[i]; + val = v->dysum.hydred[SW_SHRUB][i]; break; case eSW_Week: - val = v->wkavg.hydred_shrub[i]; + val = v->wkavg.hydred[SW_SHRUB][i]; break; case eSW_Month: - val = v->moavg.hydred_shrub[i]; + val = v->moavg.hydred[SW_SHRUB][i]; break; case eSW_Year: - val = v->yravg.hydred_shrub[i]; + val = v->yravg.hydred[SW_SHRUB][i]; break; } @@ -3661,16 +3661,16 @@ static void get_hydred(OutPeriod pd) switch (pd) { case eSW_Day: - val = v->dysum.hydred_forb[i]; + val = v->dysum.hydred[SW_FORBS][i]; break; case eSW_Week: - val = v->wkavg.hydred_forb[i]; + val = v->wkavg.hydred[SW_FORBS][i]; break; case eSW_Month: - val = v->moavg.hydred_forb[i]; + val = v->moavg.hydred[SW_FORBS][i]; break; case eSW_Year: - val = v->yravg.hydred_forb[i]; + val = v->yravg.hydred[SW_FORBS][i]; break; } @@ -3683,16 +3683,16 @@ static void get_hydred(OutPeriod pd) switch (pd) { case eSW_Day: - val = v->dysum.hydred_grass[i]; + val = v->dysum.hydred[SW_GRASS][i]; break; case eSW_Week: - val = v->wkavg.hydred_grass[i]; + val = v->wkavg.hydred[SW_GRASS][i]; break; case eSW_Month: - val = v->moavg.hydred_grass[i]; + val = v->moavg.hydred[SW_GRASS][i]; break; case eSW_Year: - val = v->yravg.hydred_grass[i]; + val = v->yravg.hydred[SW_GRASS][i]; break; } @@ -3756,19 +3756,19 @@ static void get_hydred(OutPeriod pd) { case eSW_Day: ForEachSoilLayer(i) - p[delta + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 1)] = v->dysum.hydred_tree[i]; + p[delta + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 1)] = v->dysum.hydred[SW_TREES][i]; break; case eSW_Week: ForEachSoilLayer(i) - p[delta + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 1)] = v->wkavg.hydred_tree[i]; + p[delta + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 1)] = v->wkavg.hydred[SW_TREES][i]; break; case eSW_Month: ForEachSoilLayer(i) - p[delta + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 1)] = v->moavg.hydred_tree[i]; + p[delta + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 1)] = v->moavg.hydred[SW_TREES][i]; break; case eSW_Year: ForEachSoilLayer(i) - p[delta + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 1)] = v->yravg.hydred_tree[i]; + p[delta + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 1)] = v->yravg.hydred[SW_TREES][i]; break; } @@ -3777,19 +3777,19 @@ static void get_hydred(OutPeriod pd) { case eSW_Day: ForEachSoilLayer(i) - p[delta + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 2)] = v->dysum.hydred_shrub[i]; + p[delta + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 2)] = v->dysum.hydred[SW_SHRUB][i]; break; case eSW_Week: ForEachSoilLayer(i) - p[delta + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 2)] = v->wkavg.hydred_shrub[i]; + p[delta + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 2)] = v->wkavg.hydred[SW_SHRUB][i]; break; case eSW_Month: ForEachSoilLayer(i) - p[delta + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 2)] = v->moavg.hydred_shrub[i]; + p[delta + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 2)] = v->moavg.hydred[SW_SHRUB][i]; break; case eSW_Year: ForEachSoilLayer(i) - p[delta + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 2)] = v->yravg.hydred_shrub[i]; + p[delta + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 2)] = v->yravg.hydred[SW_SHRUB][i]; break; } @@ -3798,19 +3798,19 @@ static void get_hydred(OutPeriod pd) { case eSW_Day: ForEachSoilLayer(i) - p[delta + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 3)] = v->dysum.hydred_forb[i]; + p[delta + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 3)] = v->dysum.hydred[SW_FORBS][i]; break; case eSW_Week: ForEachSoilLayer(i) - p[delta + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 3)] = v->wkavg.hydred_forb[i]; + p[delta + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 3)] = v->wkavg.hydred[SW_FORBS][i]; break; case eSW_Month: ForEachSoilLayer(i) - p[delta + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 3)] = v->moavg.hydred_forb[i]; + p[delta + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 3)] = v->moavg.hydred[SW_FORBS][i]; break; case eSW_Year: ForEachSoilLayer(i) - p[delta + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 3)] = v->yravg.hydred_forb[i]; + p[delta + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 3)] = v->yravg.hydred[SW_FORBS][i]; break; } @@ -3819,22 +3819,22 @@ static void get_hydred(OutPeriod pd) { case eSW_Day: ForEachSoilLayer(i) - p[delta + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 4)] = v->dysum.hydred_grass[i]; + p[delta + dy_nrow * (i + 2) + (dy_nrow * SW_Site.n_layers * 4)] = v->dysum.hydred[SW_GRASS][i]; SW_Output[eSW_HydRed].dy_row++; break; case eSW_Week: ForEachSoilLayer(i) - p[delta + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 4)] = v->wkavg.hydred_grass[i]; + p[delta + wk_nrow * (i + 2) + (wk_nrow * SW_Site.n_layers * 4)] = v->wkavg.hydred[SW_GRASS][i]; SW_Output[eSW_HydRed].wk_row++; break; case eSW_Month: ForEachSoilLayer(i) - p[delta + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 4)] = v->moavg.hydred_grass[i]; + p[delta + mo_nrow * (i + 2) + (mo_nrow * SW_Site.n_layers * 4)] = v->moavg.hydred[SW_GRASS][i]; SW_Output[eSW_HydRed].mo_row++; break; case eSW_Year: ForEachSoilLayer(i) - p[delta + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 4)] = v->yravg.hydred_grass[i]; + p[delta + yr_nrow * (i + 1) + (yr_nrow * SW_Site.n_layers * 4)] = v->yravg.hydred[SW_GRASS][i]; SW_Output[eSW_HydRed].yr_row++; break; } @@ -4357,13 +4357,13 @@ static void sumof_swc(SW_SOILWAT *v, SW_SOILWAT_OUTPUTS *s, OutKey k) case eSW_Transp: ForEachSoilLayer(i) { - s->transp_total[i] += v->transpiration_tree[i] - + v->transpiration_forb[i] + v->transpiration_shrub[i] - + v->transpiration_grass[i]; - s->transp_tree[i] += v->transpiration_tree[i]; - s->transp_shrub[i] += v->transpiration_shrub[i]; - s->transp_forb[i] += v->transpiration_forb[i]; - s->transp_grass[i] += v->transpiration_grass[i]; + s->transp_total[i] += v->transpiration[SW_TREES][i] + + v->transpiration[SW_SHRUB][i] + v->transpiration[SW_FORBS][i] + + v->transpiration[SW_GRASS][i]; + s->transp[SW_TREES][i] += v->transpiration[SW_TREES][i]; + s->transp[SW_SHRUB][i] += v->transpiration[SW_SHRUB][i]; + s->transp[SW_FORBS][i] += v->transpiration[SW_FORBS][i]; + s->transp[SW_GRASS][i] += v->transpiration[SW_GRASS][i]; } break; @@ -4373,23 +4373,23 @@ static void sumof_swc(SW_SOILWAT *v, SW_SOILWAT_OUTPUTS *s, OutKey k) break; case eSW_EvapSurface: - s->total_evap += v->tree_evap + v->forb_evap + v->shrub_evap - + v->grass_evap + v->litter_evap + v->surfaceWater_evap; - s->tree_evap += v->tree_evap; - s->shrub_evap += v->shrub_evap; - s->forb_evap += v->forb_evap; - s->grass_evap += v->grass_evap; + s->total_evap += v->evap_veg[SW_TREES] + v->evap_veg[SW_FORBS] + v->evap_veg[SW_SHRUB] + + v->evap_veg[SW_GRASS] + v->litter_evap + v->surfaceWater_evap; + s->evap_veg[SW_TREES] += v->evap_veg[SW_TREES]; + s->evap_veg[SW_SHRUB] += v->evap_veg[SW_SHRUB]; + s->evap_veg[SW_FORBS] += v->evap_veg[SW_FORBS]; + s->evap_veg[SW_GRASS] += v->evap_veg[SW_GRASS]; s->litter_evap += v->litter_evap; s->surfaceWater_evap += v->surfaceWater_evap; break; case eSW_Interception: - s->total_int += v->tree_int + v->forb_int + v->shrub_int + v->grass_int + s->total_int += v->int_veg[SW_TREES] + v->int_veg[SW_FORBS] + v->int_veg[SW_SHRUB] + v->int_veg[SW_GRASS] + v->litter_int; - s->tree_int += v->tree_int; - s->shrub_int += v->shrub_int; - s->forb_int += v->forb_int; - s->grass_int += v->grass_int; + s->int_veg[SW_TREES] += v->int_veg[SW_TREES]; + s->int_veg[SW_SHRUB] += v->int_veg[SW_SHRUB]; + s->int_veg[SW_FORBS] += v->int_veg[SW_FORBS]; + s->int_veg[SW_GRASS] += v->int_veg[SW_GRASS]; s->litter_int += v->litter_int; break; @@ -4401,12 +4401,12 @@ static void sumof_swc(SW_SOILWAT *v, SW_SOILWAT_OUTPUTS *s, OutKey k) case eSW_HydRed: ForEachSoilLayer(i) { - s->hydred_total[i] += v->hydred_tree[i] + v->hydred_forb[i] - + v->hydred_shrub[i] + v->hydred_grass[i]; - s->hydred_tree[i] += v->hydred_tree[i]; - s->hydred_shrub[i] += v->hydred_shrub[i]; - s->hydred_forb[i] += v->hydred_forb[i]; - s->hydred_grass[i] += v->hydred_grass[i]; + s->hydred_total[i] += v->hydred[SW_TREES][i] + v->hydred[SW_FORBS][i] + + v->hydred[SW_SHRUB][i] + v->hydred[SW_GRASS][i]; + s->hydred[SW_TREES][i] += v->hydred[SW_TREES][i]; + s->hydred[SW_SHRUB][i] += v->hydred[SW_SHRUB][i]; + s->hydred[SW_FORBS][i] += v->hydred[SW_FORBS][i]; + s->hydred[SW_GRASS][i] += v->hydred[SW_GRASS][i]; } break; @@ -4628,10 +4628,10 @@ static void average_for(ObjType otyp, OutPeriod pd) ForEachSoilLayer(i) { savg->transp_total[i] = ssumof->transp_total[i] / div; - savg->transp_tree[i] = ssumof->transp_tree[i] / div; - savg->transp_shrub[i] = ssumof->transp_shrub[i] / div; - savg->transp_forb[i] = ssumof->transp_forb[i] / div; - savg->transp_grass[i] = ssumof->transp_grass[i] / div; + savg->transp[SW_TREES][i] = ssumof->transp[SW_TREES][i] / div; + savg->transp[SW_SHRUB][i] = ssumof->transp[SW_SHRUB][i] / div; + savg->transp[SW_FORBS][i] = ssumof->transp[SW_FORBS][i] / div; + savg->transp[SW_GRASS][i] = ssumof->transp[SW_GRASS][i] / div; } break; @@ -4642,20 +4642,20 @@ static void average_for(ObjType otyp, OutPeriod pd) case eSW_EvapSurface: savg->total_evap = ssumof->total_evap / div; - savg->tree_evap = ssumof->tree_evap / div; - savg->shrub_evap = ssumof->shrub_evap / div; - savg->forb_evap = ssumof->forb_evap / div; - savg->grass_evap = ssumof->grass_evap / div; + savg->evap_veg[SW_TREES] = ssumof->evap_veg[SW_TREES] / div; + savg->evap_veg[SW_SHRUB] = ssumof->evap_veg[SW_SHRUB] / div; + savg->evap_veg[SW_FORBS] = ssumof->evap_veg[SW_FORBS] / div; + savg->evap_veg[SW_GRASS] = ssumof->evap_veg[SW_GRASS] / div; savg->litter_evap = ssumof->litter_evap / div; savg->surfaceWater_evap = ssumof->surfaceWater_evap / div; break; case eSW_Interception: savg->total_int = ssumof->total_int / div; - savg->tree_int = ssumof->tree_int / div; - savg->shrub_int = ssumof->shrub_int / div; - savg->forb_int = ssumof->forb_int / div; - savg->grass_int = ssumof->grass_int / div; + savg->int_veg[SW_TREES] = ssumof->int_veg[SW_TREES] / div; + savg->int_veg[SW_SHRUB] = ssumof->int_veg[SW_SHRUB] / div; + savg->int_veg[SW_FORBS] = ssumof->int_veg[SW_FORBS] / div; + savg->int_veg[SW_GRASS] = ssumof->int_veg[SW_GRASS] / div; savg->litter_int = ssumof->litter_int / div; break; @@ -4672,10 +4672,10 @@ static void average_for(ObjType otyp, OutPeriod pd) ForEachSoilLayer(i) { savg->hydred_total[i] = ssumof->hydred_total[i] / div; - savg->hydred_tree[i] = ssumof->hydred_tree[i] / div; - savg->hydred_shrub[i] = ssumof->hydred_shrub[i] / div; - savg->hydred_forb[i] = ssumof->hydred_forb[i] / div; - savg->hydred_grass[i] = ssumof->hydred_grass[i] / div; + savg->hydred[SW_TREES][i] = ssumof->hydred[SW_TREES][i] / div; + savg->hydred[SW_SHRUB][i] = ssumof->hydred[SW_SHRUB][i] / div; + savg->hydred[SW_FORBS][i] = ssumof->hydred[SW_FORBS][i] / div; + savg->hydred[SW_GRASS][i] = ssumof->hydred[SW_GRASS][i] / div; } break; diff --git a/SW_Site.c b/SW_Site.c index cc96ebc49..519a1b21c 100644 --- a/SW_Site.c +++ b/SW_Site.c @@ -492,17 +492,17 @@ static void _read_layers(void) { v->lyr[lyrno]->soilMatric_density = matricd; v->lyr[lyrno]->fractionVolBulk_gravel = f_gravel; v->lyr[lyrno]->evap_coeff = evco; - v->lyr[lyrno]->transp_coeff_forb = trco_forb; - v->lyr[lyrno]->transp_coeff_tree = trco_tree; - v->lyr[lyrno]->transp_coeff_shrub = trco_shrub; - v->lyr[lyrno]->transp_coeff_grass = trco_grass; + v->lyr[lyrno]->transp_coeff[SW_FORBS] = trco_forb; + v->lyr[lyrno]->transp_coeff[SW_TREES] = trco_tree; + v->lyr[lyrno]->transp_coeff[SW_SHRUB] = trco_shrub; + v->lyr[lyrno]->transp_coeff[SW_GRASS] = trco_grass; v->lyr[lyrno]->fractionWeightMatric_sand = psand; v->lyr[lyrno]->fractionWeightMatric_clay = pclay; v->lyr[lyrno]->impermeability = imperm; - v->lyr[lyrno]->my_transp_rgn_tree = 0; - v->lyr[lyrno]->my_transp_rgn_forb = 0; - v->lyr[lyrno]->my_transp_rgn_shrub = 0; - v->lyr[lyrno]->my_transp_rgn_grass = 0; + v->lyr[lyrno]->my_transp_rgn[SW_TREES] = 0; + v->lyr[lyrno]->my_transp_rgn[SW_FORBS] = 0; + v->lyr[lyrno]->my_transp_rgn[SW_SHRUB] = 0; + v->lyr[lyrno]->my_transp_rgn[SW_GRASS] = 0; v->lyr[lyrno]->sTemp = soiltemp; if (evap_ok) { @@ -512,26 +512,26 @@ static void _read_layers(void) { evap_ok = swFALSE; } if (transp_ok_forb) { - if (GT(v->lyr[lyrno]->transp_coeff_forb, 0.0)) { - v->n_transp_lyrs_forb++; + if (GT(v->lyr[lyrno]->transp_coeff[SW_FORBS], 0.0)) { + v->n_transp_lyrs[SW_FORBS]++; } else transp_ok_forb = swFALSE; } if (transp_ok_tree) { - if (GT(v->lyr[lyrno]->transp_coeff_tree, 0.0)) { - v->n_transp_lyrs_tree++; + if (GT(v->lyr[lyrno]->transp_coeff[SW_TREES], 0.0)) { + v->n_transp_lyrs[SW_TREES]++; } else transp_ok_tree = swFALSE; } if (transp_ok_shrub) { - if (GT(v->lyr[lyrno]->transp_coeff_shrub, 0.0)) { - v->n_transp_lyrs_shrub++; + if (GT(v->lyr[lyrno]->transp_coeff[SW_SHRUB], 0.0)) { + v->n_transp_lyrs[SW_SHRUB]++; } else transp_ok_shrub = swFALSE; } if (transp_ok_grass) { - if (GT(v->lyr[lyrno]->transp_coeff_grass, 0.0)) { - v->n_transp_lyrs_grass++; + if (GT(v->lyr[lyrno]->transp_coeff[SW_GRASS], 0.0)) { + v->n_transp_lyrs[SW_GRASS]++; } else transp_ok_grass = swFALSE; } @@ -594,16 +594,16 @@ void init_site_info(void) { lyr = sp->lyr[s]; /* sum ev and tr coefficients for later */ evsum += lyr->evap_coeff; - trsum_forb += lyr->transp_coeff_forb; - trsum_tree += lyr->transp_coeff_tree; - trsum_shrub += lyr->transp_coeff_shrub; - trsum_grass += lyr->transp_coeff_grass; + trsum_forb += lyr->transp_coeff[SW_FORBS]; + trsum_tree += lyr->transp_coeff[SW_TREES]; + trsum_shrub += lyr->transp_coeff[SW_SHRUB]; + trsum_grass += lyr->transp_coeff[SW_GRASS]; /* calculate soil water content at SWPcrit for each vegetation type */ - lyr->swcBulk_atSWPcrit_forb = SW_SWPmatric2VWCBulk(lyr->fractionVolBulk_gravel, SW_VegProd.forb.SWPcrit, s) * lyr->width; - lyr->swcBulk_atSWPcrit_tree = SW_SWPmatric2VWCBulk(lyr->fractionVolBulk_gravel, SW_VegProd.tree.SWPcrit, s) * lyr->width; - lyr->swcBulk_atSWPcrit_shrub = SW_SWPmatric2VWCBulk(lyr->fractionVolBulk_gravel, SW_VegProd.shrub.SWPcrit, s) * lyr->width; - lyr->swcBulk_atSWPcrit_grass = SW_SWPmatric2VWCBulk(lyr->fractionVolBulk_gravel, SW_VegProd.grass.SWPcrit, s) * lyr->width; + lyr->swcBulk_atSWPcrit[SW_FORBS] = SW_SWPmatric2VWCBulk(lyr->fractionVolBulk_gravel, SW_VegProd.forb.SWPcrit, s) * lyr->width; + lyr->swcBulk_atSWPcrit[SW_TREES] = SW_SWPmatric2VWCBulk(lyr->fractionVolBulk_gravel, SW_VegProd.tree.SWPcrit, s) * lyr->width; + lyr->swcBulk_atSWPcrit[SW_SHRUB] = SW_SWPmatric2VWCBulk(lyr->fractionVolBulk_gravel, SW_VegProd.shrub.SWPcrit, s) * lyr->width; + lyr->swcBulk_atSWPcrit[SW_GRASS] = SW_SWPmatric2VWCBulk(lyr->fractionVolBulk_gravel, SW_VegProd.grass.SWPcrit, s) * lyr->width; /* Find which transpiration region the current soil layer * is in and check validity of result. Region bounds are @@ -614,7 +614,7 @@ void init_site_info(void) { ForEachTranspRegion(r) { if (s < _TranspRgnBounds[r]) { - if (ZRO(lyr->transp_coeff_forb)) + if (ZRO(lyr->transp_coeff[SW_FORBS])) break; /* end of transpiring layers */ curregion = r + 1; break; @@ -623,8 +623,8 @@ void init_site_info(void) { if (curregion || _TranspRgnBounds[curregion] == 0) { LogError(logfp, LOGNOTE, " Layer %d : curregion %d _TranspRgnBounds %d", s + 1, curregion, _TranspRgnBounds[curregion]); - lyr->my_transp_rgn_forb = curregion; - sp->n_transp_lyrs_forb = max(sp->n_transp_lyrs_forb, s); + lyr->my_transp_rgn[SW_FORBS] = curregion; + sp->n_transp_lyrs[SW_FORBS] = max(sp->n_transp_lyrs[SW_FORBS], s); } else if (s == 0) { LogError(logfp, LOGFATAL, "%s : Top soil layer must be included\n" @@ -641,7 +641,7 @@ void init_site_info(void) { ForEachTranspRegion(r) { if (s < _TranspRgnBounds[r]) { - if (ZRO(lyr->transp_coeff_tree)) + if (ZRO(lyr->transp_coeff[SW_TREES])) break; /* end of transpiring layers */ curregion = r + 1; break; @@ -649,8 +649,8 @@ void init_site_info(void) { } if (curregion || _TranspRgnBounds[curregion] == 0) { - lyr->my_transp_rgn_tree = curregion; - sp->n_transp_lyrs_tree = max(sp->n_transp_lyrs_tree, s); + lyr->my_transp_rgn[SW_TREES] = curregion; + sp->n_transp_lyrs[SW_TREES] = max(sp->n_transp_lyrs[SW_TREES], s); } else if (s == 0) { LogError(logfp, LOGFATAL, "%s : Top soil layer must be included\n" @@ -667,7 +667,7 @@ void init_site_info(void) { ForEachTranspRegion(r) { if (s < _TranspRgnBounds[r]) { - if (ZRO(lyr->transp_coeff_shrub)) + if (ZRO(lyr->transp_coeff[SW_SHRUB])) break; /* end of transpiring layers */ curregion = r + 1; break; @@ -675,8 +675,8 @@ void init_site_info(void) { } if (curregion || _TranspRgnBounds[curregion] == 0) { - lyr->my_transp_rgn_shrub = curregion; - sp->n_transp_lyrs_shrub = max(sp->n_transp_lyrs_shrub, s); + lyr->my_transp_rgn[SW_SHRUB] = curregion; + sp->n_transp_lyrs[SW_SHRUB] = max(sp->n_transp_lyrs[SW_SHRUB], s); } else if (s == 0) { LogError(logfp, LOGFATAL, "%s : Top soil layer must be included\n" @@ -692,7 +692,7 @@ void init_site_info(void) { ForEachTranspRegion(r) { if (s < _TranspRgnBounds[r]) { - if (ZRO(lyr->transp_coeff_grass)) + if (ZRO(lyr->transp_coeff[SW_GRASS])) break; /* end of transpiring layers */ curregion = r + 1; break; @@ -700,8 +700,8 @@ void init_site_info(void) { } if (curregion || _TranspRgnBounds[curregion] == 0) { - lyr->my_transp_rgn_grass = curregion; - sp->n_transp_lyrs_grass = max(sp->n_transp_lyrs_grass, s); + lyr->my_transp_rgn[SW_GRASS] = curregion; + sp->n_transp_lyrs[SW_GRASS] = max(sp->n_transp_lyrs[SW_GRASS], s); } else if (s == 0) { LogError(logfp, LOGFATAL, "%s : Top soil layer must be included\n" @@ -770,8 +770,8 @@ void init_site_info(void) { "tr_co_forb sum (%5.4f) != 1.0.\nNew Coefficients are:", MyFileName, trsum_forb); ForEachForbTranspLayer(s) { - SW_Site.lyr[s]->transp_coeff_forb /= trsum_forb; - LogError(logfp, LOGNOTE, " Layer %d : %5.4f", s + 1, SW_Site.lyr[s]->transp_coeff_forb); + SW_Site.lyr[s]->transp_coeff[SW_FORBS] /= trsum_forb; + LogError(logfp, LOGNOTE, " Layer %d : %5.4f", s + 1, SW_Site.lyr[s]->transp_coeff[SW_FORBS]); } } if (!EQ(trsum_tree, 1.0)) { @@ -779,8 +779,8 @@ void init_site_info(void) { "tr_co_tree sum (%5.4f) != 1.0.\nNew coefficients are:", MyFileName, trsum_tree); ForEachTreeTranspLayer(s) { - SW_Site.lyr[s]->transp_coeff_tree /= trsum_tree; - LogError(logfp, LOGNOTE, " Layer %d : %5.4f", s + 1, SW_Site.lyr[s]->transp_coeff_tree); + SW_Site.lyr[s]->transp_coeff[SW_TREES] /= trsum_tree; + LogError(logfp, LOGNOTE, " Layer %d : %5.4f", s + 1, SW_Site.lyr[s]->transp_coeff[SW_TREES]); } } if (!EQ(trsum_shrub, 1.0)) { @@ -788,8 +788,8 @@ void init_site_info(void) { "tr_co_shrub sum (%5.4f) != 1.0.\nNew coefficients are:", MyFileName, trsum_shrub); ForEachShrubTranspLayer(s) { - SW_Site.lyr[s]->transp_coeff_shrub /= trsum_shrub; - LogError(logfp, LOGNOTE, " Layer %d : %5.4f", s + 1, SW_Site.lyr[s]->transp_coeff_shrub); + SW_Site.lyr[s]->transp_coeff[SW_SHRUB] /= trsum_shrub; + LogError(logfp, LOGNOTE, " Layer %d : %5.4f", s + 1, SW_Site.lyr[s]->transp_coeff[SW_SHRUB]); } } if (!EQ(trsum_grass, 1.0)) { @@ -797,8 +797,8 @@ void init_site_info(void) { "tr_co_grass sum (%5.4f) != 1.0.\nNew coefficients are:", MyFileName, trsum_grass); ForEachGrassTranspLayer(s) { - SW_Site.lyr[s]->transp_coeff_grass /= trsum_grass; - LogError(logfp, LOGNOTE, " Layer %d : %5.4f", s + 1, SW_Site.lyr[s]->transp_coeff_grass); + SW_Site.lyr[s]->transp_coeff[SW_GRASS] /= trsum_grass; + LogError(logfp, LOGNOTE, " Layer %d : %5.4f", s + 1, SW_Site.lyr[s]->transp_coeff[SW_GRASS]); } } @@ -894,10 +894,10 @@ void _echo_inputs(void) { LogError(logfp, LOGNOTE, " Soils File: %s\n", SW_F_name(eLayers)); LogError(logfp, LOGNOTE, " Number of soil layers: %d\n", s->n_layers); LogError(logfp, LOGNOTE, " Number of evaporation layers: %d\n", s->n_evap_lyrs); - LogError(logfp, LOGNOTE, " Number of forb transpiration layers: %d\n", s->n_transp_lyrs_forb); - LogError(logfp, LOGNOTE, " Number of tree transpiration layers: %d\n", s->n_transp_lyrs_tree); - LogError(logfp, LOGNOTE, " Number of shrub transpiration layers: %d\n", s->n_transp_lyrs_shrub); - LogError(logfp, LOGNOTE, " Number of grass transpiration layers: %d\n", s->n_transp_lyrs_grass); + LogError(logfp, LOGNOTE, " Number of forb transpiration layers: %d\n", s->n_transp_lyrs[SW_FORBS]); + LogError(logfp, LOGNOTE, " Number of tree transpiration layers: %d\n", s->n_transp_lyrs[SW_TREES]); + LogError(logfp, LOGNOTE, " Number of shrub transpiration layers: %d\n", s->n_transp_lyrs[SW_SHRUB]); + LogError(logfp, LOGNOTE, " Number of grass transpiration layers: %d\n", s->n_transp_lyrs[SW_GRASS]); LogError(logfp, LOGNOTE, " Number of transpiration regions: %d\n", s->n_transp_rgn); LogError(logfp, LOGNOTE, "\nLayer Specific Values:\n----------------------\n"); @@ -914,10 +914,10 @@ void _echo_inputs(void) { " %3d %5.1f %9.5f %6.2f %8.5f %8.5f %6.2f %6.2f %6.2f %6.2f %6.2f %6.2f %9.2f %9.2f %9.2f %9.2f %9.2f %10d %10d %15d %15d %15.4f %9.4f %9.4f %9.4f %9.4f\n", i + 1, s->lyr[i]->width, s->lyr[i]->soilBulk_density, s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_fieldcap / s->lyr[i]->width, s->lyr[i]->swcBulk_wiltpt / s->lyr[i]->width, s->lyr[i]->fractionWeightMatric_sand, s->lyr[i]->fractionWeightMatric_clay, - s->lyr[i]->swcBulk_atSWPcrit_forb / s->lyr[i]->width, s->lyr[i]->swcBulk_atSWPcrit_tree / s->lyr[i]->width, - s->lyr[i]->swcBulk_atSWPcrit_shrub / s->lyr[i]->width, s->lyr[i]->swcBulk_atSWPcrit_grass / s->lyr[i]->width, s->lyr[i]->evap_coeff, - s->lyr[i]->transp_coeff_forb, s->lyr[i]->transp_coeff_tree, s->lyr[i]->transp_coeff_shrub, s->lyr[i]->transp_coeff_grass, s->lyr[i]->my_transp_rgn_forb, - s->lyr[i]->my_transp_rgn_tree, s->lyr[i]->my_transp_rgn_shrub, s->lyr[i]->my_transp_rgn_grass, s->lyr[i]->swcBulk_wet / s->lyr[i]->width, + s->lyr[i]->swcBulk_atSWPcrit[SW_FORBS] / s->lyr[i]->width, s->lyr[i]->swcBulk_atSWPcrit[SW_TREES] / s->lyr[i]->width, + s->lyr[i]->swcBulk_atSWPcrit[SW_SHRUB] / s->lyr[i]->width, s->lyr[i]->swcBulk_atSWPcrit[SW_GRASS] / s->lyr[i]->width, s->lyr[i]->evap_coeff, + s->lyr[i]->transp_coeff[SW_FORBS], s->lyr[i]->transp_coeff[SW_TREES], s->lyr[i]->transp_coeff[SW_SHRUB], s->lyr[i]->transp_coeff[SW_GRASS], s->lyr[i]->my_transp_rgn[SW_FORBS], + s->lyr[i]->my_transp_rgn[SW_TREES], s->lyr[i]->my_transp_rgn[SW_SHRUB], s->lyr[i]->my_transp_rgn[SW_GRASS], s->lyr[i]->swcBulk_wet / s->lyr[i]->width, s->lyr[i]->swcBulk_min / s->lyr[i]->width, s->lyr[i]->swcBulk_init / s->lyr[i]->width, s->lyr[i]->swcBulk_saturated / s->lyr[i]->width, s->lyr[i]->impermeability); @@ -934,8 +934,8 @@ void _echo_inputs(void) { { LogError(logfp, LOGNOTE, " %3d %5.1f %9.5f %6.2f %8.5f %8.5f %6.2f %6.2f %7.4f %7.4f %7.4f %7.4f %7.4f %7.4f %8.4f %7.4f %5.4f\n", i + 1, s->lyr[i]->width, s->lyr[i]->soilBulk_density, s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_fieldcap, s->lyr[i]->swcBulk_wiltpt, s->lyr[i]->fractionWeightMatric_sand, - s->lyr[i]->fractionWeightMatric_clay, s->lyr[i]->swcBulk_atSWPcrit_forb, s->lyr[i]->swcBulk_atSWPcrit_tree, s->lyr[i]->swcBulk_atSWPcrit_shrub, - s->lyr[i]->swcBulk_atSWPcrit_grass, s->lyr[i]->swcBulk_wet, s->lyr[i]->swcBulk_min, s->lyr[i]->swcBulk_init, s->lyr[i]->swcBulk_saturated, s->lyr[i]->sTemp); + s->lyr[i]->fractionWeightMatric_clay, s->lyr[i]->swcBulk_atSWPcrit[SW_FORBS], s->lyr[i]->swcBulk_atSWPcrit[SW_TREES], s->lyr[i]->swcBulk_atSWPcrit[SW_SHRUB], + s->lyr[i]->swcBulk_atSWPcrit[SW_GRASS], s->lyr[i]->swcBulk_wet, s->lyr[i]->swcBulk_min, s->lyr[i]->swcBulk_init, s->lyr[i]->swcBulk_saturated, s->lyr[i]->sTemp); } LogError(logfp, LOGNOTE, "\n Water Potential values:\n"); @@ -950,10 +950,10 @@ void _echo_inputs(void) { LogError(logfp, LOGNOTE, " %3d %15.4f %15.4f %15.4f %15.4f %15.4f %15.4f %15.4f %15.4f %15.4f\n", i + 1, SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_fieldcap, i), SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_wiltpt, i), - SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_atSWPcrit_forb, i), - SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_atSWPcrit_tree, i), - SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_atSWPcrit_shrub, i), - SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_atSWPcrit_grass, i), + SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_atSWPcrit[SW_FORBS], i), + SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_atSWPcrit[SW_TREES], i), + SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_atSWPcrit[SW_SHRUB], i), + SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_atSWPcrit[SW_GRASS], i), SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_wet, i), SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_min, i), SW_SWCbulk2SWPmatric(s->lyr[i]->fractionVolBulk_gravel, s->lyr[i]->swcBulk_init, i)); diff --git a/SW_Site.h b/SW_Site.h index f05c326a5..a8f2529b3 100644 --- a/SW_Site.h +++ b/SW_Site.h @@ -39,7 +39,7 @@ fractionVolBulk_gravel is the gravel content as a fraction of the bulk soil renamed many of the of the variables in SW_LAYER_INFO to better reflect BULK and MATRIC values due to the renaming, also had to update the use of these variables in the other files. - 07/09/2013 (clk) added the variables transp_coeff_forb, swcBulk_atSWPcrit_forb, and my_transp_rgn_forb to SW_LAYER_INFO + 07/09/2013 (clk) added the variables transp_coeff[SW_FORBS], swcBulk_atSWPcrit[SW_FORBS], and my_transp_rgn[SW_FORBS] to SW_LAYER_INFO 07/09/2013 (clk) added the variable n_transp_lyrs_forb to SW_SITE */ /********************************************************/ @@ -57,7 +57,7 @@ typedef struct { RealD width, /* width of the soil layer (cm) */ soilBulk_density, /* bulk soil density, i.e., including gravel component, (g/cm3) */ evap_coeff, /* prop. of total soil evap from this layer */ - transp_coeff_forb, transp_coeff_tree, transp_coeff_shrub, transp_coeff_grass, /* prop. of total transp from this layer */ + transp_coeff[NVEGTYPES], /* prop. of total transp from this layer */ soilMatric_density, /* matric soil density, i.e., gravel component excluded, (g/cm3) */ fractionVolBulk_gravel, /* gravel content (> 2 mm) as volume-fraction of bulk soil (g/cm3) */ fractionWeightMatric_sand, /* sand content (< 2 mm & > . mm) as weight-fraction of matric soil (g/g) */ @@ -69,7 +69,7 @@ typedef struct { swcBulk_min, /* swc cannot go below this (cm) *width */ swcBulk_saturated, /* saturated soil water content (cm) * width */ impermeability, /* fraction of how impermeable a layer is (0=permeable, 1=impermeable) */ - swcBulk_atSWPcrit_forb, swcBulk_atSWPcrit_tree, swcBulk_atSWPcrit_shrub, swcBulk_atSWPcrit_grass, /* swc at the critical soil water potential */ + swcBulk_atSWPcrit[NVEGTYPES], /* swc at the critical soil water potential */ thetasMatric, /* This group is parameters for */ psisMatric, /* Cosby et al. (1982) SWC <-> SWP */ @@ -78,10 +78,10 @@ typedef struct { sTemp; /* initial soil temperature for each soil layer */ - LyrIndex my_transp_rgn_forb, my_transp_rgn_tree, my_transp_rgn_shrub, my_transp_rgn_grass; /* which transp zones from Site am I in? */ - + LyrIndex my_transp_rgn[NVEGTYPES]; /* which transp zones from Site am I in? */ } SW_LAYER_INFO; + typedef struct { Bool reset_yr, /* 1: reset values at start of each year */ @@ -91,8 +91,9 @@ typedef struct { LyrIndex n_layers, /* total number of soil layers */ n_transp_rgn, /* soil layers are grouped into n transp. regions */ n_evap_lyrs, /* number of layers in which evap is possible */ - n_transp_lyrs_forb, n_transp_lyrs_tree, n_transp_lyrs_shrub, n_transp_lyrs_grass, /* layer index of deepest transp. region */ + n_transp_lyrs[NVEGTYPES], /* layer index of deepest transp. region */ deep_lyr; /* index of deep drainage layer if deepdrain, 0 otherwise */ + RealD slow_drain_coeff, /* low soil water drainage coefficient */ pet_scale, /* changes relative effect of PET calculation */ latitude, /* latitude of the site (radians) */ diff --git a/SW_SoilWater.h b/SW_SoilWater.h index 12ad52783..11a846db5 100644 --- a/SW_SoilWater.h +++ b/SW_SoilWater.h @@ -23,8 +23,8 @@ 02/19/2011 (drs) moved soil_inf from SW_SOILWAT and SW_SOILWAT_OUTPUTS to SW_WEATHER and SW_WEATHER_OUTPUTS 07/22/2011 (drs) added for saturated conditions: surfaceWater and surfaceWater_evap to SW_SOILWAT_OUTPUTS and SW_SOILWAT 08/22/2011 (drs) added function RealD SW_SnowDepth( RealD SWE, RealD snowdensity) - 09/08/2011 (drs) replaced in both struct SW_SOILWAT_OUTPUTS and SW_SOILWAT RealD crop_int, forest_int with RealD tree_int, shrub_int, grass_int - 09/09/2011 (drs) replaced in both struct SW_SOILWAT_OUTPUTS and SW_SOILWAT RealD veg_evap with RealD tree_evap, shrub_evap, grass_evap + 09/08/2011 (drs) replaced in both struct SW_SOILWAT_OUTPUTS and SW_SOILWAT RealD crop_int, forest_int with RealD int_veg[SW_TREES], int_veg[SW_SHRUB], int_veg[SW_GRASS] + 09/09/2011 (drs) replaced in both struct SW_SOILWAT_OUTPUTS and SW_SOILWAT RealD veg_evap with RealD evap_veg[SW_TREES], evap_veg[SW_SHRUB], evap_veg[SW_GRASS] 09/09/2011 (drs) replaced in both struct SW_SOILWAT_OUTPUTS and SW_SOILWAT RealD transpiration and hydred with RealD transpiration_xx, hydred_xx for each vegetation type (tree, shrub, grass) 09/12/2011 (drs) added RealD snowdepth [TWO_DAYS] to struct SW_SOILWAT_OUTPUTS and SW_SOILWAT 02/03/2012 (drs) added function 'RealD SW_SWC_SWCres(RealD sand, RealD clay, RealD porosity)': which calculates 'Brooks-Corey' residual volumetric soil water based on Rawls & Brakensiek (1985) @@ -32,8 +32,8 @@ 04/16/2013 (clk) Added the variables vwcMatric, and swaMatric to SW_SOILWAT_OUTPUTS Also, renamed a few of the other variables to better reflect MATRIC vs BULK values and SWC vs VWC. modified the use of these variables throughout the rest of the code. - 07/09/2013 (clk) Added the variables transp_forb, forb_evap, hydred_forb, and forb_int to SW_SOILWAT_OUTPUTS - Added the variables transpiration_forb, hydred_forb, forb_evap, and forb_int to SW_SOILWAT + 07/09/2013 (clk) Added the variables transp_forb, evap_veg[SW_FORBS], hydred[SW_FORBS], and int_veg[SW_FORBS] to SW_SOILWAT_OUTPUTS + Added the variables transpiration_forb, hydred[SW_FORBS], evap_veg[SW_FORBS], and int_veg[SW_FORBS] to SW_SOILWAT */ /********************************************************/ /********************************************************/ @@ -66,17 +66,15 @@ typedef struct { vwcMatric[MAX_LAYERS], swcBulk[MAX_LAYERS], /* soil water content cm/layer */ swpMatric[MAX_LAYERS], /* soil water potential */ swaBulk[MAX_LAYERS], /* available soil water cm/layer, swc-(wilting point) */ - swaMatric[MAX_LAYERS], transp_total[MAX_LAYERS], transp_tree[MAX_LAYERS], transp_forb[MAX_LAYERS], transp_shrub[MAX_LAYERS], transp_grass[MAX_LAYERS], evap[MAX_LAYERS], - lyrdrain[MAX_LAYERS], hydred_total[MAX_LAYERS], hydred_tree[MAX_LAYERS], /* hydraulic redistribution cm/layer */ - hydred_forb[MAX_LAYERS], hydred_shrub[MAX_LAYERS], hydred_grass[MAX_LAYERS], surfaceWater, total_evap, surfaceWater_evap, tree_evap, forb_evap, shrub_evap, - grass_evap, - litter_evap, - total_int, - tree_int, - forb_int, - shrub_int, - grass_int, - litter_int, + swaMatric[MAX_LAYERS], + transp_total[MAX_LAYERS], transp[NVEGTYPES][MAX_LAYERS], + evap[MAX_LAYERS], + lyrdrain[MAX_LAYERS], + hydred_total[MAX_LAYERS], hydred[NVEGTYPES][MAX_LAYERS], /* hydraulic redistribution cm/layer */ + surfaceWater, surfaceWater_evap, + total_evap, evap_veg[NVEGTYPES], + litter_evap, + total_int, int_veg[NVEGTYPES], litter_int, snowpack, snowdepth, et, @@ -93,19 +91,19 @@ typedef struct { /* current daily soil water related values */ Bool is_wet[MAX_LAYERS]; /* swc sufficient to count as wet today */ - RealD swcBulk[TWO_DAYS][MAX_LAYERS], snowpack[TWO_DAYS], /* swe of snowpack, if accumulation flag set */ - snowdepth, transpiration_tree[MAX_LAYERS], transpiration_forb[MAX_LAYERS], transpiration_shrub[MAX_LAYERS], transpiration_grass[MAX_LAYERS], evaporation[MAX_LAYERS], - drain[MAX_LAYERS], /* amt of swc able to drain from curr layer to next */ - hydred_tree[MAX_LAYERS], /* hydraulic redistribution cm/layer */ - hydred_forb[MAX_LAYERS], hydred_shrub[MAX_LAYERS], hydred_grass[MAX_LAYERS], surfaceWater, surfaceWater_evap, pet, aet, litter_evap, tree_evap, forb_evap, - shrub_evap, grass_evap, - litter_int, - tree_int, - forb_int, - shrub_int, - grass_int, - sTemp[MAX_LAYERS], - surfaceTemp; // soil surface temperature + RealD swcBulk[TWO_DAYS][MAX_LAYERS], + snowpack[TWO_DAYS], /* swe of snowpack, if accumulation flag set */ + snowdepth, + transpiration[NVEGTYPES][MAX_LAYERS], + evaporation[MAX_LAYERS], + drain[MAX_LAYERS], /* amt of swc able to drain from curr layer to next */ + hydred[NVEGTYPES][MAX_LAYERS], /* hydraulic redistribution cm/layer */ + surfaceWater, surfaceWater_evap, + pet, aet, + litter_evap, evap_veg[NVEGTYPES], + litter_int, int_veg[NVEGTYPES], + sTemp[MAX_LAYERS], + surfaceTemp; // soil surface temperature Bool partsError; // soil temperature error indicator diff --git a/SW_VegEstab.c b/SW_VegEstab.c index 24debe760..32096ab39 100644 --- a/SW_VegEstab.c +++ b/SW_VegEstab.c @@ -377,7 +377,9 @@ static void _sanity_check(unsigned int sppnum) { SW_VEGESTAB_INFO *v = SW_VegEstab.parms[sppnum]; LyrIndex min_transp_lyrs; - min_transp_lyrs = min(SW_Site.n_transp_lyrs_tree, min(SW_Site.n_transp_lyrs_forb, min(SW_Site.n_transp_lyrs_shrub, SW_Site.n_transp_lyrs_grass))); + min_transp_lyrs = min(SW_Site.n_transp_lyrs[SW_TREES], + min(SW_Site.n_transp_lyrs[SW_SHRUB], min(SW_Site.n_transp_lyrs[SW_FORBS], + SW_Site.n_transp_lyrs[SW_GRASS]))); if (v->estab_lyrs > min_transp_lyrs) { LogError(logfp, LOGFATAL, "%s : Layers requested (estab_lyrs) > (# transpiration layers=%d).", MyFileName, min_transp_lyrs);