/*******************************************************************************
Function name: InitImageDump()
Purpose : Initialize the image dumps. This information is in the
[OUTPUT] section of the input file
Required :
LISTPTR Input - Linked list with input strings
int Dt - Model timestep in seconds
MAPSIZE *MapDump - Information about areal extent
int MaxSoilLayers - Maximum number of soil layers
int MaxVegLayers - Maximum number of vegetation layers
char *Path - Directory to write output to
int NMaps - Number of maps to dump
int NImages - Number of images to dump
MAPDUMP **DMap - Array of maps and images to dump
Returns : void
Modifies : Members of DMap
Comments : InitImageDump must be preceded by a call to InitMapDump, since
the necessary memory is allocated there
*******************************************************************************/
void InitImageDump(LISTPTR Input, int Dt, MAPSIZE * Map, int MaxSoilLayers,
int MaxVegLayers, char *Path, int NMaps, int NImages,
MAPDUMP ** DMap)
{
char *Routine = "InitImageDump";
DATE End; /* End of low resolution map dump period */
DATE Start; /* Start of low resolution map dump period */
int i; /* counter */
int j; /* counter */
int Interval; /* Interval between low resolution map dumps */
int MaxLayers; /* Maximum number of layers allowed for this
variable */
char KeyName[image_lower + 1][BUFSIZE + 1];
char *KeyStr[] = {
"IMAGE VARIABLE",
"IMAGE LAYER",
"IMAGE START",
"IMAGE END",
"IMAGE INTERVAL",
"IMAGE UPPER LIMIT",
"IMAGE LOWER LIMIT"
};
char *SectionName = "OUTPUT";
char VarStr[image_lower + 1][BUFSIZE + 1];
float tmpInterval;
for (i = NMaps - NImages; i < NMaps; i++) {
/* Read the key-entry pairs from the input file */
for (j = 0; j <= image_lower; j++) {
sprintf(KeyName[j], "%s %d", KeyStr[j], i - (NMaps - NImages) + 1);
GetInitString(SectionName, KeyName[j], "", VarStr[j],
(unsigned long)BUFSIZE, Input);
}
/* Assign the entries to the appropriate variables */
if (!CopyInt(&((*DMap)[i].ID), VarStr[image_variable], 1))
ReportError(KeyName[image_variable], 51);
if (!IsValidID((*DMap)[i].ID))
ReportError("Input Options File", 19);
if (IsMultiLayer((*DMap)[i].ID)) {
MaxLayers = GetVarNLayers((*DMap)[i].ID, MaxSoilLayers, MaxVegLayers);
if (!CopyInt(&((*DMap)[i].Layer), VarStr[image_layer], 1))
ReportError(KeyName[image_layer], 51);
if ((*DMap)[i].Layer < 1 || (*DMap)[i].Layer > MaxLayers)
ReportError("Input Options File", 20);
}
else
(*DMap)[i].Layer = 1;
(*DMap)[i].Resolution = IMAGE_OUTPUT;
strncpy((*DMap)[i].FileName, Path, BUFSIZE);
GetVarAttr(&((*DMap)[i]));
(*DMap)[i].NumberType = NC_BYTE;
strcpy((*DMap)[i].Format, "%d");
CreateMapFile((*DMap)[i].FileName, (*DMap)[i].FileLabel, Map);
if (!SScanDate(VarStr[image_start], &Start))
ReportError(KeyName[image_start], 51);
if (!SScanDate(VarStr[image_end], &End))
ReportError(KeyName[image_end], 51);
if (!CopyFloat(&tmpInterval, VarStr[image_interval], 1))
ReportError(KeyName[image_interval], 51);
Interval = SECPHOUR * tmpInterval;
if (Interval % Dt != 0 || Interval <= 0)
ReportError("Input Options File", 24);
if (((*DMap)[i].N = NumberOfSteps(&Start, &End, Interval)) < 1)
ReportError("Input Options File", 25);
if (!((*DMap)[i].DumpDate = (DATE *)calloc((*DMap)[i].N, sizeof(DATE))))
ReportError(Routine, 1);
CopyDate(&((*DMap)[i].DumpDate[0]), &Start);
for (j = 1; j < (*DMap)[i].N; j++)
(*DMap)[i].DumpDate[j] =
NextDate(&((*DMap)[i].DumpDate[j - 1]), Interval);
if (!CopyFloat(&((*DMap)[i].MaxVal), VarStr[image_upper], 1))
ReportError(KeyName[image_upper], 51);
if (!CopyFloat(&((*DMap)[i].MinVal), VarStr[image_lower], 1))
ReportError(KeyName[image_lower], 51);
}
}
int InitTime(TIMESTRUCT * Time, DATE * Start, DATE * End, DATE * StartRadar,
DATE * StartMM5, int Dt)
{
const char *Routine = "InitTime";
int tmpsecond;
Time->Dt = Dt; /* timestep in seconds */
/* Just to be sure, recalculate the Julian and JDay fields of all the dates */
if (Start != NULL) {
CopyDate(&(Time->Start), Start);
Time->Start.JDay = DayOfYear(Time->Start.Year, Time->Start.Month,
Time->Start.Day);
Time->Start.Julian = GregorianToJulianDay(Time->Start.Year,
Time->Start.Month,
Time->Start.Day,
Time->Start.Hour,
Time->Start.Min, Time->Start.Sec);
CopyDate(&(Time->Current), &(Time->Start));
}
if (End != NULL) {
CopyDate(&(Time->End), End);
Time->End.JDay = DayOfYear(Time->End.Year, Time->End.Month, Time->End.Day);
Time->End.Julian = GregorianToJulianDay(Time->End.Year, Time->End.Month,
Time->End.Day, Time->End.Hour,
Time->End.Min, Time->End.Sec);
}
if (StartRadar != NULL) {
CopyDate(&(Time->StartRadar), StartRadar);
Time->StartRadar.JDay =
DayOfYear(Time->StartRadar.Year, Time->StartRadar.Month,
Time->StartRadar.Day);
Time->StartRadar.Julian =
GregorianToJulianDay(Time->StartRadar.Year, Time->StartRadar.Month,
Time->StartRadar.Day, Time->StartRadar.Hour,
Time->StartRadar.Min, Time->StartRadar.Sec);
}
if (StartMM5 != NULL) {
CopyDate(&(Time->StartMM5), StartMM5);
Time->StartMM5.JDay =
DayOfYear(Time->StartMM5.Year, Time->StartMM5.Month, Time->StartMM5.Day);
Time->StartMM5.Julian =
GregorianToJulianDay(Time->StartMM5.Year, Time->StartMM5.Month,
Time->StartMM5.Day, Time->StartMM5.Hour,
Time->StartMM5.Min, Time->StartMM5.Sec);
}
if (Start != NULL && End != NULL) {
if (After(&(Time->Start), &(Time->End)))
return FALSE;
Time->Step = 0;
Time->NDaySteps = SECPDAY / Time->Dt;
if ((SECPDAY - Time->NDaySteps * Time->Dt) != 0)
ReportError((char *) Routine, 7);
/* the 0.5 in the next line is because Julian day is measured from midday,
and we want since midnight */
tmpsecond = Round(((Time->Start.Julian - 0.5) -
floor(Time->Start.Julian - 0.5)) * SECPDAY);
Time->DayStep = tmpsecond / Time->Dt;
/* The following line insures that the first timestep of the day would
coincide with midnight */
if (tmpsecond - Time->DayStep * Time->Dt != 0)
ReportError((char *) Routine, 9);
Time->NTotalSteps = NumberOfSteps(&(Time->Start), &(Time->End), Time->Dt);
if (Time->NTotalSteps == FAIL)
return FALSE;
}
return TRUE;
}
