cl_GM_HelmholtzTransport_LemmonJacobsen.hpp

Go to the documentation of this file.

/*
 * BELFEM -- The Berkeley Lab Finite Element Framework
 * Copyright (c) 2026, The Regents of the University of California,
 * through Lawrence Berkeley National Laboratory (subject to receipt of any required
 * approvals from the U.S. Dept. of Energy).  All rights reserved.
 *
 * Developers: Christian Messe, Gregory Giard
 *
 * See the top-level LICENSE file for the complete license and disclaimer.
 */
 
#ifndef BELFEM_CL_GM_HELMHOLTZTRANSPORT_LEMMONJACOBSEN_HPP
#define BELFEM_CL_GM_HELMHOLTZTRANSPORT_LEMMONJACOBSEN_HPP
 
#include "typedefs.hpp"
#include "cl_Vector.hpp"
#include "cl_Bitset.hpp"
#include "en_Helmholtz.hpp"
#include "cl_GM_HelmholtzTransport.hpp"
 
#define BELFEM_LJTRANS_T          0
#define BELFEM_LJTRANS_P          1
#define BELFEM_LJTRANS_V          2
#define BELFEM_LJTRANS_TAU        3
#define BELFEM_LJTRANS_DELTA      4
#define BELFEM_LJTRANS_ETA0       5
#define BELFEM_LJTRANS_ETA        6
#define BELFEM_LJTRANS_LAMBDA     7
#define BELFEM_LJTRANS_NUMVALS    8
 
namespace belfem
{
    namespace gasmodels
    {
//----------------------------------------------------------------------------

        class HelmholtzTransport_LemmonJacobsen : public HelmholtzTransport
        {
//----------------------------------------------------------------------------
        private:
//----------------------------------------------------------------------------

            const HelmholtzModel mModel ;

            real mTcrit ;

            real mPcrit ;

            real mRhocrit ;

            real mM ;

            real mEpsilonKb ;

            real mSigma ;

            Vector< real > mB ;

            Vector< real > mEtaN ;
            Vector< real > mEtaT ;
            Vector< real > mEtaD ;
            Vector< real > mEtaL ;

            real mLambdaN1 ;
            real mLambdaN2 ;
            real mLambdaT2 ;
            real mLambdaN3 ;
            real mLambdaT3 ;

            Vector< real > mLambdaN ;
            Vector< real > mLambdaT ;
            Vector< real > mLambdaD ;
            Vector< real > mLambdaL ;

            real mXi0 ;      
            real mGammaC ;   
            real mQd ;       
            real mTref ;     

            real mConstEta0 ;

            mutable real mVals[ BELFEM_LJTRANS_NUMVALS ] = { 0.0 };
            mutable Bitset< BELFEM_LJTRANS_NUMVALS > mBits;
 
//----------------------------------------------------------------------------
        public:
//----------------------------------------------------------------------------

            HelmholtzTransport_LemmonJacobsen(
                    Gas & aParent,
                    const HelmholtzModel aModel );
 
            ~HelmholtzTransport_LemmonJacobsen() = default ;
 
//----------------------------------------------------------------------------

            real
            mu( const real T, const real p ) const ;
 
//----------------------------------------------------------------------------

            real
            lambda( const real T, const real p ) const ;
 
//----------------------------------------------------------------------------
        private:
//----------------------------------------------------------------------------

            void
            init_tables() ;
 
//----------------------------------------------------------------------------

            real
            omega( const real T ) const ;
 
//----------------------------------------------------------------------------

            real
            eta_0( const real T ) const ;
 
//----------------------------------------------------------------------------

            real
            eta_r() const ;
 
//----------------------------------------------------------------------------

            real
            lambda_0( const real T ) const ;
 
//----------------------------------------------------------------------------

            real
            lambda_r() const ;
 
//----------------------------------------------------------------------------

            real
            lambda_c( const real T, const real p ) const ;
 
//----------------------------------------------------------------------------

            real
            chi( const real T, const real v ) const ;
 
//----------------------------------------------------------------------------
 
            void
            update_Tp( const real T, const real p ) const ;
 
            bool
            test( const index_t aIndex ) const ;
 
            void
            set( const index_t aIndex, const real aValue ) const ;
 
            const real &
            get( const index_t aIndex ) const ;
 
//----------------------------------------------------------------------------
        } ;
 
//----------------------------------------------------------------------------
 
        inline bool
        HelmholtzTransport_LemmonJacobsen::test( const index_t aIndex ) const
        {
            BELFEM_ASSERT( aIndex < BELFEM_LJTRANS_NUMVALS,
                          "Invalid Lemmon-Jacobsen state index: %u",
                          ( unsigned int ) aIndex );
 
            return mBits.test( aIndex );
        }
 
//----------------------------------------------------------------------------
 
        inline void
        HelmholtzTransport_LemmonJacobsen::set(
                const index_t aIndex, const real aValue ) const
        {
            BELFEM_ASSERT( aIndex < BELFEM_LJTRANS_NUMVALS,
                          "Invalid Lemmon-Jacobsen state index: %u",
                          ( unsigned int ) aIndex );
 
            mVals[ aIndex ] = aValue;
            mBits.set( aIndex );
        }
 
//----------------------------------------------------------------------------
 
        inline const real &
        HelmholtzTransport_LemmonJacobsen::get( const index_t aIndex ) const
        {
            BELFEM_ASSERT( aIndex < BELFEM_LJTRANS_NUMVALS,
                          "Invalid Lemmon-Jacobsen state index: %u",
                          ( unsigned int ) aIndex );
 
            return mVals[ aIndex ];
        }
 
//----------------------------------------------------------------------------
 
        inline void
        HelmholtzTransport_LemmonJacobsen::update_Tp(
                const real T, const real p ) const
        {
            BELFEM_ASSERT( T > 0, "Invalid temperature" );
            BELFEM_ASSERT( p > 0, "Invalid pressure" );
 
            if(    T != mVals[ BELFEM_LJTRANS_T ]
                || p != mVals[ BELFEM_LJTRANS_P ] )
            {
                mBits.reset();
 
                mVals[ BELFEM_LJTRANS_V ]     = mEoS.v( T, p );
 
                mVals[ BELFEM_LJTRANS_T ]     = T ;
                mVals[ BELFEM_LJTRANS_P ]     = p ;
                mVals[ BELFEM_LJTRANS_TAU ]   = mTcrit / T ;
                mVals[ BELFEM_LJTRANS_DELTA ] =
                        1.0 / ( mVals[ BELFEM_LJTRANS_V ] * mRhocrit ) ;
 
                mBits.set( BELFEM_LJTRANS_T );
                mBits.set( BELFEM_LJTRANS_P );
                mBits.set( BELFEM_LJTRANS_V );
                mBits.set( BELFEM_LJTRANS_TAU );
                mBits.set( BELFEM_LJTRANS_DELTA );
            }
        }
 
//----------------------------------------------------------------------------
    }
}
#endif //BELFEM_CL_GM_HELMHOLTZTRANSPORT_LEMMONJACOBSEN_HPP