/*******************************************************************************
Function name: InitRadar()
Purpose : Read the radar information from the options file. This
information is in the [METEOROLOGY] section
Required :
LISTPTR Input - Linked list with input strings
MAPSIZE *Map - Information about basin area
TIMESTRUCT *Time - Time information
INPUTFILES *InFiles - Filenames for various input files
MAPSIZE *Radar - Information about radar coverage
Returns : void
Modifies : Members of Time, InFiles and Radar
Comments :
*****************************************************************************/
void InitRadar(LISTPTR Input, MAPSIZE * Map, TIMESTRUCT * Time,
INPUTFILES * InFiles, MAPSIZE * Radar)
{
DATE Start;
int i;
STRINIENTRY StrEnv[] = {
{"METEOROLOGY", "RADAR START", "", ""},
{"METEOROLOGY", "RADAR FILE", "", ""},
{"METEOROLOGY", "RADAR EXTREME NORTH", "", ""},
{"METEOROLOGY", "RADAR EXTREME WEST", "", ""},
{"METEOROLOGY", "RADAR NUMBER OF ROWS", "", ""},
{"METEOROLOGY", "RADAR NUMBER OF COLUMNS", "", ""},
{"METEOROLOGY", "RADAR GRID SPACING", "", ""},
{NULL, NULL, "", NULL},
};
/* Read the key-entry pairs from the input file */
for (i = 0; StrEnv[i].SectionName; i++)
GetInitString(StrEnv[i].SectionName, StrEnv[i].KeyName, StrEnv[i].Default,
StrEnv[i].VarStr, (unsigned long)BUFSIZE, Input);
/* Assign the entries to the variables */
if (!SScanDate(StrEnv[radar_start].VarStr, &Start))
ReportError(StrEnv[radar_start].KeyName, 51);
InitTime(Time, NULL, NULL, &Start, NULL, Time->Dt);
if (IsEmptyStr(StrEnv[radar_file].VarStr))
ReportError(StrEnv[radar_file].KeyName, 51);
strcpy(InFiles->RadarFile, StrEnv[radar_file].VarStr);
/**************** Determine areal extent ****************/
strcpy(Radar->System, Map->System);
if (!CopyDouble(&(Radar->Yorig), StrEnv[radar_north].VarStr, 1))
ReportError(StrEnv[radar_north].KeyName, 51);
if (!CopyDouble(&(Radar->Xorig), StrEnv[radar_west].VarStr, 1))
ReportError(StrEnv[radar_west].KeyName, 51);
if (!CopyInt(&(Radar->NY), StrEnv[radar_rows].VarStr, 1))
ReportError(StrEnv[radar_rows].KeyName, 51);
if (!CopyInt(&(Radar->NX), StrEnv[radar_cols].VarStr, 1))
ReportError(StrEnv[radar_cols].KeyName, 51);
if (!CopyFloat(&(Radar->DY), StrEnv[radar_grid].VarStr, 1))
ReportError(StrEnv[radar_grid].KeyName, 51);
Radar->DXY = sqrt(Radar->DX * Radar->DX + Radar->DY * Radar->DY);
Radar->X = 0;
Radar->Y = 0;
Radar->OffsetX = Round(((float)(Radar->Xorig - Map->Xorig)) /
((float)Map->DX));
Radar->OffsetY = Round(((float)(Radar->Yorig - Map->Yorig)) /
((float)Map->DY));
if (Radar->OffsetX > 0 || Radar->OffsetY < 0)
ReportError("Input Options File", 31);
}
int WriteRecord0( FILE* f, EphCtx* ctx, long recordSize)
{
int retVal;
/*** SS ***/
if (0 != fseek(f, OFFSET_IN_FILE(SS), SEEK_SET))
{
return ERR_FILE_SEEK;
}
if (3 != fwrite(ctx->ss, sizeof(double), 3, f))
{
return ERR_FILE_WRITE;
}
/*** ncon ****/
if ( 1 != fwrite(&ctx->nCon, sizeof(int), 1, f))
{
}
/*** AU ***/
if ((retVal = CopyDouble( f, recordSize + ctx->auIndex * sizeof(double),
OFFSET_IN_FILE(AU))))
{
return retVal;
}
/*** EMRATIO ***/
if ((retVal = CopyDouble( f, recordSize + ctx->emRatioIndex * sizeof(double),
OFFSET_IN_FILE(EmRatio))))
{
return retVal;
}
/*** DENUM ***/
if ((retVal = CopyDouble2Int( f, recordSize + ctx->denumIndex * sizeof(double),
OFFSET_IN_FILE(Denum))))
{
return retVal;
}
return 0;
}
/*******************************************************************************
Function name: InitPixDump()
Purpose : Initialize the pixel dumps. This information is in the
[OUTPUT] section of the input file
Required :
LISTPTR Input - Linked list with input strings
MAPSIZE *Map - Information about basin extent
uchar **BasinMask - Basin mask
char *Path - Directory to write output to
int NPix - Number of pixels to dump
PIXDUMP **Pix - Array of pixels to dump
Returns : number of accepted dump pixels (i.e. in the mask, etc)
Modifies : NPix and its members
Comments :
*******************************************************************************/
int InitPixDump(LISTPTR Input, MAPSIZE *Map, uchar **BasinMask, char *Path,
int NPix, PIXDUMP **Pix, OPTIONSTRUCT *Options)
{
char *Routine = "InitPixDump";
char Str[BUFSIZE + 1];
double North;
double East;
int i; /* counter */
int j;
int ok;
char temp_name[BUFSIZE + 1];
char KeyName[name + 1][BUFSIZE + 1];
char *KeyStr[] = {
"NORTH COORDINATE",
"EAST COORDINATE",
"NAME"
};
char *SectionName = "OUTPUT";
char VarStr[name + 1][BUFSIZE + 1];
ok = 0;
if (!(*Pix = (PIXDUMP *)calloc(NPix, sizeof(PIXDUMP))))
ReportError(Routine, 1);
for (i = 0; i < NPix; i++) {
/* Read the key-entry pairs from the input file */
for (j = 0; j <= name; j++) {
sprintf(KeyName[j], "%s %d", KeyStr[j], i + 1);
GetInitString(SectionName, KeyName[j], "", VarStr[j],
(unsigned long)BUFSIZE, Input);
}
/* Assign the entries to the appropriate variables */
if (!CopyDouble(&North, VarStr[north], 1))
ReportError(KeyName[north], 51);
if (!CopyDouble(&East, VarStr[east], 1))
ReportError(KeyName[east], 51);
if (IsEmptyStr(VarStr[name]))
ReportError(KeyName[name], 51);
strcpy(temp_name, VarStr[name]);
/* Convert map coordinates to matrix coordinates */
(*Pix)[i].Loc.N = Round(((Map->Yorig - 0.5 * Map->DY) - North) / Map->DY);
(*Pix)[i].Loc.E = Round((East - (Map->Xorig + 0.5 * Map->DX)) / Map->DX);
if (!InArea(Map, &((*Pix)[i].Loc)) ||
!INBASIN(BasinMask[(*Pix)[i].Loc.N][(*Pix)[i].Loc.E])) {
printf("Ignoring dump command for pixel named %s \n", temp_name);
}
else {
printf("Accepting dump command for pixel named %s \n", temp_name);
sprintf(Str, "%s", temp_name);
sprintf((*Pix)[ok].OutFile.FileName, "%sPixel.%s", Path, Str);
(*Pix)[ok].Loc.N = (*Pix)[i].Loc.N;
(*Pix)[ok].Loc.E = (*Pix)[i].Loc.E;
OpenFile(&((*Pix)[ok].OutFile.FilePtr), (*Pix)[ok].OutFile.FileName, "w", TRUE);
ok++;
}
}
return ok;
}
/*****************************************************************************
Function name: InitConstants()
Purpose : Initialize constants and settings for DHSVM run
Processes the following sections in InFile:
[OPTIONS]
[AREA]
[TIME]
[CONSTANTS}
Required :
LISTPTR Input - Linked list with input strings
OPTIONSTRUCT *Options - Structure with different program options
MAPSIZE *Map - Coverage and resolution of model area
SOLARGEOMETRY *SolarGeo - Solar geometry information
TIMESTRUCT *Time - Begin and end times, model timestep
Returns : void
Modifies : (see list of required above)
Comments :
*****************************************************************************/
void InitConstants(LISTPTR Input, OPTIONSTRUCT * Options, MAPSIZE * Map,
SOLARGEOMETRY * SolarGeo, TIMESTRUCT * Time)
{
int i; /* counter */
double PointModelX; /* X-coordinate for POINT model mode */
double PointModelY; /* Y-coordinate for POINT model mode */
float TimeStep; /* Timestep in hours */
DATE End; /* End of run */
DATE Start; /* Start of run */
STRINIENTRY StrEnv[] = {
{"OPTIONS", "FORMAT", "", ""},
{"OPTIONS", "EXTENT", "", ""},
{"OPTIONS", "GRADIENT", "", ""},
{"OPTIONS", "FLOW ROUTING", "", ""},
{"OPTIONS", "SENSIBLE HEAT FLUX", "", ""},
{"OPTIONS", "SEDIMENT", "", ""},
{"OPTIONS", "SEDIMENT INPUT FILE", "", ""},
{"OPTIONS", "OVERLAND ROUTING", "", ""},
{"OPTIONS", "INFILTRATION", "", ""},
{"OPTIONS", "INTERPOLATION", "", ""},
{"OPTIONS", "MM5", "", ""},
{"OPTIONS", "QPF", "", ""},
{"OPTIONS", "PRISM", "", ""},
{"OPTIONS", "CANOPY RADIATION ATTENUATION MODE", "", ""},
{"OPTIONS", "SHADING", "", ""},
{"OPTIONS", "SNOTEL", "", ""},
{"OPTIONS", "OUTSIDE", "", ""},
{"OPTIONS", "RHOVERRIDE", "", ""},
{"OPTIONS", "PRECIPITATION SOURCE", "", ""},
{"OPTIONS", "WIND SOURCE", "", ""},
{"OPTIONS", "TEMPERATURE LAPSE RATE", "", ""},
{"OPTIONS", "PRECIPITATION LAPSE RATE", "", ""},
{"OPTIONS", "CRESSMAN RADIUS", "", ""},
{"OPTIONS", "CRESSMAN STATIONS", "", ""},
{"OPTIONS", "PRISM DATA PATH", "", ""},
{"OPTIONS", "PRISM DATA EXTENSION", "", ""},
{"OPTIONS", "SHADING DATA PATH", "", ""},
{"OPTIONS", "SHADING DATA EXTENSION", "", ""},
{"OPTIONS", "SKYVIEW DATA PATH", "", ""},
{"OPTIONS", "STREAM TEMPERATURE", "", ""},
{"OPTIONS", "CANOPY SHADING", "", ""},
{"AREA", "COORDINATE SYSTEM", "", ""},
{"AREA", "EXTREME NORTH", "", ""},
{"AREA", "EXTREME WEST", "", ""},
{"AREA", "CENTER LATITUDE", "", ""},
{"AREA", "CENTER LONGITUDE", "", ""},
{"AREA", "TIME ZONE MERIDIAN", "", ""},
{"AREA", "NUMBER OF ROWS", "", ""},
{"AREA", "NUMBER OF COLUMNS", "", ""},
{"AREA", "GRID SPACING", "", ""},
{"AREA", "POINT NORTH", "", ""},
{"AREA", "POINT EAST", "", ""},
{"TIME", "TIME STEP", "", ""},
{"TIME", "MODEL START", "", ""},
{"TIME", "MODEL END", "", ""},
{"CONSTANTS", "GROUND ROUGHNESS", "", ""},
{"CONSTANTS", "SNOW ROUGHNESS", "", ""},
{"CONSTANTS", "RAIN THRESHOLD", "", ""},
{"CONSTANTS", "SNOW THRESHOLD", "", ""},
{"CONSTANTS", "SNOW WATER CAPACITY", "", ""},
{"CONSTANTS", "REFERENCE HEIGHT", "", ""},
{"CONSTANTS", "RAIN LAI MULTIPLIER", "", ""},
{"CONSTANTS", "SNOW LAI MULTIPLIER", "", ""},
{"CONSTANTS", "MIN INTERCEPTED SNOW", "", ""},
{"CONSTANTS", "OUTSIDE BASIN VALUE", "", ""},
{"CONSTANTS", "TEMPERATURE LAPSE RATE", "", ""},
{"CONSTANTS", "PRECIPITATION LAPSE RATE", "", ""},
{"CONSTANTS", "PRECIPITATION MULTIPLIER", "", ""},
{"CONSTANTS", "TREE HEIGHT", "", ""},
{"CONSTANTS", "BUFFER WIDTH", "", ""},
{"CONSTANTS", "OVERHANG COEFFICIENT", "", ""},
{"CONSTANTS", "MONTHLY EXTINCTION COEFFICIENT", "", ""},
{"CONSTANTS", "CANOPY BANK DISTANCE", "", ""},
{NULL, NULL, "", NULL}
};
/* Read the key-entry pairs from the input file */
for (i = 0; StrEnv[i].SectionName; i++)
GetInitString(StrEnv[i].SectionName, StrEnv[i].KeyName, StrEnv[i].Default,
StrEnv[i].VarStr, (unsigned long) BUFSIZE, Input);
/**************** Determine model options ****************/
/* Determine file format to be used */
if (strncmp(StrEnv[format].VarStr, "BIN", 3) == 0)
Options->FileFormat = BIN;
else if (strncmp(StrEnv[format].VarStr, "NETCDF", 3) == 0)
Options->FileFormat = NETCDF;
else if (strncmp(StrEnv[format].VarStr, "BYTESWAP", 3) == 0)
Options->FileFormat = BYTESWAP;
else
ReportError(StrEnv[format].KeyName, 51);
/* Determine whether the model should be run in POINT mode or in BASIN mode.
If in POINT mode also read which pixel to model */
if (strncmp(StrEnv[extent].VarStr, "POINT", 5) == 0) {
Options->Extent = POINT;
Options->HasNetwork = FALSE;
}
else if (strncmp(StrEnv[extent].VarStr, "BASIN", 5) == 0) {
Options->Extent = BASIN;
}
else
ReportError(StrEnv[extent].KeyName, 51);
/* Determine how the flow gradient should be calculated */
if (Options->Extent != POINT) {
if (strncmp(StrEnv[gradient].VarStr, "TOPO", 4) == 0)
Options->FlowGradient = TOPOGRAPHY;
else if (strncmp(StrEnv[gradient].VarStr, "WATER", 5) == 0)
Options->FlowGradient = WATERTABLE;
else
ReportError(StrEnv[gradient].KeyName, 51);
}
else
Options->FlowGradient = NOT_APPLICABLE;
/* Determine what meterological interpolation to use */
if (strncmp(StrEnv[interpolation].VarStr, "INVDIST", 7) == 0)
Options->Interpolation = INVDIST;
else if (strncmp(StrEnv[interpolation].VarStr, "NEAREST", 7) == 0)
Options->Interpolation = NEAREST;
else if (strncmp(StrEnv[interpolation].VarStr, "VARCRESS", 8) == 0)
Options->Interpolation = VARCRESS;
else
ReportError(StrEnv[interpolation].KeyName, 51);
/* if VARIABLE CRESTMAN interpolation then get parameters */
if (Options->Interpolation == VARCRESS) {
if (!CopyInt(&(Options->CressRadius), StrEnv[cressman_radius].VarStr, 1))
ReportError(StrEnv[cressman_radius].KeyName, 51);
if (!CopyInt
(&(Options->CressStations), StrEnv[cressman_stations].VarStr, 1))
ReportError(StrEnv[cressman_stations].KeyName, 51);
}
/* Determine whether a road/network is imposed on the model area */
if (Options->Extent != POINT) {
if (strncmp(StrEnv[flow_routing].VarStr, "NETWORK", 7) == 0)
Options->HasNetwork = TRUE;
else if (strncmp(StrEnv[flow_routing].VarStr, "UNIT", 4) == 0)
Options->HasNetwork = FALSE;
else
ReportError(StrEnv[flow_routing].KeyName, 51);
}
else
Options->HasNetwork = FALSE;
/* Determine whether a sensible heat flux should be calculated */
if (strncmp(StrEnv[sensible_heat_flux].VarStr, "TRUE", 4) == 0)
Options->HeatFlux = TRUE;
else if (strncmp(StrEnv[sensible_heat_flux].VarStr, "FALSE", 5) == 0)
Options->HeatFlux = FALSE;
else
ReportError(StrEnv[sensible_heat_flux].KeyName, 51);
/* Determine whether sediment model should be run */
if (strncmp(StrEnv[sediment].VarStr, "TRUE", 4) == 0)
Options->Sediment = TRUE;
else if (strncmp(StrEnv[sediment].VarStr, "FALSE", 5) == 0){
printf("WARNING: Sediment option has not been chosen. All erosion\n");
printf("options are being turned off.\n\n");
Options->Sediment = FALSE;
Options->MassWaste = FALSE;
Options->SurfaceErosion = FALSE;
Options->ErosionPeriod = FALSE;
}
else
ReportError(StrEnv[sediment].KeyName, 51);
if(Options->Sediment == TRUE) {
if (IsEmptyStr(StrEnv[sed_input_file].VarStr))
ReportError(StrEnv[sed_input_file].KeyName, 51);
strcpy(Options->SedFile, StrEnv[sed_input_file].VarStr);
}
/* Determine overland flow routing method to use */
if (strncmp(StrEnv[routing].VarStr, "KINEMATIC", 9) == 0)
Options->Routing = TRUE;
else if (strncmp(StrEnv[routing].VarStr, "CONVENTIONAL", 12) == 0)
Options->Routing = FALSE;
else
ReportError(StrEnv[routing].KeyName, 51);
/* Determine if the maximum infiltration rate is static or dynamic */
if (strncmp(StrEnv[infiltration].VarStr, "STATIC", 6) == 0) {
Options->Infiltration = STATIC;
}
else if (strncmp(StrEnv[infiltration].VarStr, "DYNAMIC", 7) == 0) {
Options->Infiltration = DYNAMIC ;
printf("WARNING: Dynamic maximum infiltration capacity has\n");
printf("not been fully tested. It is a work in progress.\n\n");
}
else
ReportError(StrEnv[infiltration].KeyName, 51);
/* Determine whether the mm5 interface should be used */
if (strncmp(StrEnv[mm5].VarStr, "TRUE", 4) == 0)
Options->MM5 = TRUE;
else if (strncmp(StrEnv[mm5].VarStr, "FALSE", 5) == 0)
Options->MM5 = FALSE;
else
ReportError(StrEnv[mm5].KeyName, 51);
/* Determine whether the QPF override should be used on the MM5 fields */
if (strncmp(StrEnv[qpf].VarStr, "TRUE", 4) == 0)
Options->QPF = TRUE;
else if (strncmp(StrEnv[qpf].VarStr, "FALSE", 5) == 0)
Options->QPF = FALSE;
else
ReportError(StrEnv[qpf].KeyName, 51);
/* Determine if PRISM maps will be used to interpolate precip fields */
if (strncmp(StrEnv[prism].VarStr, "TRUE", 4) == 0)
Options->Prism = TRUE;
else if (strncmp(StrEnv[prism].VarStr, "FALSE", 5) == 0)
Options->Prism = FALSE;
else
ReportError(StrEnv[prism].KeyName, 51);
/* Determine the kind of canopy radiation attenuation to be used */
if (strncmp(StrEnv[canopy_radatt].VarStr, "FIXED", 3) == 0)
Options->CanopyRadAtt = FIXED;
else if (strncmp(StrEnv[canopy_radatt].VarStr, "VARIABLE", 3) == 0)
Options->CanopyRadAtt = VARIABLE;
else
ReportError(StrEnv[canopy_radatt].KeyName, 51);
/* Determine if solar shading maps will be used */
if (strncmp(StrEnv[shading].VarStr, "TRUE", 4) == 0)
Options->Shading = TRUE;
else if (strncmp(StrEnv[shading].VarStr, "FALSE", 5) == 0)
Options->Shading = FALSE;
else
ReportError(StrEnv[shading].KeyName, 51);
if (Options->MM5 == TRUE && Options->Prism == TRUE && Options->QPF == FALSE)
ReportError(StrEnv[prism].KeyName, 51);
/* Determine if Snotel test is called for */
if (strncmp(StrEnv[snotel].VarStr, "TRUE", 4) == 0)
Options->Snotel = TRUE;
else if (strncmp(StrEnv[snotel].VarStr, "FALSE", 5) == 0)
Options->Snotel = FALSE;
else
ReportError(StrEnv[snotel].KeyName, 51);
/* Determine if STREAM TEMP is called for */
if (strncmp(StrEnv[stream_temp].VarStr, "TRUE", 4) == 0)
Options->StreamTemp = TRUE;
else if (strncmp(StrEnv[stream_temp].VarStr, "FALSE", 5) == 0)
Options->StreamTemp = FALSE;
else
ReportError(StrEnv[stream_temp].KeyName, 51);
/* Determine if CANOPY SHADING is called for */
if (strncmp(StrEnv[canopy_shading].VarStr, "TRUE", 4) == 0) {
Options->CanopyShading = TRUE;
if (Options->StreamTemp == FALSE) {
printf("Stream temp module must be turned on to allow canopy shading options\n");
exit(-1);
}
}
else if (strncmp(StrEnv[canopy_shading].VarStr, "FALSE", 5) == 0)
Options->CanopyShading = FALSE;
else
ReportError(StrEnv[canopy_shading].KeyName, 51);
/* Determine if listed met stations outside bounding box are used */
if (strncmp(StrEnv[outside].VarStr, "TRUE", 4) == 0)
Options->Outside = TRUE;
else if (strncmp(StrEnv[outside].VarStr, "FALSE", 5) == 0)
Options->Outside = FALSE;
else
ReportError(StrEnv[outside].KeyName, 51);
if (Options->Prism == TRUE) {
if (IsEmptyStr(StrEnv[prism_data_path].VarStr))
ReportError(StrEnv[prism_data_path].KeyName, 51);
strcpy(Options->PrismDataPath, StrEnv[prism_data_path].VarStr);
if (IsEmptyStr(StrEnv[prism_data_ext].VarStr))
ReportError(StrEnv[prism_data_ext].KeyName, 51);
strcpy(Options->PrismDataExt, StrEnv[prism_data_ext].VarStr);
}
if (Options->Shading == TRUE) {
if (IsEmptyStr(StrEnv[shading_data_path].VarStr))
ReportError(StrEnv[shading_data_path].KeyName, 51);
strcpy(Options->ShadingDataPath, StrEnv[shading_data_path].VarStr);
if (IsEmptyStr(StrEnv[shading_data_ext].VarStr))
ReportError(StrEnv[shading_data_ext].KeyName, 51);
strcpy(Options->ShadingDataExt, StrEnv[shading_data_ext].VarStr);
if (IsEmptyStr(StrEnv[skyview_data_path].VarStr))
ReportError(StrEnv[skyview_data_path].KeyName, 51);
strcpy(Options->SkyViewDataPath, StrEnv[skyview_data_path].VarStr);
}
/* Determine if rh override is used */
if (strncmp(StrEnv[rhoverride].VarStr, "TRUE", 4) == 0)
Options->Rhoverride = TRUE;
else if (strncmp(StrEnv[rhoverride].VarStr, "FALSE", 5) == 0)
Options->Rhoverride = FALSE;
else
ReportError(StrEnv[rhoverride].KeyName, 51);
/* The other met options are only of importance if MM5 is FALSE */
if (Options->MM5 == TRUE) {
Options->PrecipType = NOT_APPLICABLE;
Options->WindSource = NOT_APPLICABLE;
Options->PrecipLapse = NOT_APPLICABLE;
Options->TempLapse = NOT_APPLICABLE;
if (Options->QPF == TRUE)
Options->PrecipType = STATION;
if (Options->QPF == TRUE && Options->Prism == FALSE)
Options->PrecipLapse = CONSTANT;
}
else {
/* Determine the type of precipitation data that the model will use */
if (strncmp(StrEnv[precipitation_source].VarStr, "RADAR", 5) == 0)
Options->PrecipType = RADAR;
else if (strncmp(StrEnv[precipitation_source].VarStr, "STATION", 7) == 0)
Options->PrecipType = STATION;
else
ReportError(StrEnv[precipitation_source].KeyName, 51);
/* Determine the type of wind data that the model will use */
if (strncmp(StrEnv[wind_source].VarStr, "MODEL", 5) == 0)
Options->WindSource = MODEL;
else if (strncmp(StrEnv[wind_source].VarStr, "STATION", 7) == 0)
Options->WindSource = STATION;
else
ReportError(StrEnv[wind_source].KeyName, 51);
/* Determine the type of temperature lapse rate */
if (strncmp(StrEnv[temp_lapse].VarStr, "CONSTANT", 8) == 0)
Options->TempLapse = CONSTANT;
else if (strncmp(StrEnv[temp_lapse].VarStr, "VARIABLE", 8) == 0)
Options->TempLapse = VARIABLE;
else
ReportError(StrEnv[temp_lapse].KeyName, 51);
/* Determine the type of precipitation lapse rate */
if (strncmp(StrEnv[precip_lapse].VarStr, "CONSTANT", 8) == 0)
Options->PrecipLapse = CONSTANT;
else if (strncmp(StrEnv[precip_lapse].VarStr, "MAP", 3) == 0)
Options->PrecipLapse = MAP;
else if (strncmp(StrEnv[precip_lapse].VarStr, "VARIABLE", 8) == 0)
Options->PrecipLapse = VARIABLE;
else
ReportError(StrEnv[precip_lapse].KeyName, 51);
}
/**************** Determine areal extent ****************/
if (IsEmptyStr(StrEnv[coordinate_system].VarStr))
ReportError(StrEnv[coordinate_system].KeyName, 51);
strcpy(Map->System, StrEnv[coordinate_system].VarStr);
if (!CopyDouble(&(Map->Yorig), StrEnv[extreme_north].VarStr, 1))
ReportError(StrEnv[extreme_north].KeyName, 51);
if (!CopyDouble(&(Map->Xorig), StrEnv[extreme_west].VarStr, 1))
ReportError(StrEnv[extreme_west].KeyName, 51);
if (!CopyFloat(&(SolarGeo->Latitude), StrEnv[center_latitude].VarStr, 1))
ReportError(StrEnv[center_latitude].KeyName, 51);
SolarGeo->Latitude *= (float) RADPDEG;
if (!CopyFloat(&(SolarGeo->Longitude), StrEnv[center_longitude].VarStr, 1))
ReportError(StrEnv[center_longitude].KeyName, 51);
SolarGeo->Longitude *= (float) RADPDEG;
if (!CopyFloat(&(SolarGeo->StandardMeridian),
StrEnv[time_zone_meridian].VarStr, 1))
ReportError(StrEnv[time_zone_meridian].KeyName, 51);
SolarGeo->StandardMeridian *= (float) RADPDEG;
if (!CopyInt(&(Map->NY), StrEnv[number_of_rows].VarStr, 1))
ReportError(StrEnv[number_of_rows].KeyName, 51);
if (!CopyInt(&(Map->NX), StrEnv[number_of_columns].VarStr, 1))
ReportError(StrEnv[number_of_columns].KeyName, 51);
if (!CopyFloat(&(Map->DY), StrEnv[grid_spacing].VarStr, 1))
ReportError(StrEnv[grid_spacing].KeyName, 51);
Map->DX = Map->DY;
Map->DXY = (float) sqrt(Map->DX * Map->DX + Map->DY * Map->DY);
Map->X = 0;
Map->Y = 0;
Map->OffsetX = 0;
Map->OffsetY = 0;
Map->NumCells = 0;
if (Options->Extent == POINT) {
if (!CopyDouble(&PointModelY, StrEnv[point_north].VarStr, 1))
ReportError(StrEnv[point_north].KeyName, 51);
if (!CopyDouble(&PointModelX, StrEnv[point_east].VarStr, 1))
ReportError(StrEnv[point_east].KeyName, 51);
Options->PointY =
Round(((Map->Yorig - 0.5 * Map->DY) - PointModelY) / Map->DY);
Options->PointX =
Round((PointModelX - (Map->Xorig + 0.5 * Map->DX)) / Map->DX);
}
else {
Options->PointY = 0;
Options->PointX = 0;
}
/**************** Determine model period ****************/
if (!CopyFloat(&(TimeStep), StrEnv[time_step].VarStr, 1))
ReportError(StrEnv[time_step].KeyName, 51);
TimeStep *= SECPHOUR;
if (!SScanDate(StrEnv[model_start].VarStr, &(Start)))
ReportError(StrEnv[model_start].KeyName, 51);
if (!SScanDate(StrEnv[model_end].VarStr, &(End)))
ReportError(StrEnv[model_end].KeyName, 51);
InitTime(Time, &Start, &End, NULL, NULL, (int) TimeStep);
/**************** Determine model constants ****************/
if (!CopyFloat(&Z0_GROUND, StrEnv[ground_roughness].VarStr, 1))
ReportError(StrEnv[ground_roughness].KeyName, 51);
if (!CopyFloat(&Z0_SNOW, StrEnv[snow_roughness].VarStr, 1))
ReportError(StrEnv[snow_roughness].KeyName, 51);
if (!CopyFloat(&MIN_RAIN_TEMP, StrEnv[rain_threshold].VarStr, 1))
ReportError(StrEnv[rain_threshold].KeyName, 51);
if (!CopyFloat(&MAX_SNOW_TEMP, StrEnv[snow_threshold].VarStr, 1))
ReportError(StrEnv[snow_threshold].KeyName, 51);
if (!CopyFloat(&LIQUID_WATER_CAPACITY, StrEnv[snow_water_capacity].VarStr, 1))
ReportError(StrEnv[snow_water_capacity].KeyName, 51);
if (!CopyFloat(&Zref, StrEnv[reference_height].VarStr, 1))
ReportError(StrEnv[reference_height].KeyName, 51);
if (!CopyFloat(&LAI_WATER_MULTIPLIER, StrEnv[rain_lai_multiplier].VarStr, 1))
ReportError(StrEnv[rain_lai_multiplier].KeyName, 51);
if (!CopyFloat(&LAI_SNOW_MULTIPLIER, StrEnv[snow_lai_multiplier].VarStr, 1))
ReportError(StrEnv[snow_lai_multiplier].KeyName, 51);
if (!CopyFloat(&MIN_INTERCEPTION_STORAGE,
StrEnv[min_intercepted_snow].VarStr, 1))
ReportError(StrEnv[min_intercepted_snow].KeyName, 51);
if (!CopyUChar(&OUTSIDEBASIN, StrEnv[outside_basin].VarStr, 1))
ReportError(StrEnv[outside_basin].KeyName, 51);
if (Options->TempLapse == CONSTANT) {
if (!CopyFloat(&TEMPLAPSE, StrEnv[temp_lapse_rate].VarStr, 1))
ReportError(StrEnv[temp_lapse_rate].KeyName, 51);
}
else
TEMPLAPSE = NOT_APPLICABLE;
if (Options->PrecipLapse == CONSTANT) {
if (!CopyFloat(&PRECIPLAPSE, StrEnv[precip_lapse_rate].VarStr, 1))
ReportError(StrEnv[precip_lapse_rate].KeyName, 51);
}
else
PRECIPLAPSE = NOT_APPLICABLE;
if (!CopyFloat(&PRECIPMULTIPLIER, StrEnv[precip_multiplier].VarStr, 1))
ReportError(StrEnv[precip_multiplier].KeyName, 51);
/* assign values to riparian vegetations */
if (Options->StreamTemp && Options->CanopyShading) {
if (!CopyFloat(&TREEHEIGHT, StrEnv[tree_height].VarStr, 1))
ReportError(StrEnv[tree_height].KeyName, 51);
if (!CopyFloat(&BUFFERWIDTH, StrEnv[buffer_width].VarStr, 1))
ReportError(StrEnv[buffer_width].KeyName, 51);
if (!CopyFloat(&OvhCoeff, StrEnv[ovh].VarStr, 1))
ReportError(StrEnv[ovh].KeyName, 51);
if (!CopyFloat(ExtnCoeff, StrEnv[extn].VarStr, 12))
ReportError(StrEnv[extn].KeyName, 51);
if (!CopyFloat(&CanopyBankDist, StrEnv[canopy_bank_dist].VarStr, 1))
ReportError(StrEnv[canopy_bank_dist].KeyName, 51);
printf("Calculate canopy shading effect on stream temperature: \n");
printf("Tree Height = %.1f\n", TREEHEIGHT);
printf("Buffer Width = %.1f\n", BUFFERWIDTH);
printf("Monthly Extinction Coefficient = \n");
for (i = 0; i < 12; i++)
printf("%.3f ", ExtnCoeff[i]);
printf("\n");
printf("Bank to Canopy Distance = %.3f\n\n\n", CanopyBankDist);
}
else {
TREEHEIGHT = NOT_APPLICABLE;
BUFFERWIDTH = NOT_APPLICABLE;
OvhCoeff = NOT_APPLICABLE;
for (i = 0; i < 12; i++)
ExtnCoeff[i] = NOT_APPLICABLE;
CanopyBankDist = NOT_APPLICABLE;
}
}
/*******************************************************************************
Function name: InitMM5()
Purpose : Read the MM5 information the options file. This information
is in the [METEOROLOGY] section
Required :
LISTPTR Input - Linked list with input options
int NSoilLayers - Number of soil layers
TIMESTRUCT *Time - Time information
INPUTFILES *InFiles - Filenames for various input files
Returns : void
Modifies : Members of Time and InFiles
Comments :
*****************************************************************************/
void InitMM5(LISTPTR Input, int NSoilLayers, TIMESTRUCT *Time,
INPUTFILES *InFiles, OPTIONSTRUCT *Options, MAPSIZE *MM5Map, MAPSIZE *Map)
{
DATE Start;
char *Routine = "InitMM5";
char KeyName[BUFSIZE + 1];
char VarStr[BUFSIZE + 1];
int i;
STRINIENTRY StrEnv[] = {
{"METEOROLOGY", "MM5 START", "", ""},
{"METEOROLOGY", "MM5 TEMPERATURE FILE", "", ""},
{"METEOROLOGY", "MM5 HUMIDITY FILE", "", ""},
{"METEOROLOGY", "MM5 WIND SPEED FILE", "", ""},
{"METEOROLOGY", "MM5 SHORTWAVE FILE", "", ""},
{"METEOROLOGY", "MM5 LONGWAVE FILE", "", ""},
{"METEOROLOGY", "MM5 PRECIPITATION FILE", "", ""},
{"METEOROLOGY", "MM5 TERRAIN FILE", "", ""},
{"METEOROLOGY", "MM5 TEMP LAPSE FILE", "", ""},
{"METEOROLOGY", "MM5 ROWS", "", ""},
{"METEOROLOGY", "MM5 COLS", "", ""},
{"METEOROLOGY", "MM5 EXTREME NORTH", "", ""},
{"METEOROLOGY", "MM5 EXTREME WEST", "", ""},
{"METEOROLOGY", "MM5 DY", "", ""},
{NULL, NULL, "", NULL},
};
/* Read the key-entry pairs from the input file */
for (i = 0; StrEnv[i].SectionName; i++)
GetInitString(StrEnv[i].SectionName, StrEnv[i].KeyName, StrEnv[i].Default,
StrEnv[i].VarStr, (unsigned long)BUFSIZE, Input);
/* Assign the entries to the variables */
if (!SScanDate(StrEnv[MM5_start].VarStr, &Start))
ReportError(StrEnv[MM5_start].KeyName, 51);
InitTime(Time, NULL, NULL, NULL, &Start, Time->Dt);
if (IsEmptyStr(StrEnv[MM5_temperature].VarStr))
ReportError(StrEnv[MM5_temperature].KeyName, 51);
strcpy(InFiles->MM5Temp, StrEnv[MM5_temperature].VarStr);
if (IsEmptyStr(StrEnv[MM5_terrain].VarStr))
ReportError(StrEnv[MM5_terrain].KeyName, 51);
strcpy(InFiles->MM5Terrain, StrEnv[MM5_terrain].VarStr);
if (IsEmptyStr(StrEnv[MM5_lapse].VarStr))
ReportError(StrEnv[MM5_lapse].KeyName, 51);
strcpy(InFiles->MM5Lapse, StrEnv[MM5_lapse].VarStr);
if (IsEmptyStr(StrEnv[MM5_humidity].VarStr))
ReportError(StrEnv[MM5_humidity].KeyName, 51);
strcpy(InFiles->MM5Humidity, StrEnv[MM5_humidity].VarStr);
if (IsEmptyStr(StrEnv[MM5_wind].VarStr))
ReportError(StrEnv[MM5_wind].KeyName, 51);
strcpy(InFiles->MM5Wind, StrEnv[MM5_wind].VarStr);
if (IsEmptyStr(StrEnv[MM5_shortwave].VarStr))
ReportError(StrEnv[MM5_shortwave].KeyName, 51);
strcpy(InFiles->MM5ShortWave, StrEnv[MM5_shortwave].VarStr);
if (IsEmptyStr(StrEnv[MM5_longwave].VarStr))
ReportError(StrEnv[MM5_longwave].KeyName, 51);
strcpy(InFiles->MM5LongWave, StrEnv[MM5_longwave].VarStr);
if (IsEmptyStr(StrEnv[MM5_precip].VarStr))
ReportError(StrEnv[MM5_precip].KeyName, 51);
strcpy(InFiles->MM5Precipitation, StrEnv[MM5_precip].VarStr);
if (Options->HeatFlux == TRUE) {
if (!(InFiles->MM5SoilTemp = (char **)calloc(sizeof(char *), NSoilLayers)))
ReportError(Routine, 1);
for (i = 0; i < NSoilLayers; i++) {
if (!(InFiles->MM5SoilTemp[i] =
(char *)calloc(sizeof(char), BUFSIZE + 1)))
ReportError(Routine, 1);
sprintf(KeyName, "MM5 SOIL TEMPERATURE FILE %d", i);
GetInitString("METEOROLOGY", KeyName, "", VarStr,
(unsigned long)BUFSIZE, Input);
if (IsEmptyStr(VarStr))
ReportError(KeyName, 51);
strcpy(InFiles->MM5SoilTemp[i], VarStr);
}
}
if (!CopyDouble(&(MM5Map->Yorig), StrEnv[MM5_ext_north].VarStr, 1))
ReportError(StrEnv[MM5_ext_north].KeyName, 51);
if (!CopyDouble(&(MM5Map->Xorig), StrEnv[MM5_ext_west].VarStr, 1))
ReportError(StrEnv[MM5_ext_west].KeyName, 51);
if (!CopyInt(&(MM5Map->NY), StrEnv[MM5_rows].VarStr, 1))
ReportError(StrEnv[MM5_rows].KeyName, 51);
if (!CopyInt(&(MM5Map->NX), StrEnv[MM5_cols].VarStr, 1))
ReportError(StrEnv[MM5_cols].KeyName, 51);
if (!CopyFloat(&(MM5Map->DY), StrEnv[MM5_dy].VarStr, 1))
ReportError(StrEnv[MM5_dy].KeyName, 51);
MM5Map->OffsetX = Round(((float)(MM5Map->Xorig - Map->Xorig)) /
((float)Map->DX));
MM5Map->OffsetY = Round(((float)(MM5Map->Yorig - Map->Yorig)) /
((float)Map->DY));
if (MM5Map->OffsetX > 0 || MM5Map->OffsetY < 0)
ReportError("Input Options File", 31);
printf("MM5 extreme north / south is %f %f \n", MM5Map->Yorig,
MM5Map->Yorig - MM5Map->NY * MM5Map->DY);
printf("MM5 extreme west / east is %f %f\n", MM5Map->Xorig,
MM5Map->Xorig + MM5Map->NX * MM5Map->DY);
printf("MM5 rows is %d \n", MM5Map->NY);
printf("MM5 cols is %d \n", MM5Map->NX);
printf("MM5 dy is %f \n", MM5Map->DY);
printf("Temperature Map is %s\n", InFiles->MM5Temp);
printf("Precip Map is %s\n", InFiles->MM5Precipitation);
printf("wind Map is %s\n", InFiles->MM5Wind);
printf("shortwave Map is %s\n", InFiles->MM5ShortWave);
printf("humidity Map is %s\n", InFiles->MM5Humidity);
printf("lapse Map is %s\n", InFiles->MM5Lapse);
printf("terrain Map is %s\n", InFiles->MM5Terrain);
printf("MM5 offset x is %d \n", MM5Map->OffsetX);
printf("MM5 offset y is %d \n", MM5Map->OffsetY);
printf("dhsvm extreme north / south is %f %f \n", Map->Yorig,
Map->Yorig - Map->NY * Map->DY);
printf("dhsvm extreme west / east is %f %f \n", Map->Xorig,
Map->Xorig + Map->NX * Map->DY);
printf("fail if %d > %d\n",
(int)((Map->NY + MM5Map->OffsetY) * Map->DY / MM5Map->DY),
MM5Map->NY);
printf("fail if %d > %d\n",
(int)((Map->NX - MM5Map->OffsetX) * Map->DX / MM5Map->DY),
MM5Map->NX);
if ((int)((Map->NY + MM5Map->OffsetY) * Map->DY / MM5Map->DY) > MM5Map->NY
|| (int)((Map->NX - MM5Map->OffsetX) * Map->DX / MM5Map->DY) >
MM5Map->NX)
ReportError("Input Options File", 31);
}
/*****************************************************************************
Function name: InitConstants()
Purpose : Initialize constants and settings for DHSVM run
Processes the following sections in InFile:
[OPTIONS]
[AREA]
[TIME]
[CONSTANTS}
Required :
LISTPTR Input - Linked list with input strings
OPTIONSTRUCT *Options - Structure with different program options
MAPSIZE *Map - Coverage and resolution of model area
SOLARGEOMETRY *SolarGeo - Solar geometry information
TIMESTRUCT *Time - Begin and end times, model timestep
Returns : void
Modifies : (see list of required above)
Comments : Make sure order in settings.h matches list of keys here
Some modifications for input of monthly atmospheric parameters for
soil chemistry model, MWW -sc 10/2005
*****************************************************************************/
void InitConstants(LISTPTR Input, OPTIONSTRUCT * Options, MAPSIZE * Map,
SOLARGEOMETRY * SolarGeo, TIMESTRUCT * Time, BASINWIDE * Basinwide)
{
// const char *Routine = "InitConstants";
int i, j; /* counter */
double PointModelX; /* X-coordinate for POINT model mode */
double PointModelY; /* Y-coordinate for POINT model mode */
float TimeStep; /* Timestep in hours */
DATE End; /* End of run */
DATE Start; /* Start of run */
STRINIENTRY StrEnv[] = {
{"OPTIONS", "INPUTFILEVERSION", "", ""},
{"OPTIONS", "FORMAT", "", ""},
{"OPTIONS", "EXTENT", "", ""},
{"OPTIONS", "GRADIENT", "", ""},
{"OPTIONS", "FLOW ROUTING", "", ""},
{"OPTIONS", "SENSIBLE HEAT FLUX", "", ""},
{"OPTIONS", "STREAM TEMPERATURE", "", ""},
{"OPTIONS", "GROUNDWATER", "" , ""},
{"OPTIONS", "CHEMISTRY", "" , ""},
{"OPTIONS", "GLACIER MOVEMENT", "" , ""},
{"OPTIONS", "CHANNEL INFILTRATION", "" , ""},
{"OPTIONS", "FRACTIONAL ROUTING", "" , ""},
{"OPTIONS", "INTERPOLATION", "", ""},
{"OPTIONS", "MM5", "", ""},
{"OPTIONS", "QPF", "", ""},
{"OPTIONS", "PRISM", "", ""},
{"OPTIONS", "CANOPY RADIATION ATTENUATION MODE", "", ""},
{"OPTIONS", "SHADING", "", ""},
{"OPTIONS", "SNOTEL", "", ""},
{"OPTIONS", "OUTSIDE", "", ""},
{"OPTIONS", "RHOVERRIDE", "", ""},
{"OPTIONS", "PRECIPITATION SOURCE", "", ""},
{"OPTIONS", "WIND SOURCE", "", ""},
{"OPTIONS", "TEMPERATURE LAPSE RATE", "", ""},
{"OPTIONS", "PRECIPITATION LAPSE RATE", "", ""},
{"OPTIONS", "CRESSMAN RADIUS", "", ""},
{"OPTIONS", "CRESSMAN STATIONS", "", ""},
{"OPTIONS", "PRISM DATA PATH", "", ""},
{"OPTIONS", "PRISM DATA EXTENSION", "", ""},
{"OPTIONS", "SHADING DATA PATH", "", ""},
{"OPTIONS", "SHADING DATA EXTENSION", "", ""},
{"OPTIONS", "SKYVIEW DATA PATH", "", ""},
{"OPTIONS", "INITIAL STATE PATH", "", ""},
{"AREA", "COORDINATE SYSTEM", "", ""},
{"AREA", "EXTREME NORTH", "", ""},
{"AREA", "EXTREME WEST", "", ""},
{"AREA", "CENTER LATITUDE", "", ""},
{"AREA", "CENTER LONGITUDE", "", ""},
{"AREA", "TIME ZONE MERIDIAN", "", ""},
{"AREA", "NUMBER OF ROWS", "", ""},
{"AREA", "NUMBER OF COLUMNS", "", ""},
{"AREA", "GRID SPACING", "", ""},
{"AREA", "POINT NORTH", "", ""},
{"AREA", "POINT EAST", "", ""},
{"TIME", "TIME STEP", "", ""},
{"TIME", "MODEL START", "", ""},
{"TIME", "MODEL END", "", ""},
{"CONSTANTS", "GROUND ROUGHNESS", "", ""},
{"CONSTANTS", "SNOW ROUGHNESS", "", ""},
{"CONSTANTS", "RAIN THRESHOLD", "", ""},
{"CONSTANTS", "SNOW THRESHOLD", "", ""},
{"CONSTANTS", "SNOW WATER CAPACITY", "", ""},
{"CONSTANTS", "REFERENCE HEIGHT", "", ""},
{"CONSTANTS", "RAIN LAI MULTIPLIER", "", ""},
{"CONSTANTS", "SNOW LAI MULTIPLIER", "", ""},
{"CONSTANTS", "MIN INTERCEPTED SNOW", "", ""},
{"CONSTANTS", "OUTSIDE BASIN VALUE", "", ""},
{"CONSTANTS", "GLACIER CREEP ACTIVATION ENERGY", "", ""},
{"CONSTANTS", "GLEN CONSTANT", "", ""},
{"CONSTANTS", "MAXIMUM GLACIER FLUX FRACTION", "", ""},
{"CONSTANTS", "TEMPERATURE LAPSE RATE", "", ""},
{"CONSTANTS", "PRECIPITATION LAPSE RATE", "", ""},
{"CONSTANTS", "DEPTH RATIO", "", ""},
{"CONSTANTS", "WIND ATTENUATION FACTOR", "", ""},
{"CONSTANTS", "RAD ATTENUATION FACTOR", "", ""},
{"CONSTANTS", "MINIMUM SEGMENT ORDER", "", ""},
{"CHEMISTRY", "METABOLIC DOC DECOMPOSITION RATE", "", ""},
{"CHEMISTRY", "STRUCTURAL DOC DECOMPOSITION RATE", "", ""},
{"CHEMISTRY", "DECOMPOSITION RATE CONSTANT OF DOC", "", ""},
{"CHEMISTRY", "MAXIMUM DOC SORPTION COEFFICIENT", "", ""},
{"CHEMISTRY", "C:N FOR SORBED DOM", "", ""},
{"CHEMISTRY", "C:N FOR MICROBIAL DECOMP OF DOM", "", ""},
{"CHEMISTRY", "BACKGROUND CATIONS", "", ""},
{"CHEMISTRY", "NITRIFICATION TEMPERATURE FACTOR", "", ""},
{"CHEMISTRY", "FREE AIR CO2 DIFFUSION COEFFICIENT", "", ""},
{"CHEMISTRY", "FREE AIR O2 DIFFUSION COEFFICIENT", "", ""},
{"CHEMISTRY", "MASS TRANSFER COEFFICIENT OF DISSOLVED CO2", "", ""},
{"CHEMISTRY", "MASS TRANSFER COEFFICIENT OF DISSOLVED O2", "", ""},
{"CHEMISTRY", "DENITRIFICATION SATURATION THRESHOLD", "", ""},
{"CHEMISTRY", "NITRATE REDUCTION HALF SATURATION FRACTION", "", ""},
{"CHEMISTRY", "OXYGEN CONCENTRATION REACTION COEFFICIENT", "", ""},
{"CHEMISTRY", "SUSPENDED DOC MINERALIZATION CONSTANT", "", ""},
{"CHEMISTRY", "SUSPENDED DON HYDROLYSIS RATE", "", ""},
{"CHEMISTRY", "SUSPENDED AMMONIUM DECOMPOSITION RATE", "", ""},
{"CHEMISTRY", "SUSPENDED NITRIFICATION RATE", "", ""},
{"CHEMISTRY", "ATMOSPHERIC CO2 CONCENTRATION", "", ""},
{"CHEMISTRY", "ATMOSPHERIC DOC CONCENTRATION", "", ""},
{"CHEMISTRY", "ATMOSPHERIC DON CONCENTRATION", "", ""},
{"CHEMISTRY", "ATMOSPHERIC NH4 CONCENTRATION", "", ""},
{"CHEMISTRY", "ATMOSPHERIC NO3 CONCENTRATION", "", ""},
{"CHEMISTRY", "ATMOSPHERIC NO2 CONCENTRATION", "", ""},
{NULL, NULL, "", NULL}
};
/* Read the key-entry pairs from the input file */
for (i = 0; StrEnv[i].SectionName; i++)
GetInitString(StrEnv[i].SectionName, StrEnv[i].KeyName, StrEnv[i].Default,
StrEnv[i].VarStr, (unsigned long) BUFSIZE, Input);
/**************** Determine model options ****************/
/* Determine file format to be used */
if (strncmp(StrEnv[inputfileversion].VarStr, "045", 3) != 0)
{
printf("\n\n****************************************\nERROR LOADING INPUT FILE, WRONG VERSION\n");
printf("Please make sure that the inputfileversion field in the [OPTIONS] section of the config file matches the INPUT_FILE_VERSION constant set in settings.h\n");
printf("\nExpected INPUT_FILE_VERSION=");
printf(INPUT_FILE_VERSION);
printf("\tValue in Input file=%s",StrEnv[inputfileversion].VarStr);
ReportError(StrEnv[inputfileversion].KeyName,51);
}
if (strncmp(StrEnv[format].VarStr, "BIN", 3) == 0)
Options->FileFormat = BIN;
else if (strncmp(StrEnv[format].VarStr, "NETCDF", 3) == 0)
Options->FileFormat = NETCDF;
else if (strncmp(StrEnv[format].VarStr, "BYTESWAP", 3) == 0)
Options->FileFormat = BYTESWAP;
else
ReportError(StrEnv[format].KeyName, 51);
/* Determine whether the model should be run in POINT mode or in BASIN mode.
If in POINT mode also read which pixel to model */
if (strncmp(StrEnv[extent].VarStr, "POINT", 5) == 0) {
Options->Extent = POINT;
Options->HasNetwork = FALSE;
}
else if (strncmp(StrEnv[extent].VarStr, "BASIN", 5) == 0) {
Options->Extent = BASIN;
}
else
ReportError(StrEnv[extent].KeyName, 51);
/* Determine how the flow gradient should be calculated */
if (Options->Extent != POINT) {
if (strncmp(StrEnv[gradient].VarStr, "TOPO", 4) == 0)
Options->FlowGradient = TOPOGRAPHY;
else if (strncmp(StrEnv[gradient].VarStr, "WATER", 5) == 0)
Options->FlowGradient = WATERTABLE;
else
ReportError(StrEnv[gradient].KeyName, 51);
}
else
Options->FlowGradient = NOT_APPLICABLE;
/* Determine what meterological interpolation to use */
if (strncmp(StrEnv[interpolation].VarStr, "INVDIST", 7) == 0)
Options->Interpolation = INVDIST;
else if (strncmp(StrEnv[interpolation].VarStr, "NEAREST", 7) == 0)
Options->Interpolation = NEAREST;
else if (strncmp(StrEnv[interpolation].VarStr, "VARCRESS", 8) == 0)
Options->Interpolation = VARCRESS;
else
ReportError(StrEnv[interpolation].KeyName, 51);
/* if VARIABLE CRESTMAN interpolation then get parameters */
if (Options->Interpolation == VARCRESS) {
if (!CopyInt(&(Options->CressRadius), StrEnv[cressman_radius].VarStr, 1))
ReportError(StrEnv[cressman_radius].KeyName, 51);
if (!CopyInt
(&(Options->CressStations), StrEnv[cressman_stations].VarStr, 1))
ReportError(StrEnv[cressman_stations].KeyName, 51);
}
/* Determine whether a road/network is imposed on the model area */
if (Options->Extent != POINT) {
if (strncmp(StrEnv[flow_routing].VarStr, "NETWORK", 7) == 0)
Options->HasNetwork = TRUE;
else if (strncmp(StrEnv[flow_routing].VarStr, "UNIT", 4) == 0)
Options->HasNetwork = FALSE;
else
ReportError(StrEnv[flow_routing].KeyName, 51);
}
else
Options->HasNetwork = FALSE;
/* Determine whether a sensible heat flux should be calculated */
if (strncmp(StrEnv[sensible_heat_flux].VarStr, "TRUE", 4) == 0)
Options->HeatFlux = TRUE;
else if (strncmp(StrEnv[sensible_heat_flux].VarStr, "FALSE", 5) == 0)
Options->HeatFlux = FALSE;
else
ReportError(StrEnv[sensible_heat_flux].KeyName, 51);
/* Determine whether or not calculate Stream Temperature MWW 08112004 */
if (strncmp(StrEnv[stream_temperature].VarStr, "TRUE", 4) == 0)
Options->StreamTemp = TRUE;
else if (strncmp(StrEnv[stream_temperature].VarStr, "FALSE", 5) == 0)
Options->StreamTemp = FALSE;
else
ReportError(StrEnv[stream_temperature].KeyName, 51);
/* determine if deeper groundwater is represented */
if (strncmp(StrEnv[groundwater].VarStr, "TRUE", 4) == 0)
Options->Groundwater = TRUE;
else if (strncmp(StrEnv[groundwater].VarStr, "FALSE", 5) == 0)
Options->Groundwater = FALSE;
else
ReportError(StrEnv[groundwater].KeyName, 51);
/* determine if soil chemistry is incorporated */
if (strncmp(StrEnv[chemistry].VarStr, "TRUE", 4) == 0)
Options->Chemistry = TRUE;
else if (strncmp(StrEnv[chemistry].VarStr, "FALSE", 5) == 0)
Options->Chemistry = FALSE;
else
ReportError(StrEnv[chemistry].KeyName, 51);
/* ALLOW GLACIERS TO MOVE ? */
if (strncmp(StrEnv[glacier_movement].VarStr, "TRUE", 4) == 0)
Options->GlacierMove = TRUE;
else if (strncmp(StrEnv[glacier_movement].VarStr, "FALSE", 5) == 0)
Options->GlacierMove = FALSE;
else
ReportError(StrEnv[glacier_movement].KeyName, 51);
/* determine if Channel Infiltration is allowed */
if (strncmp(StrEnv[channel_infiltration].VarStr, "TRUE", 4) == 0)
Options->ChannelInfiltration = TRUE;
else if (strncmp(StrEnv[channel_infiltration].VarStr, "FALSE", 5) == 0)
Options->ChannelInfiltration = FALSE;
else
ReportError(StrEnv[channel_infiltration].KeyName, 51);
/* determine if Fractional Routing is allowed */
if (strncmp(StrEnv[fractional_routing].VarStr, "TRUE", 4) == 0)
Options->FractionalRouting = TRUE;
else if (strncmp(StrEnv[fractional_routing].VarStr, "FALSE", 5) == 0)
Options->FractionalRouting = FALSE;
else
ReportError(StrEnv[fractional_routing].KeyName, 51);
/* Determine whether the mm5 interface should be used */
if (strncmp(StrEnv[mm5].VarStr, "TRUE", 4) == 0)
Options->MM5 = TRUE;
else if (strncmp(StrEnv[mm5].VarStr, "FALSE", 5) == 0)
Options->MM5 = FALSE;
else
ReportError(StrEnv[mm5].KeyName, 51);
/* Determine whether the QPF override should be used on the MM5 fields */
if (strncmp(StrEnv[qpf].VarStr, "TRUE", 4) == 0)
Options->QPF = TRUE;
else if (strncmp(StrEnv[qpf].VarStr, "FALSE", 5) == 0)
Options->QPF = FALSE;
else
ReportError(StrEnv[qpf].KeyName, 51);
/* Determine if PRISM maps will be used to interpolate precip fields */
if (strncmp(StrEnv[prism].VarStr, "TRUE", 4) == 0)
Options->Prism = TRUE;
else if (strncmp(StrEnv[prism].VarStr, "FALSE", 5) == 0)
Options->Prism = FALSE;
else
ReportError(StrEnv[prism].KeyName, 51);
/* Determine the kinf of canopy radiation attenuation to be used */
if (strncmp(StrEnv[canopy_radatt].VarStr, "FIXED", 3) == 0)
Options->CanopyRadAtt = FIXED;
else if (strncmp(StrEnv[canopy_radatt].VarStr, "VARIABLE", 3) == 0)
Options->CanopyRadAtt = VARIABLE;
else
ReportError(StrEnv[canopy_radatt].KeyName, 51);
/* Determine if solar shading maps will be used */
if (strncmp(StrEnv[shading].VarStr, "TRUE", 4) == 0)
Options->Shading = TRUE;
else if (strncmp(StrEnv[shading].VarStr, "FALSE", 5) == 0)
Options->Shading = FALSE;
else
ReportError(StrEnv[shading].KeyName, 51);
if (Options->MM5 == TRUE && Options->Prism == TRUE && Options->QPF == FALSE)
ReportError(StrEnv[prism].KeyName, 51);
/* Determine if Snotel test is called for */
if (strncmp(StrEnv[snotel].VarStr, "TRUE", 4) == 0)
Options->Snotel = TRUE;
else if (strncmp(StrEnv[snotel].VarStr, "FALSE", 5) == 0)
Options->Snotel = FALSE;
else
ReportError(StrEnv[snotel].KeyName, 51);
/* Determine if listed met stations outside bounding box are used */
if (strncmp(StrEnv[outside].VarStr, "TRUE", 4) == 0)
Options->Outside = TRUE;
else if (strncmp(StrEnv[outside].VarStr, "FALSE", 5) == 0)
Options->Outside = FALSE;
else
ReportError(StrEnv[outside].KeyName, 51);
if (Options->Prism == TRUE) {
if (IsEmptyStr(StrEnv[prism_data_path].VarStr))
ReportError(StrEnv[prism_data_path].KeyName, 51);
strcpy(Options->PrismDataPath, StrEnv[prism_data_path].VarStr);
if (IsEmptyStr(StrEnv[prism_data_ext].VarStr))
ReportError(StrEnv[prism_data_ext].KeyName, 51);
strcpy(Options->PrismDataExt, StrEnv[prism_data_ext].VarStr);
}
if (Options->Shading == TRUE) {
if (IsEmptyStr(StrEnv[shading_data_path].VarStr))
ReportError(StrEnv[shading_data_path].KeyName, 51);
strcpy(Options->ShadingDataPath, StrEnv[shading_data_path].VarStr);
if (IsEmptyStr(StrEnv[shading_data_ext].VarStr))
ReportError(StrEnv[shading_data_ext].KeyName, 51);
strcpy(Options->ShadingDataExt, StrEnv[shading_data_ext].VarStr);
if (IsEmptyStr(StrEnv[skyview_data_path].VarStr))
ReportError(StrEnv[skyview_data_path].KeyName, 51);
strcpy(Options->SkyViewDataPath, StrEnv[skyview_data_path].VarStr);
}
/* path to inital state files */
if (IsEmptyStr(StrEnv[initial_state_path].VarStr))
ReportError(StrEnv[initial_state_path].KeyName, 51);
strcpy(Options->StartStatePath, StrEnv[initial_state_path].VarStr);
/* Determine if rh override is used */
if (strncmp(StrEnv[rhoverride].VarStr, "TRUE", 4) == 0)
Options->Rhoverride = TRUE;
else if (strncmp(StrEnv[rhoverride].VarStr, "FALSE", 5) == 0)
Options->Rhoverride = FALSE;
else
ReportError(StrEnv[rhoverride].KeyName, 51);
/* The other met options are only of importance if MM5 is FALSE */
if (Options->MM5 == TRUE) {
Options->PrecipType = NOT_APPLICABLE;
Options->WindSource = NOT_APPLICABLE;
Options->PrecipLapse = NOT_APPLICABLE;
Options->TempLapse = NOT_APPLICABLE;
if (Options->QPF == TRUE)
Options->PrecipType = STATION;
if (Options->QPF == TRUE && Options->Prism == FALSE)
Options->PrecipLapse = CONSTANT;
}
else {
/* Determine the type of precipitation data that the model will use */
if (strncmp(StrEnv[precipitation_source].VarStr, "RADAR", 5) == 0)
Options->PrecipType = RADAR;
else if (strncmp(StrEnv[precipitation_source].VarStr, "STATION", 7) == 0)
Options->PrecipType = STATION;
else
ReportError(StrEnv[precipitation_source].KeyName, 51);
/* Determine the type of wind data that the model will use */
if (strncmp(StrEnv[wind_source].VarStr, "MODEL", 5) == 0)
Options->WindSource = MODEL;
else if (strncmp(StrEnv[wind_source].VarStr, "STATION", 7) == 0)
Options->WindSource = STATION;
else
ReportError(StrEnv[wind_source].KeyName, 51);
/* Determine the type of temperature lapse rate */
if (strncmp(StrEnv[temp_lapse].VarStr, "CONSTANT", 8) == 0) {
Options->TempLapse = CONSTANT;
} else if (strncmp(StrEnv[temp_lapse].VarStr, "VARIABLE", 8) == 0) {
Options->TempLapse = VARIABLE;
} else if (strncmp(StrEnv[temp_lapse].VarStr, "MONTHLY", 7) == 0) {
Options->TempLapse = MONTHLY;
} else {
ReportError(StrEnv[temp_lapse].KeyName, 51);
}
/* Determine the type of precipitation lapse rate */
if (strncmp(StrEnv[precip_lapse].VarStr, "CONSTANT", 8) == 0)
Options->PrecipLapse = CONSTANT;
else if (strncmp(StrEnv[precip_lapse].VarStr, "MAP", 3) == 0)
Options->PrecipLapse = MAP;
else if (strncmp(StrEnv[precip_lapse].VarStr, "VARIABLE", 8) == 0)
Options->PrecipLapse = VARIABLE;
else if (strncmp(StrEnv[precip_lapse].VarStr, "MONTHLY", 7) == 0)
Options->PrecipLapse = MONTHLY;
else
ReportError(StrEnv[precip_lapse].KeyName, 51);
}
/**************** Determine areal extent ****************/
if (IsEmptyStr(StrEnv[coordinate_system].VarStr))
ReportError(StrEnv[coordinate_system].KeyName, 51);
strcpy(Map->System, StrEnv[coordinate_system].VarStr);
if (!CopyDouble(&(Map->Yorig), StrEnv[extreme_north].VarStr, 1))
ReportError(StrEnv[extreme_north].KeyName, 51);
if (!CopyDouble(&(Map->Xorig), StrEnv[extreme_west].VarStr, 1))
ReportError(StrEnv[extreme_west].KeyName, 51);
if (!CopyFloat(&(SolarGeo->Latitude), StrEnv[center_latitude].VarStr, 1))
ReportError(StrEnv[center_latitude].KeyName, 51);
SolarGeo->Latitude *= (float) RADPDEG;
if (!CopyFloat(&(SolarGeo->Longitude), StrEnv[center_longitude].VarStr, 1))
ReportError(StrEnv[center_longitude].KeyName, 51);
SolarGeo->Longitude *= (float) RADPDEG;
if (!CopyFloat(&(SolarGeo->StandardMeridian),
StrEnv[time_zone_meridian].VarStr, 1))
ReportError(StrEnv[time_zone_meridian].KeyName, 51);
SolarGeo->StandardMeridian *= (float) RADPDEG;
if (!CopyInt(&(Map->NY), StrEnv[number_of_rows].VarStr, 1))
ReportError(StrEnv[number_of_rows].KeyName, 51);
if (!CopyInt(&(Map->NX), StrEnv[number_of_columns].VarStr, 1))
ReportError(StrEnv[number_of_columns].KeyName, 51);
if (!CopyFloat(&(Map->DY), StrEnv[grid_spacing].VarStr, 1))
ReportError(StrEnv[grid_spacing].KeyName, 51);
Map->DX = Map->DY;
Map->DXY = (float) sqrt(Map->DX * Map->DX + Map->DY * Map->DY);
Map->X = 0;
Map->Y = 0;
Map->OffsetX = 0;
Map->OffsetY = 0;
#if NDIRS == 4
Map->xneighbor[0] = 0;
Map->yneighbor[0] = -1; /* N (0 rads) */
Map->xneighbor[1] = 1;
Map->yneighbor[1] = 0; /* E (PI/2 rads)*/
Map->xneighbor[2] = 0;
Map->yneighbor[2] = 1; /* S (PI rads)*/
Map->xneighbor[3] = -1;
Map->yneighbor[3] = 0; /* W (3PI/2 rads or -PI/2 rads)*/
#elif NDIRS == 8
Map->xneighbor[0] = 0; /*--------------------------*/
Map->yneighbor[0] = -1; /* N */
Map->xneighbor[1] = 1;
Map->yneighbor[1] = -1; /* NE */
Map->xneighbor[2] = 1;
Map->yneighbor[2] = 0; /* E */
Map->xneighbor[3] = 1;
Map->yneighbor[3] = 1; /* SE */
Map->xneighbor[4] = 0;
Map->yneighbor[4] = 1; /* S */
Map->xneighbor[5] = -1;
Map->yneighbor[5] = 1; /* SW */
Map->xneighbor[6] = -1;
Map->yneighbor[6] = 0; /* W */
Map->xneighbor[7] = -1;
Map->yneighbor[7] = -1; /* NW */
#endif
if (Options->Extent == POINT) {
if (!CopyDouble(&PointModelY, StrEnv[point_north].VarStr, 1))
ReportError(StrEnv[point_north].KeyName, 51);
if (!CopyDouble(&PointModelX, StrEnv[point_east].VarStr, 1))
ReportError(StrEnv[point_east].KeyName, 51);
Options->PointY =
Round(((Map->Yorig - 0.5 * Map->DY) - PointModelY) / Map->DY);
Options->PointX =
Round((PointModelX - (Map->Xorig + 0.5 * Map->DX)) / Map->DX);
}
else {
Options->PointY = 0;
Options->PointX = 0;
}
/**************** Determine model period ****************/
if (!CopyFloat(&(TimeStep), StrEnv[time_step].VarStr, 1))
ReportError(StrEnv[time_step].KeyName, 51);
TimeStep *= SECPHOUR;
if (!SScanDate(StrEnv[model_start].VarStr, &(Start)))
ReportError(StrEnv[model_start].KeyName, 51);
if (!SScanDate(StrEnv[model_end].VarStr, &(End)))
ReportError(StrEnv[model_end].KeyName, 51);
InitTime(Time, &Start, &End, NULL, NULL, (int) TimeStep);
/**************** Determine model constants ****************/
if (!CopyFloat(&Z0_GROUND, StrEnv[ground_roughness].VarStr, 1))
ReportError(StrEnv[ground_roughness].KeyName, 51);
if (!CopyFloat(&Z0_SNOW, StrEnv[snow_roughness].VarStr, 1))
ReportError(StrEnv[snow_roughness].KeyName, 51);
if (!CopyFloat(&MIN_RAIN_TEMP, StrEnv[rain_threshold].VarStr, 1))
ReportError(StrEnv[rain_threshold].KeyName, 51);
if (!CopyFloat(&MAX_SNOW_TEMP, StrEnv[snow_threshold].VarStr, 1))
ReportError(StrEnv[snow_threshold].KeyName, 51);
if (!CopyFloat(&LIQUID_WATER_CAPACITY, StrEnv[snow_water_capacity].VarStr, 1))
ReportError(StrEnv[snow_water_capacity].KeyName, 51);
if (!CopyFloat(&Zref, StrEnv[reference_height].VarStr, 1))
ReportError(StrEnv[reference_height].KeyName, 51);
if (!CopyFloat(&LAI_WATER_MULTIPLIER, StrEnv[rain_lai_multiplier].VarStr, 1))
ReportError(StrEnv[rain_lai_multiplier].KeyName, 51);
if (!CopyFloat(&LAI_SNOW_MULTIPLIER, StrEnv[snow_lai_multiplier].VarStr, 1))
ReportError(StrEnv[snow_lai_multiplier].KeyName, 51);
if (!CopyFloat(&MIN_INTERCEPTION_STORAGE,
StrEnv[min_intercepted_snow].VarStr, 1))
ReportError(StrEnv[min_intercepted_snow].KeyName, 51);
if (!CopyUChar(&OUTSIDEBASIN, StrEnv[outside_basin].VarStr, 1))
ReportError(StrEnv[outside_basin].KeyName, 51);
/* Glacier model terms MWW-glacier */
if(Options->GlacierMove == TRUE ) {
if (!CopyFloat(&GLACIER_Q, StrEnv[glacier_creep_q].VarStr, 1))
ReportError(StrEnv[glacier_creep_q].KeyName, 51);
if (!CopyFloat(&GLACIER_N, StrEnv[glacier_creep_n].VarStr, 1))
ReportError(StrEnv[glacier_creep_n].KeyName, 51);
if (!CopyFloat(&MAX_GLACIER_FLUX, StrEnv[max_glacier_flux].VarStr, 1))
ReportError(StrEnv[max_glacier_flux].KeyName, 51);
}
if (Options->TempLapse == CONSTANT) {
if (!CopyFloat(&TEMPLAPSE, StrEnv[temp_lapse_rate].VarStr, 1))
ReportError(StrEnv[temp_lapse_rate].KeyName, 51);
}
else if (Options->TempLapse == MONTHLY) {
if (!CopyFloat( Basinwide->TempLapse, StrEnv[temp_lapse_rate].VarStr, 12))
ReportError(StrEnv[temp_lapse_rate].KeyName, 51);
}
else
TEMPLAPSE = NOT_APPLICABLE;
if (Options->PrecipLapse == CONSTANT) {
if (!CopyFloat(&PRECIPLAPSE, StrEnv[precip_lapse_rate].VarStr, 1))
ReportError(StrEnv[precip_lapse_rate].KeyName, 51);
}
else if (Options->PrecipLapse == MONTHLY) {
if (!CopyFloat( Basinwide->PrcpLapse, StrEnv[precip_lapse_rate].VarStr, 12))
ReportError(StrEnv[precip_lapse_rate].KeyName, 51);
}
else
PRECIPLAPSE = NOT_APPLICABLE;
if (Options->StreamTemp == TRUE) {
if (!CopyFloat(&DEPTHRATIO, StrEnv[depthratio].VarStr, 1))
ReportError(StrEnv[depthratio].KeyName, 51);
if (!CopyFloat(&ST_WIND_FAC, StrEnv[st_wind_fac].VarStr, 1))
ReportError(StrEnv[st_wind_fac].KeyName, 51);
if (!CopyFloat(&ST_RAD_FAC, StrEnv[st_rad_fac].VarStr, 1))
ReportError(StrEnv[st_rad_fac].KeyName, 51);
if (!CopyInt(&MIN_SEG_ORDER, StrEnv[min_seg_order].VarStr, 1))
ReportError(StrEnv[min_seg_order].KeyName, 51);
}
else {
DEPTHRATIO = 1.0;
ST_WIND_FAC = 1.0;
ST_RAD_FAC = 1.0;
MIN_SEG_ORDER = NOT_APPLICABLE;
}
/* This section added for Soil Chemistry functions, MWW -sc */
if (Options->Chemistry == TRUE) {
if (!CopyFloat(&META_DOC_K_DECOMP, StrEnv[meta_doc_decomp_rate].VarStr, 1))
ReportError(StrEnv[meta_doc_decomp_rate].KeyName, 51);
if (!CopyFloat(&STRUCT_DOC_K_DECOMP, StrEnv[struct_doc_decomp_rate].VarStr, 1))
ReportError(StrEnv[struct_doc_decomp_rate].KeyName, 51);
if (!CopyFloat(&K_DECOMPOSE_DOC, StrEnv[k_decompose_doc].VarStr, 1))
ReportError(StrEnv[k_decompose_doc].KeyName, 51);
if (!CopyFloat(&K1_SORPTION_MAX, StrEnv[k1_sorption_max].VarStr, 1))
ReportError(StrEnv[k1_sorption_max].KeyName, 51);
if (!CopyFloat(&CN_SORB_DOM, StrEnv[cn_sorb_dom].VarStr, 1))
ReportError(StrEnv[cn_sorb_dom].KeyName, 51);
if (!CopyFloat(&CN_MICRODECOMP_DOM, StrEnv[cn_microdecomp_dom].VarStr, 1))
ReportError(StrEnv[cn_microdecomp_dom].KeyName, 51);
if (!CopyFloat(&BG_CATIONS, StrEnv[bg_cations].VarStr, 1))
ReportError(StrEnv[bg_cations].KeyName, 51);
if (!CopyFloat(&NITRI_TEMP_FAC, StrEnv[nitri_temp_fac].VarStr, 1))
ReportError(StrEnv[nitri_temp_fac].KeyName, 51);
if (!CopyFloat(&FREEAIRDCO2, StrEnv[freeair_co2].VarStr, 1))
ReportError(StrEnv[freeair_co2].KeyName, 51);
if (!CopyFloat(&FREEAIROXY, StrEnv[freeair_co2].VarStr, 1))
ReportError(StrEnv[freeair_oxy].KeyName, 51);
if (!CopyFloat(&CO2KGASTRANS, StrEnv[co2_kgas].VarStr, 1))
ReportError(StrEnv[co2_kgas].KeyName, 51);
if (!CopyFloat(&O2KGASTRANS, StrEnv[o2_kgas].VarStr, 1))
ReportError(StrEnv[o2_kgas].KeyName, 51);
if (!CopyFloat(&POTENTIALDENITRIF, StrEnv[pot_denitrif].VarStr, 1))
ReportError(StrEnv[pot_denitrif].KeyName, 51);
if (!CopyFloat(&DENITRIF_HALFSAT, StrEnv[denitrif_halfsat].VarStr, 1))
ReportError(StrEnv[denitrif_halfsat].KeyName, 51);
if (!CopyFloat(&KOXY_NITRIF, StrEnv[koxy_nitrif].VarStr, 1))
ReportError(StrEnv[koxy_nitrif].KeyName, 51);
if (!CopyFloat(&KMINER_CHAN, StrEnv[kminer_chan].VarStr, 1))
ReportError(StrEnv[kminer_chan].KeyName, 51);
if (!CopyFloat(&KHYDRO_CHAN, StrEnv[khydro_chan].VarStr, 1))
ReportError(StrEnv[khydro_chan].KeyName, 51);
if (!CopyFloat(&KNITRIF1_CHAN, StrEnv[knitrif1_chan].VarStr, 1))
ReportError(StrEnv[knitrif1_chan].KeyName, 51);
if (!CopyFloat(&KNITRIF2_CHAN, StrEnv[knitrif2_chan].VarStr, 1))
ReportError(StrEnv[knitrif2_chan].KeyName, 51);
if (!CopyFloat( Basinwide->atmos_CO2_conc, StrEnv[atmos_co2_conc].VarStr, 12))
ReportError(StrEnv[atmos_co2_conc].KeyName, 51);
if (!CopyFloat( Basinwide->atmos_DOC_conc, StrEnv[atmos_doc_conc].VarStr, 12))
ReportError(StrEnv[atmos_doc_conc].KeyName, 51);
if (!CopyFloat( Basinwide->atmos_DON_conc, StrEnv[atmos_don_conc].VarStr, 12))
ReportError(StrEnv[atmos_don_conc].KeyName, 51);
if (!CopyFloat( Basinwide->atmos_NH4_conc, StrEnv[atmos_nh4_conc].VarStr, 12))
ReportError(StrEnv[atmos_nh4_conc].KeyName, 51);
if (!CopyFloat( Basinwide->atmos_NO3_conc, StrEnv[atmos_no3_conc].VarStr, 12))
ReportError(StrEnv[atmos_no3_conc].KeyName, 51);
if (!CopyFloat( Basinwide->atmos_NO2_conc, StrEnv[atmos_no2_conc].VarStr, 12))
ReportError(StrEnv[atmos_no2_conc].KeyName, 51);
} else {
META_DOC_K_DECOMP = 0.0;
STRUCT_DOC_K_DECOMP = 0.0;
K_DECOMPOSE_DOC = 0.0;
K1_SORPTION_MAX = 0.0;
CN_SORB_DOM = 0.0;
CN_MICRODECOMP_DOM = 0.0;
FREEAIRDCO2 = 0.0;
CO2KGASTRANS = 0.0;
O2KGASTRANS = 0.0;
POTENTIALDENITRIF = 0.0;
DENITRIF_HALFSAT = 0.0;
BG_CATIONS = 0.0;
KOXY_NITRIF = 0.0;
KMINER_CHAN = 0.0;
KNITRIF1_CHAN = 0.0;
KNITRIF2_CHAN = 0.0;
for ( j=0;j<12;j++) {
Basinwide->atmos_CO2_conc[j] = 0.0;
Basinwide->atmos_DOC_conc[j] = 0.0;
Basinwide->atmos_DON_conc[j] = 0.0;
Basinwide->atmos_NH4_conc[j] = 0.0;
Basinwide->atmos_NO3_conc[j] = 0.0;
//Basinwide->atmos_NO3_conc[j] = 0.0;
}
}
}
