const char *NFtimePrint(NFtime_p timePtr, char *timeStr) {
if (timeStr == (char *) NULL) {
CMmsgPrint(CMmsgAppError, "Invalid time string pointer in %s:%d!\n", __FILE__, __LINE__);
}
else if (timePtr->Minute != NFtimeUnset)
sprintf (timeStr, "%04d-%02d-%02d %02d %02d", timePtr->Year, timePtr->Month, timePtr->Day, timePtr->Hour,
timePtr->Minute);
else if (timePtr->Hour != NFtimeUnset)
sprintf (timeStr, "%04d-%02d-%02d %02d", timePtr->Year, timePtr->Month, timePtr->Day, timePtr->Hour);
else if (timePtr->Day != NFtimeUnset)
sprintf (timeStr, "%04d-%02d-%02d", timePtr->Year, timePtr->Month, timePtr->Day);
else if (timePtr->Month != NFtimeUnset) sprintf (timeStr, "%04d-%02d", timePtr->Year, timePtr->Month);
else
sprintf (timeStr, "%04d", timePtr->Year);
return (timeStr);
}
static bool _NCdsHandleGContTestNodata(const NCdsHandleGCont_t *gCont, double val) {
switch (gCont->GType) {
default:
CMmsgPrint(CMmsgAppError, "Invalid data NetCDF type in: %s %d", __FILE__, __LINE__);
break;
case NC_BYTE:
case NC_SHORT:
case NC_INT:
return ((gCont->MissingVal.Int == (int) val) || (gCont->FillValue.Int == (int) val) ? true : false);
case NC_FLOAT:
case NC_DOUBLE:
return (NCmathEqualValues(gCont->MissingVal.Float, val) || NCmathEqualValues(gCont->FillValue.Float, val)
? true : false);
}
return (true);
}
static void _MDCParamAlbedo (int itemID) {
// Input
int cover;
float snowPack;
// Local
static float albedo [] = { 0.14, 0.18, 0.18, 0.20, 0.20, 0.22, 0.26, 0.10 };
static float albedoSnow [] = { 0.14, 0.23, 0.35, 0.50, 0.50, 0.50, 0.50, 0.50 };
cover = MFVarGetInt (_MDInCoverID, itemID, 7); // defaulting missing value to water.
if ((cover < 0) || (cover >= (int) (sizeof (albedo) / sizeof (albedo [0])))) {
CMmsgPrint (CMmsgWarning,"Warning: Invalid cover [%d] in: %s:%d\n",cover,__FILE__,__LINE__);
return;
}
snowPack = MFVarGetFloat (_MDInSnowPackID, itemID, 0.0);
MFVarSetFloat (_MDOutCParamAlbedoID,itemID,snowPack > 0.0 ? albedoSnow[cover] : albedo[cover]);
}
static NCgridVariable_p _NCgridVariableCreate(size_t fileNum) {
size_t i;
NCgridVariable_p gridVariable;
if (((gridVariable = (NCgridVariable_p) calloc(1, sizeof(NCgridVariable_t))) == (NCgridVariable_p) NULL) ||
((gridVariable->VarIDs = (int *) calloc(fileNum, sizeof(int))) == (int *) NULL) ||
((gridVariable->Units = (ut_unit **) calloc(fileNum, sizeof(ut_unit *))) == (ut_unit **) NULL)) {
CMmsgPrint(CMmsgSysError, "Memory alloction error in %s:%s!\n", __FILE__, __LINE__);
return ((NCgridVariable_p) NULL);
}
for (i = 0; i < fileNum; ++i) {
gridVariable->VarIDs[i] = CMfailed;
gridVariable->Units[i] = (ut_unit *) NULL;
}
return (gridVariable);
}
NCdataType NCdataGetType(int ncid) {
int status;
char dTypeStr[NC_MAX_NAME];
if ((status = nc_get_att_text(ncid, NC_GLOBAL, NCnameGADataType, dTypeStr)) == NC_NOERR) {
if (strncmp(dTypeStr, NCnameTypeGCont, strlen(NCnameTypeGCont)) == 0) return (NCtypeGCont);
else if (strncmp(dTypeStr, NCnameTypeGDisc, strlen(NCnameTypeGDisc)) == 0) return (NCtypeGDisc);
else if (strncmp(dTypeStr, NCnameTypePoint, strlen(NCnameTypePoint)) == 0) return (NCtypePoint);
else if (strncmp(dTypeStr, NCnameTypeLine, strlen(NCnameTypeLine)) == 0) return (NCtypeLine);
else if (strncmp(dTypeStr, NCnameTypePolygon, strlen(NCnameTypePolygon)) == 0) return (NCtypePolygon);
else if (strncmp(dTypeStr, NCnameTypeNetwork, strlen(NCnameTypeNetwork)) == 0) return (NCtypeNetwork);
CMmsgPrint(CMmsgAppError, "Invalid data type in: %s %d", __FILE__, __LINE__);
return (NCtypeUndefined);
}
return (NCtypeGCont);
}
DBInt RGlibGenFuncFieldCompare (DBObjTable *table,char *f0Text,char *f1Text,char *rText,DBInt diffMethod)
{
DBInt intVal, ret, i, rowID;
DBFloat val [2];
DBObjTableField *field [2];
DBObjTableField *result;
DBObjRecord *record;
field [0] = table->Field (f0Text);
field [1] = table->Field (f1Text);
result = table->Field (rText);
if ((field [0] == (DBObjTableField *) NULL) || (field [1] == (DBObjTableField *) NULL))
{ CMmsgPrint (CMmsgAppError, "Invalid Compare Fields in: %s %d",__FILE__,__LINE__); return (DBFault); }
if (result == (DBObjTableField *) NULL)
table->AddField (result = new DBObjTableField (rText,DBTableFieldFloat,"%10.3f",sizeof (DBFloat4)));
if (diffMethod > 0) result->Format ("%6.2f");
for (rowID = 0;rowID < table->ItemNum ();++rowID)
{
record = table->Item (rowID);
if ((record->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle)
result->Float (record,result->FloatNoData ());
else
{
for (i = 0;i < 2;++i)
if (field [i]->Type () == DBTableFieldInt)
{
intVal = field [i]->Int (record);
ret = intVal == field [i]->IntNoData ();
val [i] = (DBFloat) intVal;
}
else
{
val [i] = field [i]->Float (record);
ret = CMmathEqualValues (val [i],field [i]->FloatNoData ());
}
if (ret) result->Float (record,result->FloatNoData ());
else switch (diffMethod)
{
default: result->Float (record, val [0] - val [1]); break;
case 1: result->Float (record,(val [0] - val [1]) * 100.0 / val [0]); break;
case 2: result->Float (record,(val [0] - val [1]) * 100.0 / (val [0] > val [1] ? val [0] : val [1])); break;
}
}
}
return (DBSuccess);
}
void UIMenuItem::CreateButton(Widget menuWidget,
UIMenuItem *menuBut,
void *menuData) {
Arg wargs[2];
int argNum = 0, menuNum;
char mnemonic[2];
Widget subMenu;
XmString string;
switch (menuBut->Type) {
case UIMENU_FUNCTION:
string = XmStringCreate(menuBut->Label, UICharSetNormal);
menuBut->Button = XtVaCreateWidget("UIFunctionButton", xmPushButtonGadgetClass, menuWidget,
XmNuserData, menuBut,
XmNlabelString, string,
NULL);
XtAddCallback(menuBut->Button, XmNactivateCallback, (XtCallbackProc) _UIMenuButtonCBK,
(XtPointer) menuData);
XmStringFree(string);
break;
case UIMENU_SUBMENU:
argNum = 0;
subMenu = XmCreatePulldownMenu(menuWidget, (char *) "GHAASPullDownMenu", wargs, argNum);
mnemonic[0] = menuBut->Label[0];
mnemonic[1] = '\0';
string = XmStringCreate(menuBut->Label, UICharSetBold);
menuBut->Button = XtVaCreateWidget("UISubmenuButton", xmCascadeButtonWidgetClass, menuWidget,
XmNlabelString, string,
XmNsubMenuId, subMenu,
XmNmnemonic, XStringToKeysym(mnemonic),
NULL);
XmStringFree(string);
if (menuBut->Action != NULL)
for (menuNum = 0; ((UIMenuItem *) menuBut->Action)[menuNum].Type != 0; ++menuNum)
menuBut->CreateButton(subMenu, ((UIMenuItem *) menuBut->Action) + menuNum, menuData);
break;
case UIMENU_SEPARATOR:
menuBut->Button = XmCreateSeparatorGadget(menuWidget, (char *) "GHAASMenuSeparator", NULL, 0);
break;
default:
CMmsgPrint(CMmsgAppError, "Not valid Button type in: %s %d", __FILE__, __LINE__);
return;
}
if (menuBut->VisibleVAR == UIMENU_NORULE) XtManageChild(menuBut->Button);
XtSetSensitive(menuBut->Button, menuBut->SensitiveVAR == UIMENU_NORULE);
}
void Finalize_Hamon(void *userData) {
size_t i;
HamonData_t *data = (HamonData_t *) userData;
CMmsgPrint(CMmsgUsrError, "Parameter0: %lf\n", data->Parameter0);
CMmsgPrint(CMmsgUsrError, "Parameter1: %lf\n", data->Parameter1);
CMmsgPrint(CMmsgUsrError, "Airtemp: %lf\n", data->Airtemp);
CMmsgPrint(CMmsgUsrError, "VaporPressure: %lf\n", data->VaporPressure);
CMmsgPrint(CMmsgUsrError, "PotEvap: %lf\n", data->PotEvap);
for (i = 0; i < VectorLen; ++i) CMmsgPrint(CMmsgInfo, "Vector: %lf\n", data->Vector[i]);
}
void GetVariable(DBObjRecord *record, DBCoordinate coord) {
switch ((GridIF->Data())->Type()) {
case DBTypeGridContinuous: {
DBFloat value;
if (GridIF->Value(LayerRec, coord, &value))
TargetFLD->Float(record, value);
else TargetFLD->Float(record, TargetFLD->FloatNoData());
}
break;
case DBTypeGridDiscrete: {
DBObjRecord *grdRec;
if ((grdRec = GridIF->GridItem(LayerRec, coord)) != (DBObjRecord *) NULL)
switch (SourceFLD->Type()) {
case DBVariableString:
TargetFLD->String(record, SourceFLD->String(grdRec));
break;
case DBVariableInt:
TargetFLD->Int(record, SourceFLD->Int(grdRec));
break;
case DBVariableFloat:
TargetFLD->Float(record, SourceFLD->Float(grdRec));
break;
default:
break;
}
else
switch (SourceFLD->Type()) {
case DBVariableString:
TargetFLD->String(record, "");
break;
case DBVariableInt:
TargetFLD->Int(record, SourceFLD->IntNoData());
break;
case DBVariableFloat:
TargetFLD->Float(record, SourceFLD->FloatNoData());
break;
default:
break;
}
}
break;
default:
CMmsgPrint(CMmsgUsrError, "Invalid grid type in: CMDgrdVariable:GetVariable ()");
break;
}
}
NCstate NCdsHandleDefine (NCdsHandle_t *dsh, int *ncids, size_t n)
{
NCdataType dataType;
int i;
dsh->NCIds = (int *) NULL;
NCdsHandleClear (dsh);
if (n < 1) return (NCfailed);
if ((dataType = NCdataGetType (ncids [0])) == NCtypeUndefined) return (NCfailed);
dsh->DataType = dataType;
if ((dsh->NCIds = (int *) calloc (n,sizeof (int))) == (int *) NULL)
{ CMmsgPrint (CMmsgSysError, "Memory allocation error in: %s %d",__FILE__,__LINE__); return (NCfailed); }
for (i = 0;i < n;++i) dsh->NCIds [i] = ncids [i];
dsh->NCnum = n;
return (NCsucceeded);
}
int main( int argc, char* argv[] )
{
fData* theData;
int errCheck;
setInputFiles( argc,argv );
theData = readFile( dataFile, dataTypesFile, &errCheck );
if(errCheck)
CMmsgPrint (CMmsgUsrError, "errors were reported, but continuing anyways.");
printDataTypes( *theData );
freeFData( theData );
return 0;
}
void DBGridOperation(DBObjData *grdData, DBFloat constant, DBInt oper) {
DBInt layerID;
DBFloat value;
DBPosition pos;
DBObjRecord *layerRec;
DBGridIF *gridIF = new DBGridIF(grdData);
for (layerID = 0; layerID < gridIF->LayerNum(); ++layerID) {
layerRec = gridIF->Layer(layerID);
if ((layerRec->Flags() & DBObjectFlagIdle) != DBObjectFlagIdle) break;
}
if (layerID == gridIF->LayerNum()) {
CMmsgPrint(CMmsgAppError, "No Layer to Process in %s %d", __FILE__, __LINE__);
return;
}
for (layerID = 0; layerID < gridIF->LayerNum(); ++layerID) {
layerRec = gridIF->Layer(layerID);
if ((layerRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue;
for (pos.Row = 0; pos.Row < gridIF->RowNum(); pos.Row++) {
if (DBPause((layerID * gridIF->RowNum() + pos.Row) * 100 / (gridIF->LayerNum() * gridIF->RowNum())))
goto Stop;
for (pos.Col = 0; pos.Col < gridIF->ColNum(); pos.Col++) {
if (gridIF->Value(layerRec, pos, &value))
switch (oper) {
case DBMathOperatorAdd:
gridIF->Value(layerRec, pos, value + constant);
break;
case DBMathOperatorSub:
gridIF->Value(layerRec, pos, value - constant);
break;
case DBMathOperatorMul:
gridIF->Value(layerRec, pos, value * constant);
break;
case DBMathOperatorDiv:
gridIF->Value(layerRec, pos, value / constant);
break;
}
}
}
gridIF->RecalcStats(layerRec);
}
Stop:
return;
}
NFcontext_p NFcontextCreate () {
NFcontext_p context;
if ((context = (NFcontext_p ) malloc (sizeof (NFcontext_t))) == (NFcontext_p) NULL) {
CMmsgPrint (CMmsgSysError,"Memory allocation error in %s:%d\n",__FILE__,__LINE__);
return ((NFcontext_p) NULL);
}
context->TimeStepUnit = (const char *) NULL;
context->MinTimeStep = 0;
context->MaxTimeStep = 0;
context->ParameterNum = context->VariableNum = 0;
context->Parameters = (struct NFparameter_s *) NULL;
context->Variables = (struct NFvariable_s *) NULL;
context->UserDataSize = 0;
context->UserData = (void *) NULL;
return (context);
}
int DBObjData::Write (const char *fileName)
{
DBInt ret;
FILE *file;
if (strncmp(CMfileExtension(fileName),"nc",2) == 0)
ret = DBExportNetCDF (this,fileName);
else
{
if ((file = fopen (fileName,"w")) == (FILE *) NULL)
{ CMmsgPrint (CMmsgSysError, "File (%s) Opening Error in: %s %d", fileName, __FILE__,__LINE__); return (DBFault); }
ret = Write (file);
fclose (file);
}
return (ret);
}
DBInt DBGridIF::DeleteLayers(char *firstLayer, char *lastLayer) {
DBInt layerID;
DBObjRecord *layerRec;
if ((layerRec = LayerTable->Item(firstLayer)) == (DBObjRecord *) NULL) {
CMmsgPrint(CMmsgAppError, "Invalid layer name in: %s %d", __FILE__, __LINE__);
return (DBFault);
}
layerID = layerRec->RowID();
while (strcmp(layerRec->Name(), lastLayer) != 0) {
DeleteLayer(layerRec->Name());
if ((layerRec = LayerTable->Item(layerID)) == (DBObjRecord *) NULL) break;
}
return (DBSuccess);
}
DBCoordinate *DBVPolyIF::Vertexes(const DBObjRecord *polyRec) const {
DBInt vertex, i, line;
DBObjRecord *lineRec, *nodeRec, *firstNodeRec;
DBCoordinate *lcoords;
vertex = 0;
lineRec = FirstLine(polyRec);
firstNodeRec = nodeRec = LineRightPoly(lineRec) == polyRec ? FromNode(lineRec) : ToNode(lineRec);
for (line = 0; line < LineNum(polyRec); ++line) {
if (LineRightPoly(lineRec) == polyRec) {
if (nodeRec != FromNode(lineRec)) {
CoordsPTR[vertex++] = NodeCoord(nodeRec);
if (nodeRec != firstNodeRec) CoordsPTR[vertex++] = NodeCoord(firstNodeRec);
nodeRec = FromNode(lineRec);
}
CoordsPTR[vertex++] = NodeCoord(nodeRec);
if (DBVLineIF::VertexNum(lineRec) > 0) {
lcoords = DBVLineIF::Vertexes(lineRec);
for (i = 0; i < DBVLineIF::VertexNum(lineRec); ++i) CoordsPTR[vertex++] = lcoords[i];
}
nodeRec = ToNode(lineRec);
lineRec = LineNextLine(lineRec);
}
else {
if (nodeRec != ToNode(lineRec)) {
CoordsPTR[vertex++] = NodeCoord(nodeRec);
if (nodeRec != firstNodeRec) CoordsPTR[vertex++] = NodeCoord(firstNodeRec);
nodeRec = ToNode(lineRec);
}
CoordsPTR[vertex++] = NodeCoord(nodeRec);
if (DBVLineIF::VertexNum(lineRec) > 0) {
lcoords = (DBCoordinate *) (DBVLineIF::Vertexes(lineRec));
for (i = DBVLineIF::VertexNum(lineRec); i > 0; --i) CoordsPTR[vertex++] = lcoords[i - 1];
}
nodeRec = FromNode(lineRec);
lineRec = LinePrevLine(lineRec);
}
}
CoordsPTR[vertex++] = NodeCoord(nodeRec);
if (nodeRec != firstNodeRec) CoordsPTR[vertex++] = NodeCoord(firstNodeRec);
if (VertexNum(polyRec) != vertex)
CMmsgPrint(CMmsgAppError, "Warning in Polygon %d VertexNum [%d %d] in: %s %d", polyRec->RowID(),
VertexNum(polyRec), vertex, __FILE__, __LINE__);
return (CoordsPTR);
}
int MDBgcRiverGPPDef () {
int optID = MFUnset;
const char *optStr;
const char *options [] = { "none", "calculate", (char *) NULL };
if (_MDRiverGPPID != MFUnset) return (_MDRiverGPPID);
MFDefEntering ("Calculate river GPP");
if (((optStr = MFOptionGet (MDOptReservoirs)) == (char *) NULL) || ((optID = CMoptLookup ( options, optStr, true)) == CMfailed)) {
CMmsgPrint(CMmsgUsrError,"Reservoir Option not specified! Option none or calculate \n");
return CMfailed;
}
if (optID==1){
// printf ("Resoption=%i\n",optID);
if (((_MDInResStorageID = MFVarGetID (MDVarReservoirStorage, "km3", MFInput, MFState, MFInitial)) == CMfailed) ||
((_MDInResStorageChangeID = MFVarGetID (MDVarReservoirStorageChange, "km3/s", MFInput, MFState, MFBoundary)) == CMfailed))
return CMfailed;
}
//input
if (//((_MDInDischargeID = MDDischargeDef ()) == CMfailed) ||
((_MDInRiverLightID = MDBgcRiverLightDef ()) == CMfailed) ||
((_MDInDischargeID = MFVarGetID (MDVarDischarge, "m3/s", MFInput, MFState, MFBoundary)) == CMfailed) ||
((_MDInRiverWidthID = MFVarGetID (MDVarRiverWidth, "m", MFInput, MFState, MFBoundary)) == CMfailed) ||
((_MDInPAR2BottomID = MFVarGetID (MDVarPAR2Bottom, "MJ/m2/d", MFInput, MFState, MFBoundary)) == CMfailed) ||
// output
((_MDBenthicAlgaeCHLID = MFVarGetID (MDVarBenthicAlgaeCHL, "g/m2", MFOutput, MFState, MFInitial)) == CMfailed) ||
((_MDBenthicAlgaeCID = MFVarGetID (MDVarBenthicAlgaeC, "g/m2", MFOutput, MFState, MFInitial)) == CMfailed) ||
((_MDBenthicGPPID = MFVarGetID (MDVarBenthicGPP, "g/m2/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
((_MDBenthicRaID = MFVarGetID (MDVarBenthicRa, "g/m2/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
((_MDBenthicNPPID = MFVarGetID (MDVarBenthicNPP, "g/m2/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
((_MDBenthicMortalityID = MFVarGetID (MDVarBenthicMortality, "g/m2/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
((_MDBenthicAlgaeC_REACHID = MFVarGetID (MDVarBenthicAlgaeC_REACH, "g/m2", MFOutput, MFState, MFInitial)) == CMfailed) ||
((_MDBenthicGPP_REACHID = MFVarGetID (MDVarBenthicGPP_REACH, "g/m2/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
((_MDBenthicRa_REACHID = MFVarGetID (MDVarBenthicRa_REACH, "g/m2/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
((_MDBenthicNPP_REACHID = MFVarGetID (MDVarBenthicNPP_REACH, "g/m2/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
((_MDBenthicMortality_REACHID = MFVarGetID (MDVarBenthicMortality_REACH, "g/m2/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
(MFModelAddFunction (_MDRiverGPP) == CMfailed)) return (CMfailed);
MFDefLeaving ("Calculate river GPP");
return (_MDRiverGPPID);
}
int UIColorNum(int colorSet) {
switch (colorSet) {
case UIColorStandard:
return (_UIColorNum (_UIStandardColors));
case UIColorElevation:
return (_UIColorNum (_UIElevationColors));
case UIColorGreyScale:
return (_UIColorNum (_UIGreyColors));
case UIColorBlueScale:
return (_UIColorNum (_UIBlueColors));
case UIColorRedScale:
return (_UIColorNum (_UIRedColors));
case UIColorTrueColor:
default:
CMmsgPrint(CMmsgUsrError, "Invalid colorset [%d]!", colorSet);
return (UIFault);
}
}
char *DBGridIF::ValueString(DBObjRecord *layerRec, DBPosition pos) {
static char retString[DBStringLength + 1];
switch (DataPTR->Type()) {
case DBTypeGridDiscrete:
return (GridItem(layerRec, pos))->Name();
case DBTypeGridContinuous: {
DBFloat cellVal;
if (Value(layerRec, pos, &cellVal) == false) return ((char *) "");
sprintf(retString, ValueFormat(), cellVal);
}
break;
default:
CMmsgPrint(CMmsgAppError, "Invalid Data Type in: %s %d", __FILE__, __LINE__);
return ((char *) NULL);
}
return (retString);
}
CMreturn Configure(bool shrink, bool flat, char *expStr) {
size_t i;
DBInt recID, layerID;
DBFloat floatVal;
DBObject *obj;
DBObjTableField *fieldPTR;
Operand = new DBMathOperand(expStr);
if (Operand->Expand(Variables) == DBFault) return (CMfailed);
CellSize.X = CellSize.Y = DBHugeVal;
for (recID = 0; recID < Variables->ItemNum(); ++recID) {
obj = Variables->Item(recID);
if ((fieldPTR = Table->Field(obj->Name())) != (DBObjTableField *) NULL) continue;
if ((GrdVar = (CMDgrdVariable **) realloc(GrdVar, sizeof(CMDgrdVariable *) * (VarNum + 1))) ==
(CMDgrdVariable **) NULL) {
CMmsgPrint(CMmsgSysError, "Memory Allocation Error in: %s %d", __FILE__, __LINE__);
return (CMfailed);
}
GrdVar[VarNum] = new CMDgrdVariable(obj->Name());
if (GrdVar[VarNum]->Configure(Table, flat) == DBFault) {
for (i = 0; i <= VarNum; ++i) delete GrdVar[i];
free(GrdVar);
return (CMfailed);
}
Extent.Expand(GrdVar[VarNum]->Extent());
floatVal = GrdVar[VarNum]->CellWidth();
if (CellSize.X > floatVal) CellSize.X = floatVal;
floatVal = GrdVar[VarNum]->CellHeight();
if (CellSize.Y > floatVal) CellSize.Y = floatVal;
layerID = (GrdVar[VarNum])->LayerNum();
if (LayerNum < layerID) {
LayerNum = layerID;
MasterVar = VarNum;
}
VarNum++;
}
for (i = 0; i < ExpNum; ++i) if (Expressions[i]->Configure(Table) == DBFault) return (CMfailed);
Operand->Configure(Table->Fields());
if (shrink) for (i = 0; i < VarNum; ++i) Extent.Shrink(GrdVar[i]->Extent());
return (CMsucceeded);
}
NCstate NCdsHandleGContSetFill(NCdsHandleGCont_t *gCont, size_t row, size_t col) {
if (row > gCont->RowNum) return (NCfailed);
if (col > gCont->ColNum) return (NCfailed);
switch (gCont->GType) {
default:
CMmsgPrint(CMmsgAppError, "Invalide NetCDF type in: %s %d", __FILE__, __LINE__);
return (NCfailed);
case NC_BYTE:
case NC_SHORT:
case NC_INT:
gCont->Data[gCont->ColNum * row + col] = (double) gCont->FillValue.Int;
break;
case NC_FLOAT:
case NC_DOUBLE:
gCont->Data[gCont->ColNum * row + col] = gCont->FillValue.Float;
break;
}
return (NCsucceeded);
}
char *NCdataGetTextAttribute(int ncid, int varid, const char *attName) {
int status;
char *att;
size_t attlen;
if ((status = nc_inq_attlen(ncid, varid, attName, &attlen)) != NC_NOERR) return ("undefined");
if ((att = (char *) malloc(attlen + 1)) == (char *) NULL) {
CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s %d", __FILE__, __LINE__);
return ((char *) NULL);
}
if ((status = nc_get_att_text(ncid, varid, attName, att)) != NC_NOERR) {
NCprintNCError (status, "NCdataGetTextAttribute");
free(att);
return ((char *) NULL);
}
att[attlen] = '\0';
return (att);
}
char *UISelection(Widget widget, char *items, int itemSize, int itemNum) {
int i;
XmString *strings;
if ((strings = (XmString *) calloc(itemNum, sizeof(XmString))) == NULL) {
CMmsgPrint(CMmsgSysError, "Memory Allocation Error in: %s %d", __FILE__, __LINE__);
return (NULL);
}
for (i = 0; i < itemNum; ++i) strings[i] = XmStringCreate(items + i * itemSize, UICharSetNormal);
_UISelection = NULL;
XtVaSetValues(widget, XmNlistItems, strings, XmNlistItemCount, itemNum, NULL);
XtManageChild(widget);
while (UILoop());
XtUnmanageChild(widget);
for (i = 0; i < itemNum; ++i) XmStringFree(strings[i]);
free(strings);
return (_UISelection);
}
static int getDaysSincePlanting(int DayOfYearModel, int DayOfYearPlanting[numSeasons],int NumGrowingSeasons,const MDIrrigatedCrop * pIrrCrop) {
int ret=-888;
float totalSeasonLenth;
totalSeasonLenth =
pIrrCrop->cropSeasLength[0] +
pIrrCrop->cropSeasLength[1] +
pIrrCrop->cropSeasLength[2] + pIrrCrop->cropSeasLength[3];
int dayssinceplanted ; //Default> crop is not grown!
int i;
for (i = 0; i < NumGrowingSeasons; i++) {
dayssinceplanted = DayOfYearModel - DayOfYearPlanting[i];
if (dayssinceplanted < 0) dayssinceplanted = 365 + (DayOfYearModel-DayOfYearPlanting[i]);
if (dayssinceplanted < totalSeasonLenth) ret = dayssinceplanted;
}
if (ret >totalSeasonLenth) CMmsgPrint (CMmsgDebug, "dayssinceplantedkorrect ?? %i %i \n",ret, DayOfYearModel);
return ret;
}
CMreturn _CMthreadJobTaskSort (CMthreadJob_p job) {
size_t taskId, start;
size_t travel, maxTravel = 0, maxRank;
CMthreadTask_p dependent;
for (taskId = 0;taskId < job->TaskNum; ++taskId) {
travel = 0;
for (dependent = job->Tasks + taskId; dependent->Dependent != (CMthreadTask_p) NULL; dependent = dependent->Dependent) {
travel += 1;
if (dependent->Rank < travel) {
dependent->Rank = travel;
if (maxRank < travel) maxRank = travel;
}
}
job->Tasks [taskId].Travel = travel;
if (maxTravel < travel) maxTravel = travel;
}
qsort (job->SortedTasks,job->TaskNum,sizeof (CMthreadTask_p),_CMthreadJobTaskCompare);
job->GroupNum = job->SortedTasks [0]->Travel + 1;
if ((job->Groups = (CMthreadTaskGroup_p) realloc (job->Groups, job->GroupNum * sizeof (CMthreadTaskGroup_t))) == (CMthreadTaskGroup_p) NULL) {
CMmsgPrint (CMmsgSysError,"Memory allocation error in: %s:%d",__FILE__,__LINE__);
return (CMfailed);
}
travel = 0;
start = 0;
for (taskId = 0;taskId < job->TaskNum; ++taskId) {
if (travel != job->GroupNum - job->SortedTasks [taskId]->Travel - 1) {
job->Groups [travel].Start = (size_t) start;
job->Groups [travel].End = (size_t) taskId;
// printf ("%3d/%3d %5d %5d %5d\n",travel,job->GroupNum, job->Groups [travel].End - job->Groups [travel].Start, job->Groups [travel].Start,job->Groups [travel].End);
travel = job->GroupNum - job->SortedTasks [taskId]->Travel - 1;
start = taskId;
}
}
job->Groups [travel].Start = (size_t) start;
job->Groups [travel].End = (size_t) taskId;
// printf ("%3d/%3d %5d %5d %5d\n",travel,job->GroupNum, job->Groups [travel].End - job->Groups [travel].Start, job->Groups [travel].Start,job->Groups [travel].End);
job->Sorted = true;
return (CMsucceeded);
}
int MDBgcRiverLightDef () {
int optID = MFUnset;
const char *optStr;
const char *options [] = { "none", "calculate", (char *) NULL };
if (_MDRiverLightID != MFUnset) return (_MDRiverLightID);
MFDefEntering ("Calculate river light");
if (((optStr = MFOptionGet (MDOptReservoirs)) == (char *) NULL) || ((optID = CMoptLookup ( options, optStr, true)) == CMfailed)) {
CMmsgPrint(CMmsgUsrError,"Reservoir Option not specified! Option none or calculate \n");
return CMfailed;
}
if (optID==1){
// printf ("Resoption=%i\n",optID);
if (((_MDInResStorageID = MFVarGetID (MDVarReservoirStorage, "km3", MFInput, MFState, MFInitial)) == CMfailed) ||
((_MDInResStorageChangeID = MFVarGetID (MDVarReservoirStorageChange, "km3/s", MFInput, MFState, MFBoundary)) == CMfailed))
return CMfailed;
}
//input
if (//((_MDInDischargeID = MDDischargeDef ()) == CMfailed) ||
// ((_MDInSolarRadID = MDSolarRadDef ()) == CMfailed) ||
((_MDInFluxDOCID = MDBgcDOCRoutingDef ()) == CMfailed) ||
((_MDInSolarRadID = MFVarGetID (MDVarSolarRadiation, "MJ/m2/d", MFInput, MFFlux, MFBoundary)) == CMfailed) ||
((_MDInDischargeID = MFVarGetID (MDVarDischarge, "m3/s", MFInput, MFState, MFBoundary)) == CMfailed) ||
((_MDInConcDOCID = MFVarGetID (MDVarDOCConcentration, "kg/m3", MFInput, MFState, MFBoundary)) == CMfailed) ||
((_MDInRiverWidthID = MFVarGetID (MDVarRiverWidth, "m", MFInput, MFState, MFBoundary)) == CMfailed) ||
((_MDInRiverbedWidthMeanID = MFVarGetID (MDVarRiverbedWidthMean, "m", MFInput, MFState, MFBoundary)) == CMfailed) ||
((_MDInRiverDepthID = MFVarGetID (MDVarRiverDepth, "m", MFInput, MFState, MFBoundary)) == CMfailed) ||
((_MDInKoppenID = MFVarGetID (MDVarKoppen, MFNoUnit, MFInput, MFState, MFBoundary)) == CMfailed) ||
// output
((_MDPAR2BottomID = MFVarGetID (MDVarPAR2Bottom, "MJ/m2/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
((_MDPAR2ReachID = MFVarGetID (MDVarPAR2Reach, "MJ/d", MFOutput, MFState, MFBoundary)) == CMfailed) ||
(MFModelAddFunction (_MDRiverLight) == CMfailed)) return (CMfailed);
MFDefLeaving ("Calculate river light");
return (_MDRiverLightID);
}
DBVPolyIF::DBVPolyIF(DBObjData *data) : DBVLineIF(data, data->Table(DBrNContours)) {
DBObjTable *items = data->Table(DBrNItems);
LineTable = data->Table(DBrNContours);
DBObjRecord *polyRec;
FirstLineFLD = items->Field(DBrNFirstLine);
LineNumFLD = items->Field(DBrNLineNum);
ExtentFLD = items->Field(DBrNRegion);
LeftPolyFLD = LineTable->Field(DBrNLeftPoly);
RightPolyFLD = LineTable->Field(DBrNRightPoly);
NextLineFLD = LineTable->Field(DBrNNextLine);
PrevLineFLD = LineTable->Field(DBrNPrevLine);
VertexNumFLD = items->Field(DBrNVertexNum);
AreaFLD = items->Field(DBrNArea);
MaxVertexNumVAR = 0;
for (polyRec = FirstItem(); polyRec != (DBObjRecord *) NULL; polyRec = NextItem())
MaxVertexNumVAR = MaxVertexNumVAR > VertexNum(polyRec) ? MaxVertexNumVAR : VertexNum(polyRec);
if ((CoordsPTR = (DBCoordinate *) malloc(MaxVertexNumVAR * sizeof(DBCoordinate))) ==
(DBCoordinate *) NULL) { CMmsgPrint(CMmsgSysError, "Memory Allocation Error in: %s %d", __FILE__, __LINE__); }
}
static float getCropKc(const MDIrrigatedCrop * pIrrCrop, int daysSincePlanted, int curCropStage)
{
float kc;
//Returns kc depending on the current stage of the growing season
if (curCropStage == 0) kc = 0.0; //crop is not currently grown
if (curCropStage == 1) kc = pIrrCrop->cropKc[0];
if (curCropStage == 2) {
int daysInStage = (daysSincePlanted - pIrrCrop->cropSeasLength[0]);
kc = pIrrCrop->cropKc[0] + (daysInStage / pIrrCrop->cropSeasLength[1])*(pIrrCrop->cropKc[1]-pIrrCrop->cropKc[0]);
}
if (curCropStage == 3) kc = pIrrCrop->cropKc[1];
if (curCropStage == 4) {
int daysInStage4 = (daysSincePlanted - (pIrrCrop->cropSeasLength[0] + pIrrCrop->cropSeasLength[1] + pIrrCrop->cropSeasLength[2]));
//kc = pIrrCrop->cropKc[2] - (daysInStage4 / pIrrCrop->cropSeasLength[3]) * abs(pIrrCrop->cropKc[3] - pIrrCrop->cropSeasLength[2]);
kc=pIrrCrop->cropKc[1]+ daysInStage4/ pIrrCrop->cropSeasLength[3] *(pIrrCrop->cropKc[2]-pIrrCrop->cropKc[1]);
//printf ("Len3 %f kc3 %f daysin4 %i KC %f \n" , pIrrCrop->cropSeasLength[3], pIrrCrop->cropKc[3],daysInStage4,kc);
}
if (kc >1.5 ) CMmsgPrint (CMmsgDebug, "kc korrect ?? kc stage dayssinceplanted kc0 kc1 season0length %f %i %i %f %f %f \n",kc, curCropStage, daysSincePlanted, pIrrCrop->cropKc[0],pIrrCrop->cropKc[1], pIrrCrop->cropSeasLength[0]);
return kc;
}
int DBObjData::Read (const char *fileName)
{
FILE *file;
if (strncmp(CMfileExtension(fileName),"nc",2) == 0)
{
Type (DBTypeGridContinuous); // TODO: Limiting to Continuous grid
if (DBImportNetCDF (this,fileName) == DBFault) return (DBFault);
}
else
{
if ((file = fopen (fileName,"r")) == (FILE *) NULL)
{
CMmsgPrint (CMmsgAppError, "File (%s) Opening Error in: %s %d",fileName, __FILE__,__LINE__);
return (DBFault);
}
if (Read (file) == DBFault) return (DBFault);
}
FileName (fileName);
return (DBSuccess);
}
/****************************************************************************************************************
* Entry text
*****************************************************************************************************************/
static void XMLCALL _NFentryText (void *argPtr, const char *str, int len) {
char *whiteChars = " \t\n";
size_t i, start, end;
bool white;
NFdata_t *data;
// NFobject_p object;
XML_Parser parser = (XML_Parser) argPtr;
data = (NFdata_t *) XML_GetUserData (parser);
if (data->Skip) return;
for (start = 0;start < len; start++) {
for (i = 0;i < strlen (whiteChars); ++i)
if (str [start] == whiteChars [i]) { white = true; break; }
if (white == false) break;
white = false;
}
if (start == len) return;
for (end = len;end > 0; end--) {
for (i = 0;i < strlen (whiteChars); ++i)
if (str [end - 1] == whiteChars [i]) { white = true; break; }
if (white == false) break;
white = false;
}
if (end - start + 1 > data->BufferLen) {
if ((data->Buffer = (char *) realloc (data->Buffer,end - start + 1)) == (char *) NULL) {
CMmsgPrint (CMmsgSysError,"Memory allocation error in %s:%d\n\n",__FILE__,__LINE__);
return;
}
data->BufferLen = end - start + 1;
}
strncpy (data->Buffer, str + start, end - start);
data->Buffer [end - start] = '\0';
// TODO Initialize
// object->Notes = CMstrAppend (object->Notes, data->Buffer, "\n");
}
