void Write3DMatrix(FILE * f, int z, int y, int x, vec_t * m)
{
int i;
fprintf(f, "(\n");
for(i = 0; i < z; i++)
{
Write2DMatrix(f, y, x, m + i * (x * y));
}
fprintf(f, ")\n");
}
/*
===============
DrawCurveFan
Draws a curve as part of a flat surface
===============
*/
void DrawCurveFan (face_t *cf, vec5_t opposite, vec5_t prev, vec5_t peak, vec5_t next) {
int i, k, l;
float coef[5][3];
// write it out
if (curveFile) {
vec5_t vecs[4];
for ( i = 0 ; i < 5 ; i++ ) {
vecs[0][i] = opposite[i];
vecs[1][i] = prev[i];
vecs[2][i] = peak[i];
vecs[3][i] = next[i];
}
fprintf (curveFile, "CURVEFAN {\n");
fprintf (curveFile, "textures/%s\n", cf->texdef.name);
Write2DMatrix (curveFile, 4, 5, (float *)vecs);
fprintf (curveFile, "}\n");
return;
}
// calculate the coefficients
for (l = 0 ; l < 5 ; l++) {
float a, b, c;
a = prev[l];
b = peak[l];
c = next[l];
coef[l][0] = a;
coef[l][1] = 2 * b - 2 * a;
coef[l][2] = a - 2 * b + c;
}
// draw it
qglBindTexture (GL_TEXTURE_2D, cf->d_texture->texture_number);
float fColor[3];
SetColor(cf, fColor);
qglBegin (GL_TRIANGLE_FAN);
qglTexCoord2fv( opposite + 3 );
qglVertex3fv( opposite );
for ( k = 0 ; k <= CBLOCK_SUBDIVISIONS ; k++ ) {
vec5_t curve;
float f;
f = (float)k / CBLOCK_SUBDIVISIONS;
for ( l = 0 ; l < 5 ; l++ ) {
curve[l] = coef[l][2]*f*f + coef[l][1]*f + coef[l][0];
}
qglTexCoord2fv( curve + 3 );
qglVertex3fv( curve );
DecColor(fColor);
}
qglEnd ();
}
/*****************************************************************************
StoreModelState()
Store the current state of the model.
The state variables for DHSVM include the following variables:
- Canopy interception for each vegetation layer
- Snow pack conditions:
- presence/absence
- number of days since last snowfall (used in albedo calculation)
- snow water equivalent
- for each layer of the snow pack:
- liquid water content
- temperature
- cold content
- Soil conditions:
- for each soil layer:
- soil moisture (also for the layer below the deepest root zone)
- temperature
- surface temperature
- ground heat storage
*****************************************************************************/
void StoreModelState(char *Path, DATE * Current, MAPSIZE * Map,
OPTIONSTRUCT * Options, TOPOPIX ** TopoMap,
PRECIPPIX ** PrecipMap, SNOWPIX ** SnowMap,
MET_MAP_PIX ** MetMap, RADCLASSPIX ** RadMap,
VEGCHEMPIX ** VegChemMap, LAYER * Veg, SOILPIX ** SoilMap,
LAYER * Soil, UNITHYDRINFO * HydrographInfo,
float *Hydrograph)
{
const char *Routine = "StoreModelState";
char Str[NAMESIZE + 1];
char FileLabel[MAXSTRING + 1];
char FileName[NAMESIZE + 1];
FILE *HydroStateFile;
int i; /* counter */
int x; /* counter */
int y; /* counter */
int NSoil; /* Number of soil layers for current pixel */
int NVeg; /* Number of veg layers for current pixel */
MAPDUMP DMap; /* Dump Info */
void *Array;
/* print a message to stdout that state is being stored */
printf("Saving Model State at: ");
PrintDate(Current, stdout);
printf("\n");
/* Only save met state during debug, it is not needed for start-up */
if (MetMap != NULL && DEBUG) {
sprintf(Str, "%02d.%02d.%04d.%02d.%02d.%02d", Current->Month, Current->Day,
Current->Year, Current->Hour, Current->Min, Current->Sec);
sprintf(FileName, "%sMet.State.%s%s", Path, Str, fileext);
strcpy(FileLabel, "Basic Meteorology at time step");
CreateMapFile(FileName, FileLabel, Map);
if (!(Array = (float *) calloc(Map->NY * Map->NX, sizeof(float))))
ReportError((char *) Routine, 1);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
((float *) Array)[y * Map->NX + x] = PrecipMap[y][x].Precip;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 201;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
((float *) Array)[y * Map->NX + x] = MetMap[y][x].accum_precip;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 701;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
((float *) Array)[y * Map->NX + x] = MetMap[y][x].air_temp;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 702;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
((float *) Array)[y * Map->NX + x] = MetMap[y][x].wind_speed;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 703;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
((float *) Array)[y * Map->NX + x] = MetMap[y][x].humidity;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 704;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
((float *) Array)[y * Map->NX + x] = RadMap[y][x].Beam +
RadMap[y][x].Diffuse;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 303;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
free(Array);
}
/* Store the canopy interception */
sprintf(Str, "%02d.%02d.%04d.%02d.%02d.%02d", Current->Month, Current->Day,
Current->Year, Current->Hour, Current->Min, Current->Sec);
printf("Writing %sInterception.State.%s%s...\n", Path, Str, fileext);
sprintf(FileName, "%sInterception.State.%s%s", Path, Str, fileext);
strcpy(FileLabel, "Interception storage for each vegetation layer");
CreateMapFile(FileName, FileLabel, Map);
if (!(Array = (float *) calloc(Map->NY * Map->NX, sizeof(float))))
ReportError((char *) Routine, 1);
for (i = 0; i < Veg->MaxLayers; i++) {
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
NVeg = Veg->NLayers[(VegChemMap[y][x].Veg - 1)];
if (i < NVeg)
((float *) Array)[y * Map->NX + x] = PrecipMap[y][x].IntRain[i];
else
((float *) Array)[y * Map->NX + x] = NA;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 202;
DMap.Layer = i;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
}
for (i = 0; i < Veg->MaxLayers; i++) {
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
NVeg = Veg->NLayers[(VegChemMap[y][x].Veg - 1)];
if (i < NVeg)
((float *) Array)[y * Map->NX + x] = PrecipMap[y][x].IntSnow[i];
else
((float *) Array)[y * Map->NX + x] = NA;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 203;
DMap.Layer = i;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
}
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
((float *) Array)[y * Map->NX + x] = PrecipMap[y][x].TempIntStorage;
}
else {
((float *) Array)[y * Map->NX + x] = NA;
}
}
}
DMap.ID = 204;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
free(Array);
/* Store the snow pack conditions */
printf("Writing %sSnow.State.%s%s...\n", Path, Str, fileext);
sprintf(FileName, "%sSnow.State.%s%s", Path, Str, fileext);
strcpy(FileLabel, "Snow pack moisture and temperature state");
CreateMapFile(FileName, FileLabel, Map);
if (!(Array = (float *) calloc(Map->NY * Map->NX, sizeof(float))))
ReportError((char *) Routine, 1);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = (float) SnowMap[y][x].HasSnow;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 401;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = (float) SnowMap[y][x].LastSnow;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 403;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = SnowMap[y][x].Swq;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 404;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = SnowMap[y][x].PackWater;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 406;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = SnowMap[y][x].TPack;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 407;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = SnowMap[y][x].SurfWater;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 408;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = SnowMap[y][x].TSurf;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 409;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = SnowMap[y][x].ColdContent;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 410;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
free(Array);
/* Store the soil conditions */
printf("Writing %sSoil.State.%s%s...\n", Path, Str, fileext);
sprintf(FileName, "%sSoil.State.%s%s", Path, Str, fileext);
strcpy(FileLabel, "Soil moisture and temperature state");
CreateMapFile(FileName, FileLabel, Map);
if (!(Array = (float *) calloc(Map->NY * Map->NX, sizeof(float))))
ReportError((char *) Routine, 1);
for (i = 0; i < Soil->MaxLayers + 1; i++) {
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
NSoil = Soil->NLayers[(SoilMap[y][x].Soil - 1)];
if (i <= NSoil)
((float *) Array)[y * Map->NX + x] = SoilMap[y][x].Moist_m_m[i];
else
((float *) Array)[y * Map->NX + x] = NA;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 501;
DMap.Layer = i;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
}
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = SoilMap[y][x].TSurf;
else
((float *) Array)[y * Map->NX + x] = SoilMap[y][x].TSurf;
}
}
DMap.ID = 505;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (i = 0; i < Soil->MaxLayers; i++) {
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask)) {
NSoil = Soil->NLayers[SoilMap[y][x].Soil - 1];
if (i < NSoil)
((float *) Array)[y * Map->NX + x] = SoilMap[y][x].Temp[i];
else
((float *) Array)[y * Map->NX + x] = NA;
}
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 511;
DMap.Layer = i;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
}
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = SoilMap[y][x].Qst;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 510;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
for (y = 0; y < Map->NY; y++) {
for (x = 0; x < Map->NX; x++) {
if (INBASIN(TopoMap[y][x].Mask))
((float *) Array)[y * Map->NX + x] = SoilMap[y][x].Runoff_m;
else
((float *) Array)[y * Map->NX + x] = NA;
}
}
DMap.ID = 512;
DMap.Resolution = MAP_OUTPUT;
strcpy(DMap.FileName, "");
GetVarAttr(&DMap);
Write2DMatrix(FileName, Array, DMap.NumberType, Map->NY, Map->NX, &DMap, 0);
free(Array);
/* If the unit hydrograph is used for flow routing, store the unit
hydrograph array */
if (Options->Extent == BASIN && Options->HasNetwork == FALSE) {
sprintf(FileName, "%sHydrograph.State.%s", Path, Str);
OpenFile(&HydroStateFile, FileName, "w", FALSE);
for (i = 0; i < HydrographInfo->TotalWaveLength; i++)
fprintf(HydroStateFile, "%f\n", Hydrograph[i]);
fclose(HydroStateFile);
}
}
/*
==================
WriteMapFile
==================
*/
static void WriteMapFile(char *filename)
{
FILE *f;
int i, j, k, l;
entity_t *entity;
epair_t *ep;
bspBrush_t *brush;
side_t *side;
plane_t *plane;
parseMesh_t *pm;
// winding_t *w;
shaderInfo_t *si;
Sys_Printf("writing %s\n", filename);
f = fopen(filename, "wb");
if(!f)
Error("Can't write %s\b", filename);
fprintf(f, "Version 2\n");
for(i = 0; i < numEntities; i++)
{
entity = &entities[i];
// write entity header
fprintf(f, "// entity %i\n", i);
fprintf(f, "{\n");
// write epairs
for(ep = entity->epairs; ep; ep = ep->next)
{
fprintf(f, "\"%s\" \"%s\"\n", ep->key, ep->value);
}
// write brush list
for(j = 0, brush = entity->brushes; brush; j++, brush = brush->next)
{
fprintf(f, "// brush %i\n", j);
fprintf(f, "{\n");
fprintf(f, "brushDef3\n");
fprintf(f, "{\n");
for(k = 0, side = brush->sides; k < brush->numsides; k++, side++)
{
// write plane equation
plane = &mapPlanes[side->planenum];
fprintf(f, "( %f %f %f %f ) ", plane->normal[0], plane->normal[1], plane->normal[2], -plane->dist);
// write texture matrix
Write2DMatrix(f, 2, 3, (float *)side->texMat);
si = side->shaderInfo;
fprintf(f, " \"%s\"", si->shader);
// support detail flags
if(side->contents & CONTENTS_DETAIL)
fprintf(f, " %i 0 0\n", CONTENTS_DETAIL);
else
fprintf(f, " 0 0 0\n");
}
fprintf(f, "}\n");
fprintf(f, "}\n");
}
// write patch list
for(j = 0, pm = entity->patches; pm; j++, pm = pm->next)
{
fprintf(f, "// patch %i\n", j);
fprintf(f, "{\n");
if(pm->patchDef3)
fprintf(f, "patchDef3\n");
else
fprintf(f, "patchDef2\n");
fprintf(f, "{\n");
// write shader
si = pm->shaderInfo;
fprintf(f, "\"%s\"\n", si->shader);
// write patch dimensions
if(pm->patchDef3)
fprintf(f, "( %i %i %i %i %i %i %i )\n", (int)pm->info[0], (int)pm->info[1], (int)pm->info[2], (int)pm->info[3],
(int)pm->info[4], (int)pm->info[5], (int)pm->info[6]);
else
fprintf(f, "( %i %i %i %i %i )\n", (int)pm->info[0], (int)pm->info[1], (int)pm->info[2], (int)pm->info[3],
(int)pm->info[4]);
fprintf(f, "(\n");
for(k = 0; k < pm->mesh.width; k++)
{
fprintf(f, "(");
for(l = 0; l < pm->mesh.height; l++)
{
// write drawVert_t::xyz + st
Write1DMatrix(f, 5, pm->mesh.verts[l * pm->mesh.width + k].xyz);
}
fprintf(f, ")\n");
}
fprintf(f, ")\n");
fprintf(f, "}\n");
fprintf(f, "}\n");
}
fprintf(f, "}\n");
}
fclose(f);
}
