Exemple #1
0
int output_open(Project* project)
//
//  Input:   none
//  Output:  returns an error code
//  Purpose: writes basic project data to binary output file.
//
{
    int   j;
    int   m;
    INT4  k;
    REAL4 x;
    REAL8 z;

    // --- open binary output file
    output_openOutFile(project);
    if ( project->ErrorCode ) return project->ErrorCode;

    // --- ignore pollutants if no water quality analsis performed
    if ( project->IgnoreQuality ) project->NumPolluts = 0;
    else project->NumPolluts = project->Nobjects[POLLUT];

    // --- subcatchment results consist of Rainfall, Snowdepth, project->Evap, 
    //     Infil, Runoff, GW Flow, GW Elev, GW Sat, and Washoff
    project->NsubcatchResults = MAX_SUBCATCH_RESULTS - 1 + project->NumPolluts;

    // --- node results consist of Depth, Head, Volume, Lateral Inflow,
    //     Total Inflow, Overflow and Quality
    project->NnodeResults = MAX_NODE_RESULTS - 1 + project->NumPolluts;

    // --- link results consist of Depth, Flow, Velocity, Froude No.,
    //     Capacity and Quality
    project->NlinkResults = MAX_LINK_RESULTS - 1 + project->NumPolluts;

    // --- get number of objects reported on
    project->NumSubcatch = 0;
    project->NumNodes = 0;
    project->NumLinks = 0;
    for (j=0; j<project->Nobjects[SUBCATCH]; j++) if (project->Subcatch[j].rptFlag) project->NumSubcatch++;
    for (j=0; j<project->Nobjects[NODE]; j++) if (project->Node[j].rptFlag) project->NumNodes++;
    for (j=0; j<project->Nobjects[LINK]; j++) if (project->Link[j].rptFlag) project->NumLinks++;

    project->BytesPerPeriod = sizeof(REAL8)
        + project->NumSubcatch * project->NsubcatchResults * sizeof(REAL4)
        + project->NumNodes * project->NnodeResults * sizeof(REAL4)
        + project->NumLinks * project->NlinkResults * sizeof(REAL4)
        + MAX_SYS_RESULTS * sizeof(REAL4);
    project->Nperiods = 0;

    project->SubcatchResults = NULL;
    project->NodeResults = NULL;
    project->LinkResults = NULL;
    project->SubcatchResults = (REAL4 *) calloc(project->NsubcatchResults, sizeof(REAL4));
    project->NodeResults = (REAL4 *) calloc(project->NnodeResults, sizeof(REAL4));
    project->LinkResults = (REAL4 *) calloc(project->NlinkResults, sizeof(REAL4));
    if ( !project->SubcatchResults || !project->NodeResults || !project->LinkResults )
    {
        report_writeErrorMsg(project,ERR_MEMORY, "");
        return project->ErrorCode;
    }

    fseek(project->Fout.file, 0, SEEK_SET);
    k = MAGICNUMBER;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);   // Magic number
    k = VERSION;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);   // Version number
    k = project->FlowUnits;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);   // Flow units
    k = project->NumSubcatch;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);   // # subcatchments
    k = project->NumNodes;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);   // # nodes
    k = project->NumLinks;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);   // # links
    k = project->NumPolluts;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);   // # pollutants

    // --- save ID names of subcatchments, nodes, links, & pollutants 
    project->IDStartPos = ftell(project->Fout.file);
    for (j=0; j<project->Nobjects[SUBCATCH]; j++)
    {
        if ( project->Subcatch[j].rptFlag ) output_saveID(project->Subcatch[j].ID, project->Fout.file);
    }
    for (j=0; j<project->Nobjects[NODE];     j++)
    {
        if ( project->Node[j].rptFlag ) output_saveID(project->Node[j].ID, project->Fout.file);
    }
    for (j=0; j<project->Nobjects[LINK];     j++)
    {
        if ( project->Link[j].rptFlag ) output_saveID(project->Link[j].ID, project->Fout.file);
    }
    for (j=0; j<project->NumPolluts; j++) output_saveID(project->Pollut[j].ID, project->Fout.file);

    // --- save codes of pollutant concentration units
    for (j=0; j<project->NumPolluts; j++)
    {
        k = project->Pollut[j].units;
        fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    }

    project->InputStartPos = ftell(project->Fout.file);

    // --- save subcatchment area
    k = 1;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = INPUT_AREA;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    for (j=0; j<project->Nobjects[SUBCATCH]; j++)
    {
         if ( !project->Subcatch[j].rptFlag ) continue;
         project->SubcatchResults[0] = (REAL4)(project->Subcatch[j].area * UCF(project,LANDAREA));
         fwrite(&project->SubcatchResults[0], sizeof(REAL4), 1, project->Fout.file);
    }

    // --- save node type, invert, & max. depth
    k = 3;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = INPUT_TYPE_CODE;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = INPUT_INVERT;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = INPUT_MAX_DEPTH;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    for (j=0; j<project->Nobjects[NODE]; j++)
    {
        if ( !project->Node[j].rptFlag ) continue;
        k = project->Node[j].type;
        project->NodeResults[0] = (REAL4)(project->Node[j].invertElev * UCF(project,LENGTH));
        project->NodeResults[1] = (REAL4)(project->Node[j].fullDepth * UCF(project,LENGTH));
        fwrite(&k, sizeof(INT4), 1, project->Fout.file);
        fwrite(project->NodeResults, sizeof(REAL4), 2, project->Fout.file);
    }

    // --- save link type, offsets, max. depth, & length
    k = 5;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = INPUT_TYPE_CODE;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = INPUT_OFFSET;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = INPUT_OFFSET;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = INPUT_MAX_DEPTH;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = INPUT_LENGTH;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);

    for (j=0; j<project->Nobjects[LINK]; j++)
    {
        if ( !project->Link[j].rptFlag ) continue;
        k = project->Link[j].type;
        if ( k == PUMP )
        {
            for (m=0; m<4; m++) project->LinkResults[m] = 0.0f;
        }
        else
        {
            project->LinkResults[0] = (REAL4)(project->Link[j].offset1 * UCF(project,LENGTH));
            project->LinkResults[1] = (REAL4)(project->Link[j].offset2 * UCF(project,LENGTH));
            if ( project->Link[j].direction < 0 )
            {
                x = project->LinkResults[0];
                project->LinkResults[0] = project->LinkResults[1];
                project->LinkResults[1] = x;
            }
            if ( k == OUTLET ) project->LinkResults[2] = 0.0f;
            else project->LinkResults[2] = (REAL4)(project->Link[j].xsect.yFull * UCF(project,LENGTH));
            if ( k == CONDUIT )
            {
                m = project->Link[j].subIndex;
                project->LinkResults[3] = (REAL4)(project->Conduit[m].length * UCF(project,LENGTH));
            }
            else project->LinkResults[3] = 0.0f;
        }
        fwrite(&k, sizeof(INT4), 1, project->Fout.file);
        fwrite(project->LinkResults, sizeof(REAL4), 4, project->Fout.file);
    }

    // --- save number & codes of subcatchment result variables
    k = project->NsubcatchResults;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = SUBCATCH_RAINFALL;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = SUBCATCH_SNOWDEPTH;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = SUBCATCH_EVAP;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = SUBCATCH_INFIL;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = SUBCATCH_RUNOFF;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = SUBCATCH_GW_FLOW;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = SUBCATCH_GW_ELEV;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = SUBCATCH_SOIL_MOIST;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);

    for (j=0; j<project->NumPolluts; j++) 
    {
        k = SUBCATCH_WASHOFF + j;
        fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    }

    // --- save number & codes of node result variables
    k = project->NnodeResults;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = NODE_DEPTH;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = NODE_HEAD;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = NODE_VOLUME;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = NODE_LATFLOW;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = NODE_INFLOW;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = NODE_OVERFLOW;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    for (j=0; j<project->NumPolluts; j++)
    {
        k = NODE_QUAL + j;
        fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    }

    // --- save number & codes of link result variables
    k = project->NlinkResults;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = LINK_FLOW;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = LINK_DEPTH;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = LINK_VELOCITY;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = LINK_VOLUME;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    k = LINK_CAPACITY;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    for (j=0; j<project->NumPolluts; j++)
    {
        k = LINK_QUAL + j;
        fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    }

    // --- save number & codes of system result variables
    k = MAX_SYS_RESULTS;
    fwrite(&k, sizeof(INT4), 1, project->Fout.file);
    for (k=0; k<MAX_SYS_RESULTS; k++) fwrite(&k, sizeof(INT4), 1, project->Fout.file);

    // --- save starting report date & report step
    //     (if reporting start date > simulation start date then
    //      make saved starting report date one reporting period
    //      prior to the date of the first reported result)
    z = (double)project->ReportStep/86400.0;
    if ( project->StartDateTime + z > project->ReportStart ) z = project->StartDateTime;
    else
    {
        z = floor((project->ReportStart - project->StartDateTime)/z) - 1.0;
        z = project->StartDateTime + z*(double)project->ReportStep/86400.0;
    }
    fwrite(&z, sizeof(REAL8), 1, project->Fout.file);
    k = project->ReportStep;
    if ( fwrite(&k, sizeof(INT4), 1, project->Fout.file) < 1)
    {
        report_writeErrorMsg(project,ERR_OUT_WRITE, "");
        return project->ErrorCode;
    }
    project->OutputStartPos = ftell(project->Fout.file);
    if ( project->Fout.mode == SCRATCH_FILE ) output_checkFileSize(project);
    return project->ErrorCode;
}
int output_open()
//
//  Input:   none
//  Output:  returns an error code
//  Purpose: writes basic project data to binary output file.
//
{
    int   nPolluts = Nobjects[POLLUT];
    int   j;
    int   m;
    INT4  k;
    REAL4 x;
    REAL8 z;

    // --- open binary output file
    output_openOutFile();
    if ( ErrorCode ) return ErrorCode;

    // --- subcatchment results consist of Rainfall, Snowdepth, Losses, Runoff, 
    //     GW Flow, GW Elev, and Washoff
    NsubcatchResults = MAX_SUBCATCH_RESULTS - 1 + nPolluts;

    // --- node results consist of Depth, Head, Volume, Lateral Inflow,
    //     Total Inflow, Overflow and Quality
    NnodeResults = MAX_NODE_RESULTS - 1 + nPolluts;

    // --- link results consist of Depth, Flow, Velocity, Froude No.,
    //     Capacity and Quality
    NlinkResults = MAX_LINK_RESULTS - 1 + nPolluts;

    // --- get number of objects reported on                                   //(5.0.014 - LR)
    NumSubcatch = 0;
    NumNodes = 0;
    NumLinks = 0;
    for (j=0; j<Nobjects[SUBCATCH]; j++) if (Subcatch[j].rptFlag) NumSubcatch++;
    for (j=0; j<Nobjects[NODE]; j++) if (Node[j].rptFlag) NumNodes++;
    for (j=0; j<Nobjects[LINK]; j++) if (Link[j].rptFlag) NumLinks++;


    BytesPerPeriod = sizeof(REAL8)                                             //(5.0.014 - LR)
        + NumSubcatch * NsubcatchResults * sizeof(REAL4)                       //(5.0.014 - LR)
        + NumNodes * NnodeResults * sizeof(REAL4)                              //(5.0.014 - LR)
        + NumLinks * NlinkResults * sizeof(REAL4)                              //(5.0.014 - LR)
        + MAX_SYS_RESULTS * sizeof(REAL4);
    Nperiods = 0;

    SubcatchResults = NULL;
    NodeResults = NULL;
    LinkResults = NULL;
    SubcatchResults = (REAL4 *) calloc(NsubcatchResults, sizeof(REAL4));
    NodeResults = (REAL4 *) calloc(NnodeResults, sizeof(REAL4));
    LinkResults = (REAL4 *) calloc(NlinkResults, sizeof(REAL4));
    if ( !SubcatchResults || !NodeResults || !LinkResults )
    {
        report_writeErrorMsg(ERR_MEMORY, "");
        return ErrorCode;
    }

    fseek(Fout.file, 0, SEEK_SET);
    k = MAGICNUMBER;
    fwrite(&k, sizeof(INT4), 1, Fout.file);   // Magic number
    k = VERSION;
    fwrite(&k, sizeof(INT4), 1, Fout.file);   // Version number
    k = FlowUnits;
    fwrite(&k, sizeof(INT4), 1, Fout.file);   // Flow units
    k = NumSubcatch;                                                           //(5.0.014 - LR)
    fwrite(&k, sizeof(INT4), 1, Fout.file);   // # subcatchments
    k = NumNodes;                                                              //(5.0.014 - LR)
    fwrite(&k, sizeof(INT4), 1, Fout.file);   // # nodes
    k = NumLinks;                                                              //(5.0.014 - LR) 
    fwrite(&k, sizeof(INT4), 1, Fout.file);   // # links
    k = Nobjects[POLLUT];
    fwrite(&k, sizeof(INT4), 1, Fout.file);   // # pollutants

    // --- save ID names of subcatchments, nodes, links, & pollutants          //(5.0.014 - LR)
    IDStartPos = ftell(Fout.file);
    for (j=0; j<Nobjects[SUBCATCH]; j++)
    {
        if ( Subcatch[j].rptFlag ) output_saveID(Subcatch[j].ID, Fout.file);
    }
    for (j=0; j<Nobjects[NODE];     j++)
    {
        if ( Node[j].rptFlag ) output_saveID(Node[j].ID, Fout.file);
    }
    for (j=0; j<Nobjects[LINK];     j++)
    {
        if ( Link[j].rptFlag ) output_saveID(Link[j].ID, Fout.file);
    }
    for (j=0; j<Nobjects[POLLUT];   j++) output_saveID(Pollut[j].ID, Fout.file);

    // --- save codes of pollutant concentration units
    for (j=0; j<Nobjects[POLLUT]; j++)
    {
        k = Pollut[j].units;
        fwrite(&k, sizeof(INT4), 1, Fout.file);
    }

    InputStartPos = ftell(Fout.file);

    // --- save subcatchment area
    k = 1;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = INPUT_AREA;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    for (j=0; j<Nobjects[SUBCATCH]; j++)
    {
         if ( !Subcatch[j].rptFlag ) continue;                                 //(5.0.014 - LR)
         SubcatchResults[0] = (REAL4)(Subcatch[j].area * UCF(LANDAREA));
         fwrite(&SubcatchResults[0], sizeof(REAL4), 1, Fout.file);
    }

    // --- save node type, invert, & max. depth
    k = 3;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = INPUT_TYPE_CODE;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = INPUT_INVERT;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = INPUT_MAX_DEPTH;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    for (j=0; j<Nobjects[NODE]; j++)
    {
        if ( !Node[j].rptFlag ) continue;                                      //(5.0.014 - LR)
        k = Node[j].type;
        NodeResults[0] = (REAL4)(Node[j].invertElev * UCF(LENGTH));
        NodeResults[1] = (REAL4)(Node[j].fullDepth * UCF(LENGTH));
        fwrite(&k, sizeof(INT4), 1, Fout.file);
        fwrite(NodeResults, sizeof(REAL4), 2, Fout.file);
    }

    // --- save link type, offsets, max. depth, & length
    k = 5;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = INPUT_TYPE_CODE;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = INPUT_OFFSET;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = INPUT_OFFSET;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = INPUT_MAX_DEPTH;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = INPUT_LENGTH;
    fwrite(&k, sizeof(INT4), 1, Fout.file);

    for (j=0; j<Nobjects[LINK]; j++)
    {
        if ( !Link[j].rptFlag ) continue;                                      //(5.0.014 - LR)
        k = Link[j].type;
        if ( k == PUMP )
        {
            for (m=0; m<4; m++) LinkResults[m] = 0.0f;
        }
        else
        {
            LinkResults[0] = (REAL4)(Link[j].offset1 * UCF(LENGTH));           //(5.0.012 - LR)
            LinkResults[1] = (REAL4)(Link[j].offset2 * UCF(LENGTH));           //(5.0.012 - LR)
            if ( Link[j].direction < 0 )
            {
                x = LinkResults[0];
                LinkResults[0] = LinkResults[1];
                LinkResults[1] = x;
            }
            if ( k == OUTLET ) LinkResults[2] = 0.0f;
            else LinkResults[2] = (REAL4)(Link[j].xsect.yFull * UCF(LENGTH));
            if ( k == CONDUIT )
            {
                m = Link[j].subIndex;
                LinkResults[3] = (REAL4)(Conduit[m].length * UCF(LENGTH));
            }
            else LinkResults[3] = 0.0f;
        }
        fwrite(&k, sizeof(INT4), 1, Fout.file);
        fwrite(LinkResults, sizeof(REAL4), 4, Fout.file);
    }

    // --- save number & codes of subcatchment result variables
    k = NsubcatchResults;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = SUBCATCH_RAINFALL;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = SUBCATCH_SNOWDEPTH;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = SUBCATCH_LOSSES;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = SUBCATCH_RUNOFF;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = SUBCATCH_GW_FLOW;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = SUBCATCH_GW_ELEV;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    for (j=0; j<nPolluts; j++)
    {
        k = SUBCATCH_WASHOFF + j;
        fwrite(&k, sizeof(INT4), 1, Fout.file);
    }

    // --- save number & codes of node result variables
    k = NnodeResults;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = NODE_DEPTH;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = NODE_HEAD;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = NODE_VOLUME;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = NODE_LATFLOW;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = NODE_INFLOW;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = NODE_OVERFLOW;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    for (j=0; j<nPolluts; j++)
    {
        k = NODE_QUAL + j;
        fwrite(&k, sizeof(INT4), 1, Fout.file);
    }

    // --- save number & codes of link result variables
    k = NlinkResults;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = LINK_FLOW;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = LINK_DEPTH;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = LINK_VELOCITY;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = LINK_FROUDE;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    k = LINK_CAPACITY;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    for (j=0; j<nPolluts; j++)
    {
        k = LINK_QUAL + j;
        fwrite(&k, sizeof(INT4), 1, Fout.file);
    }

    // --- save number & codes of system result variables
    k = MAX_SYS_RESULTS;
    fwrite(&k, sizeof(INT4), 1, Fout.file);
    for (k=0; k<MAX_SYS_RESULTS; k++) fwrite(&k, sizeof(INT4), 1, Fout.file);

    // --- save starting report date & report step
    //     (if reporting start date > simulation start date then               //(5.0.014 - LR)
    //      make saved starting report date one reporting period               //(5.0.014 - LR)
    //      prior to the date of the first reported result)                    //(5.0.014 - LR)
    z = (double)ReportStep/86400.0;                                            //(5.0.014 - LR)
    if ( StartDateTime + z > ReportStart ) z = StartDateTime;                  //(5.0.014 - LR)
    else                                                                       //(5.0.014 - LR)
    {                                                                          //(5.0.014 - LR)
        z = floor((ReportStart - StartDateTime)/z) - 1.0;                      //(5.0.014 - LR)
        z = StartDateTime + z*(double)ReportStep/86400.0;                      //(5.0.014 - LR)
    }                                                                          //(5.0.014 - LR)
    fwrite(&z, sizeof(REAL8), 1, Fout.file);
    k = ReportStep;
    if ( fwrite(&k, sizeof(INT4), 1, Fout.file) < 1)
    {
        report_writeErrorMsg(ERR_OUT_WRITE, "");
        return ErrorCode;
    }
    OutputStartPos = ftell(Fout.file);
    if ( Fout.mode == SCRATCH_FILE ) output_checkFileSize();                   //(5.0.015 - LR)
    return ErrorCode;
}