HydUtils.h

Go to the documentation of this file.

 
#pragma once
 
// STL functions objetcs
#include <functional>
 
// SfxBase library
#include "include/Sfx_DefineTypes.h"
 
// NOTE
// this code is not used anymore, need to do some clean-up and this file shopuld be parft of the clean-up.
// duplicate code (many version in different files)
 
namespace Sfx 
{
    //
    // Prototypes header
    //
 
    //float64 T( float64 B);
    //float64 A( float64 B, float64 Y);
    //float64 P( float64 A, float64 B);
    //float64 R( float64 A, float64 B);
#if 0   
    constexpr float64 Evaluation_H_fonction_A(float64 A, float64 Z, float64 B = 1.)
    {
        return (A/B + Z);
    }

    constexpr float64 Evaluation_A_fonction_H(float64 H, float64 Z, float64 B = 1.)
    {
        return (H - Z) * B;
    }
#endif //0

    inline constexpr float64 computeVelocity(float64 aU1, float64 aU2) 
    {
        return aU2 / aU1;
    }

    inline constexpr float64 WettedPerimeter( float64 aArea, float64 aWidth = 1.)
    {
        return (2. * aArea) / aWidth + aWidth;
    }

    inline constexpr float64 HydRadius( float64 aArea, float64 aWidth = 1.)
    {
        //WettedPerimeter wWP;
 
        return (aArea / WettedPerimeter(aArea));
    }
    inline constexpr float64 WettedArea(float64 aDepth, float64 aWidth = 1.)
    {
        return aWidth * aDepth;
    }
    inline constexpr float64 SectionWidth(float64 aWidth = 1.) 
    {
     return aWidth;
    }
#if 0
    struct computeVelocity //: std::binary_function<float64, float64, float64>  deprecated
    {
        constexpr float64 operator() ( const float64 aU1, 
                                       const float64 aU2) const
        {
            return aU2/aU1;
        }
    };
 
    // Design Note: 
    // ------------
    //    Function object (functors) that perform calculation 
    //    cross-section ( wetted area, hydraulic radius, width 
    //    at free surface, 
    //  
    //    To be used with iterator while going through a list 
    //    of sections.
    //
    //    Compute width of the section 
    //    process_iterator<list::iterator, Width()> wProc_it_run;
    //
    // "Model of" applicative template mechanism
    //
 
    // _____________________________________________________
    //
    // struct WettedPerimeter : public std::binary_function<float64,float64,float64>
    // result_type operator() ( const first_argument_type aArea, 
    //                          const second_argument_type aWidth) const
    //  use of std::bind2nd to set width = 1.
    //  

    class WettedPerimeter {  
 
    public:
 
        constexpr float64 operator () ( const float64 aArea, const float64 aWidth = 1.) const
        {
            //  Fonction spécifique à un canal rectangulaire de largeur B
            //  Périmètre établi en fonction d'une superficie d'écoulement A
 
            //  float64 Resultat;
 
            //  Resultat = 2.*A/B + B;
 
            //  return (Resultat);
 
            return (2.*aArea)/aWidth + aWidth;
        }
    };
 
    // ____________________________________________________
    //
    // struct HydRadius : public std::binary_function<float64,float64,float64>
    // result_type operator() ( const first_argument_type aArea, 
    //                          const second_argument_type aWidth) const
    //  use of std::bind2nd to set width = 1.
    
    
    class HydRadius {   
 
    public:
 
        constexpr float64 operator () ( const float64 aArea, const float64 aWidth = 1.) const
        {
            //  Fonction spécifique à un canal rectangulaire de largeur B
            //  Périmètre établi en fonction d'une superficie d'écoulement A
 
            //  float64 Resultat;
 
            //  Resultat = A/P(A, B);
 
            //  return (Resultat);
            WettedPerimeter wWP;
 
            return (aArea/wWP( aArea));
        }
    };
 
    //  use of std::bind2nd to set width = 1.
    //
    class WettedArea {   
 
    public:
 
        constexpr float64 operator () ( const float64 aDepth, const float64 aWidth = 1.) const
        {
            //  float64 Resultat;
 
            //  Resultat = B * Y;
 
            //  return (Resultat);
 
            return aWidth*aDepth;
        }
 
        // In a future version ?????
        //      float64 operator () ( const float64 aY, const Section aSection) const
        //      {
        //      }
    };
 
    // _____________________________________________________
    //
    class SectionWidth {
 
    public:
 
        constexpr float64 operator () ( float64 aWidth = 1.) const
        {
            return aWidth;
        }
 
        // In future version, given a section, compute is width at free surface level
        // By default the width is set to 1
        //    float64 operator () ( Section aSection = 1.) const
        //      {
        //          return aB;
        //      }
 
    };
 
    // see EMcNeilUtils 
 
    double P(double A, double B)
    {
        double Resultat;
 
        Resultat = 2. * A / B + B;
 
        return (Resultat);
    }
 
    double R(double A, double B)
    {
        double Resultat;
 
        Resultat = A / P(A, B);
 
        return (Resultat);
    }
 
 
    double A(double B, double Y)
    {
        double Resultat;
 
        Resultat = B * Y;
 
        return (Resultat);
    }
 
    double T(double B)
    {
        double Resultat;
 
        Resultat = B;
 
        return (Resultat);
    }
 
 
    // shall return std::optional<double>
    template<typename Range>
    auto StVenant1D_Incomplete_Flux( Range& aU1, Range& aU2)
    {
        static_assert(0 != std::size(aU1));
        static_assert(std::is_same_v<std::size(aU1), std::size(aU2)>);
        if constexpr ( !std::is_same_v<std::size(aU1), std::size(aU2)>)
        {
            return -1.;
        }
        else
        {
            return (aU2 * aU2) / aU1;
        }
        //static_assert(std::extent_v<decltype(aU1[0],0)> == 10.);
        //static_assert(std::extent_v<decltype(aU1[99],0)> == 1.);
        //static_assert( std::size(aU1) == std::size(decltype(aU2)),   "Incomplete Flux range empty");
        //static_assert( !std::size(aU1) && !std::size(aU2)  , "Incomplete Flux range empty");
        
        //return (aU2 * aU2) / aU1;
 
        //  Fonction de calcul de F2 incomplet (excluant le terme de pression hydrostatique)
 
//      float64 F2;
 
//      F2 = U2 * U2 / U1;
 
//      return (F2);
    }
#endif // 0
}  // End of namespace