EulerFlux_test.cpp

Go to the documentation of this file.

 
#include "numeric/EulerFlux.h"
 
#include <gtest/gtest.h>
 
#include <cmath>
 
namespace
{
 
    using rizer::numeric::faceVelocityFlux;
    using rizer::numeric::maxWaveSpeed;
    using rizer::numeric::momentumGeometricSourceIntegral;
    using rizer::numeric::rusanovEnergyFlux;
    using rizer::numeric::rusanovMomentumFlux;
    using rizer::numeric::rusanovScalarFlux;
 
    // ------------------------------------------------------------------------------ //
    //   maxWaveSpeed                                                                 //
    // ------------------------------------------------------------------------------ //

    TEST(MaxWaveSpeed, TakesTheLargerOfTheTwoSides)
    {
        EXPECT_DOUBLE_EQ(maxWaveSpeed(10.0, 300.0, 20.0, 340.0), 360.0);
        EXPECT_DOUBLE_EQ(maxWaveSpeed(50.0, 400.0, 20.0, 340.0), 450.0);
    }

    TEST(MaxWaveSpeed, UsesTheMagnitudeOfTheVelocity)
    {
        EXPECT_DOUBLE_EQ(maxWaveSpeed(-100.0, 300.0, 0.0, 300.0), 400.0);
        EXPECT_DOUBLE_EQ(maxWaveSpeed(-100.0, 300.0, 0.0, 300.0),
                         maxWaveSpeed(100.0, 300.0, 0.0, 300.0));
    }

    TEST(MaxWaveSpeed, IsTheSoundSpeedAtRest)
    {
        EXPECT_DOUBLE_EQ(maxWaveSpeed(0.0, 347.2, 0.0, 347.2), 347.2);
    }
 
    // ------------------------------------------------------------------------------ //
    //   rusanovScalarFlux                                                            //
    // ------------------------------------------------------------------------------ //

    TEST(RusanovScalarFlux, ScalesTheWholeBlendByTheFaceRadius)
    {
        const double one = rusanovScalarFlux(1.0, 2.0, 3.0, 10.0, 20.0, 400.0);
        const double seven = rusanovScalarFlux(7.0, 2.0, 3.0, 10.0, 20.0, 400.0);
        EXPECT_DOUBLE_EQ(seven, 7.0 * one);
        // 0.5*(10*2 + 20*3) - 0.5*400*(3 - 2) = 40 - 200
        EXPECT_DOUBLE_EQ(one, -160.0);
    }

    TEST(RusanovScalarFlux, VanishesOnAZeroAreaFace)
    {
        EXPECT_DOUBLE_EQ(rusanovScalarFlux(0.0, 2.0, 3.0, 10.0, 20.0, 400.0), 0.0);
    }

    TEST(RusanovScalarFlux, HasNoDissipationWithoutAJump)
    {
        EXPECT_DOUBLE_EQ(rusanovScalarFlux(2.0, 5.0, 5.0, 10.0, 30.0, 400.0),
                         2.0 * 0.5 * (10.0 * 5.0 + 30.0 * 5.0));
    }

    TEST(RusanovScalarFlux, DissipationOpposesTheJump)
    {
        const double rising = rusanovScalarFlux(1.0, 1.0, 2.0, 0.0, 0.0, 400.0);
        const double falling = rusanovScalarFlux(1.0, 2.0, 1.0, 0.0, 0.0, 400.0);
        EXPECT_LT(rising, 0.0);
        EXPECT_GT(falling, 0.0);
        EXPECT_DOUBLE_EQ(rising, -falling);
    }
 
    // ------------------------------------------------------------------------------ //
    //   rusanovMomentumFlux                                                          //
    // ------------------------------------------------------------------------------ //

    TEST(RusanovMomentumFlux, CarriesThePressureTerm)
    {
        // At rest the advective part is zero and only p survives.
        EXPECT_DOUBLE_EQ(
            rusanovMomentumFlux(2.0, 1.2, 0.0, 1.0e5, 1.2, 0.0, 3.0e5, 400.0),
            2.0 * 0.5 * (1.0e5 + 3.0e5));
    }

    TEST(RusanovMomentumFlux, MatchesTheClosedFormWithFlowAndPressure)
    {
        const double expected =
            3.0 * (0.5 * ((2.0 * 10.0 * 10.0 + 100.0) + (4.0 * 20.0 * 20.0 + 500.0)) -
                   0.5 * 450.0 * (4.0 * 20.0 - 2.0 * 10.0));
        EXPECT_DOUBLE_EQ(
            rusanovMomentumFlux(3.0, 2.0, 10.0, 100.0, 4.0, 20.0, 500.0, 450.0),
            expected);
    }

    TEST(RusanovMomentumFlux, DissipatesConservedMomentumNotVelocity)
    {
        // rho*u = 20 on both sides, so the dissipation must vanish even though
        // the velocities differ by a factor of four.
        const double flux =
            rusanovMomentumFlux(1.0, 2.0, 10.0, 0.0, 8.0, 2.5, 0.0, 400.0);
        EXPECT_DOUBLE_EQ(flux, 0.5 * (2.0 * 100.0 + 8.0 * 6.25));
    }
 
    // ------------------------------------------------------------------------------ //
    //   rusanovEnergyFlux                                                            //
    // ------------------------------------------------------------------------------ //

    TEST(RusanovEnergyFlux, AdvectsEnthalpyButDissipatesEnergy)
    {
        const double expected =
            2.0 * (0.5 * (10.0 * (1000.0 + 300.0) + 30.0 * (2000.0 + 700.0)) -
                   0.5 * 500.0 * (2000.0 - 1000.0));
        EXPECT_DOUBLE_EQ(
            rusanovEnergyFlux(2.0, 1000.0, 300.0, 10.0, 2000.0, 700.0, 30.0, 500.0),
            expected);
    }

    TEST(RusanovEnergyFlux, IsZeroAtRestAcrossAPressureJump)
    {
        EXPECT_DOUBLE_EQ(
            rusanovEnergyFlux(2.0, 1000.0, 300.0, 0.0, 1000.0, 900.0, 0.0, 500.0),
            0.0);
    }
 
    // ------------------------------------------------------------------------------ //
    //   faceVelocityFlux                                                             //
    // ------------------------------------------------------------------------------ //

    TEST(FaceVelocityFlux, IsTheAreaWeightedAverageVelocity)
    {
        EXPECT_DOUBLE_EQ(faceVelocityFlux(4.0, 10.0, 30.0), 4.0 * 20.0);
        EXPECT_DOUBLE_EQ(faceVelocityFlux(0.0, 10.0, 30.0), 0.0);
    }

    TEST(FaceVelocityFlux, CancelsForAMirroredPair)
    {
        EXPECT_DOUBLE_EQ(faceVelocityFlux(2.0, -17.0, 17.0), 0.0);
    }
 
    // ------------------------------------------------------------------------------ //
    //   momentumGeometricSourceIntegral                                              //
    // ------------------------------------------------------------------------------ //

    TEST(MomentumGeometricSourceIntegral, IsThePressureTimesTheFaceSpan)
    {
        EXPECT_DOUBLE_EQ(momentumGeometricSourceIntegral(1.0e5, 2.0e-4), 20.0);
    }

    TEST(MomentumGeometricSourceIntegral, VanishesWhenTheFaceSpanIsZero)
    {
        EXPECT_DOUBLE_EQ(momentumGeometricSourceIntegral(1.0e5, 0.0), 0.0);
    }

    TEST(MomentumGeometricSourceIntegral, CancelsTheFluxDifferenceAtUniformPressure)
    {
        const double pressure = 1.0e5;
        // A deliberately lopsided pair of faces, as a stretched mesh produces.
        const double r_west = 1.0e-3;
        const double r_east = 1.7e-3;
        const double flux_west =
            rusanovMomentumFlux(r_west, 1.2, 0.0, pressure, 1.2, 0.0, pressure, 400.0);
        const double flux_east =
            rusanovMomentumFlux(r_east, 1.2, 0.0, pressure, 1.2, 0.0, pressure, 400.0);
        const double source =
            momentumGeometricSourceIntegral(pressure, r_east - r_west);
        EXPECT_NEAR(flux_east - flux_west - source, 0.0, 1.0e-10);
    }
 
} // namespace