rate_table.c

Go to the documentation of this file.

#include "rate_table.h"
#include <math.h>
 
/*****************************STAGE TO FLOW*********************************/
/*------------------------------------------------------------------------- 
   This function finds where the given stage is in the given 
   rating table and then calls the appropriate function to do the actual
   conversion.
              Precondition:  Given a rating table structure,
                             and a stage
              Postcondition:  Converts the stage to flow,
                              gives a warning flag if above or below
--------------------------------------------------------------------------*/
int GetFlow(RatingTable A, double Stage, int *Warning)
{
    int Flow,
        i;
        
    double 
          ShiftStage,
          Level;
 
    ShiftStage = Stage;        /*  + A.RatShf[0]; took shift out! */     
    
    if( ShiftStage < A.HMin)                
    {
        Flow = BelowStage2Flow( A, ShiftStage);
        return Flow;
        *Warning = 1;
    }
 
    if( ShiftStage > A.HMax)
    {
        Flow = AboveStage2Flow( A, ShiftStage);
        return Flow;
        *Warning = 1;
    }
 
    for( i = 0; i <= A.AryMax; i++)
    {
        Level = A.RatStg[i] - ShiftStage;
        if( Level == 0)
        {
            Flow = ExactStage2Flow( A, i);
            return Flow;
            *Warning = 0;
        }
    
        if( Level > 0)
        {
            Flow = InterpolateStage2Flow( A, ShiftStage, i);
            return Flow;
            *Warning = 0;
        }
    }
}
 
 
/*-------------------------------------------------------------------------
  This function converts stage to flow when the given stage is below the
  given rating table.
-------------------------------------------------------------------------*/
int BelowStage2Flow( RatingTable A, double ShiftStage)
{
    double Slope = A.QMin / A.HMin;
    double flow = ShiftStage * Slope;
    int Flow = flow;
    return Flow;
}
 
 
/*-------------------------------------------------------------------------
  This function converts stage to flow when the given stage is above the
  given rating table.
---------------------------------------------------------------------------*/
int AboveStage2Flow( RatingTable A, double ShiftStage)
{
    double 
        flow,
        Del,
        Slope,
        Var1;
    int
        Flow;
 
    Del = log10(A.HMax) - log10(A.RatStg[A.AryMax - 1]);
    Slope = (log10(A.QMax) - log10(A.RatQ[A.AryMax - 1])) / Del;
    Var1 = log10(A.QMax);
    flow = Var1 + (Slope * (log10(ShiftStage) - log10(A.HMax)));
    flow = pow(10.0,flow);
    Flow = flow;
    return Flow;
}
 
 
/*-----------------------------------------------------------------------
  This function converts stage to flow when the given stage is exactly
  one of the stages in the given rating table.
-------------------------------------------------------------------------*/
int ExactStage2Flow( RatingTable A, int i)
{
    double flow = A.RatQ[i];
    int Flow = flow;
    return Flow;
}
 
 
/*------------------------------------------------------------------------
  This function converts stage to flow when the given stage is in between
  the stages in the given rating table.
--------------------------------------------------------------------------*/
int InterpolateStage2Flow( RatingTable A, double ShiftStage, int i)
{
    double
        flow,
        Del,
        Slope,
        Var2;
    int
        Flow,
        High = i,
        Low = i - 1;
 
    Del = log10(A.RatStg[High]) - log10(A.RatStg[Low]);
        Slope = (log10(A.RatQ[High]) - log10(A.RatQ[Low])) / Del;
    Var2 = log10(A.RatQ[Low]);
    flow = Var2 + (Slope * (log10(ShiftStage) - log10(A.RatStg[Low])));
    flow = pow(10.0,flow);
        Flow = flow;
 
    return Flow;
}
 
/********************************FLOW TO STAGE*****************************/
 
/*------------------------------------------------------------------------- 
   This function finds where the given flow is in the given 
   rating table and then calls the appropriate function to do the actual
   conversion.
              Precondition:  Given a rating table structure,
                             and a flow
              Postcondition:  Converts the flow to stage,
                              gives a warning flag if above or below
--------------------------------------------------------------------------*/
double GetStage(RatingTable A, int Flow, int *Warning)
{
    int i;
        
    double 
          Stage,
          Level;     
    
    if( Flow < A.QMin)              
    {
        Stage = BelowFlow2Stage( A, Flow);
        return Stage;
        *Warning = 1;
    }
 
    if( Flow > A.QMax)
    {
        Stage = AboveFlow2Stage( A, Flow);
        return Stage;
        *Warning = 1;
    }
 
    for( i = 0; i <= A.AryMax; i++)
    {
        Level = A.RatQ[i] - Flow;
        if( Level == 0)
        {
            Stage = ExactFlow2Stage( A, i);
            return Stage;
            *Warning = 0;
        }
    
        if( Level > 0)
        {
            Stage = InterpolateFlow2Stage( A, Flow, i);
            return Stage;
            *Warning = 0;
        }
    }
}
 
 
    
/*-------------------------------------------------------------------------
  This function converts flow to stage when the given flow is below the
  given rating table.
-------------------------------------------------------------------------*/
double BelowFlow2Stage( RatingTable A, int Flow)
{
        double flow = Flow;
    double Slope = A.HMin / A.QMin;
    double Stage = flow * Slope;
    double ShiftStage = Stage;     /* - A.RatStg[0]; took shift out*/
    return ShiftStage;
}
    
 
    
/*-------------------------------------------------------------------------
  This function converts flow to stage when the given flow is above the
  given rating table.
---------------------------------------------------------------------------*/
double AboveFlow2Stage( RatingTable A, int Flow)
{
    double 
        flow,
        Del,
        Slope,
        Var1,
            Stage,
            ShiftStage;
    flow = Flow;
 
    Del = log10(A.QMax) - log10(A.RatQ[A.AryMax - 1]);
    Slope = (log10(A.HMax) - log10(A.RatStg[A.AryMax - 1])) / Del;
    Var1 = log10(A.HMax);
    Stage = Var1 + (Slope * (log10(flow) - log10(A.QMax)));
    ShiftStage = pow(10.0,Stage);     /* - A.RatShf[0]; took shift out!*/
    return ShiftStage;
}
 
 
 
 
 
/*-----------------------------------------------------------------------
  This function converts flow to stage when the given flow is exactly
  one of the flows in the given rating table.
-------------------------------------------------------------------------*/
double ExactFlow2Stage( RatingTable A, int i)
{
    double Stage = A.RatStg[i];
        double ShiftStage = Stage;      /* - A.RatShf[0]; took out shift!*/
    return ShiftStage;
}
 
 
 
/*------------------------------------------------------------------------
  This function converts flow to stage when the given flow is in between
  the flows in the given rating table.
--------------------------------------------------------------------------*/
double InterpolateFlow2Stage( RatingTable A, int Flow, int i)
{
    double
        flow,
        Del,
        Slope,
        Var2,
            Stage,
            ShiftStage;
    int
        High = i,
        Low = i - 1;
    flow = Flow;
 
    Del = log10(A.RatQ[High]) - log10(A.RatQ[Low]);
 
        Slope = (log10(A.RatStg[High]) - log10(A.RatStg[Low])) / Del;
    Var2 = log10(A.RatStg[Low]);
    Stage = Var2 + (Slope * (log10(flow) - log10(A.RatQ[Low])));
    ShiftStage = pow(10.0,Stage);     /* - A.RatShf[0];took shift out!*/
    return ShiftStage;
}