CollisionModel_test.cpp

Go to the documentation of this file.

 
#include "numeric/TrialStateError.h"
#include "transport/CollisionModel.h"
 
#include <gtest/gtest.h>
 
#include <limits>
#include <stdexcept>
#include <vector>
 
namespace
{
 
    using rizer::CollisionModel;
    using rizer::TrialStateError;

    CollisionModel neutralAndIon()
    {
        CollisionModel::SpeciesSpec neutral;
        neutral.radius = 1.0e-10;
        neutral.molar_mass = 0.028;
        CollisionModel::SpeciesSpec ion;
        ion.Z = 1;
        ion.molar_mass = 0.028;
        return CollisionModel({neutral, ion}, /*Te_min=*/200.0, /*Te_max=*/1.0e5,
                              /*Te_n=*/16);
    }

    TEST(CollisionModelEvaluate, RefusesANonPositiveOrNanTe)
    {
        const CollisionModel model = neutralAndIon();
        const double n_k[2] = {2.4e25, 1.0e20};
        double sigma, nu_E, nu_eH, nu_eI, nu_eH_mass_weighted;
 
        model.evaluate(/*Te=*/1.0e4, /*n_e=*/1.0e20, n_k, 2, sigma, nu_E, nu_eH, nu_eI,
                       nu_eH_mass_weighted);
        EXPECT_GT(sigma, 0.0);
 
        for (const double Te : {0.0, -300.0, std::numeric_limits<double>::quiet_NaN()})
        {
            EXPECT_THROW(model.evaluate(Te, /*n_e=*/1.0e20, n_k, 2, sigma, nu_E, nu_eH,
                                        nu_eI, nu_eH_mass_weighted),
                         TrialStateError)
                << "Te = " << Te;
        }
    }

    TEST(CollisionModelEvaluate, RefusesAnIonWithoutElectrons)
    {
        const CollisionModel model = neutralAndIon();
        const double n_k[2] = {2.4e25, 1.0e20};
        double sigma, nu_E, nu_eH, nu_eI, nu_eH_mass_weighted;
 
        EXPECT_THROW(model.evaluate(/*Te=*/1.0e4, /*n_e=*/0.0, n_k, 2, sigma, nu_E,
                                    nu_eH, nu_eI, nu_eH_mass_weighted),
                     TrialStateError);
    }

    TEST(CollisionModelEvaluate, RefusesANegativeCoulombLogarithm)
    {
        const CollisionModel model = neutralAndIon();
        const double n_k[2] = {2.4e25, 1.0e26};
        double sigma, nu_E, nu_eH, nu_eI, nu_eH_mass_weighted;
 
        EXPECT_THROW(model.evaluate(/*Te=*/1000.0, /*n_e=*/1.0e26, n_k, 2, sigma, nu_E,
                                    nu_eH, nu_eI, nu_eH_mass_weighted),
                     TrialStateError);
    }

    TEST(CollisionModelEvaluate, RefusesADensityArrayOfTheWrongLength)
    {
        const CollisionModel model = neutralAndIon();
        const double n_k[3] = {2.4e25, 1.0e20, 1.0e20};
        double sigma, nu_E, nu_eH, nu_eI, nu_eH_mass_weighted;
 
        for (const std::size_t nsp : {std::size_t{1}, std::size_t{3}})
        {
            EXPECT_THROW(model.evaluate(/*Te=*/1.0e4, /*n_e=*/1.0e20, n_k, nsp, sigma,
                                        nu_E, nu_eH, nu_eI, nu_eH_mass_weighted),
                         std::invalid_argument)
                << "nsp = " << nsp;
        }
    }

    TEST(CollisionModelElectronElectron, RefusesANonPositiveOrNanTe)
    {
        for (const double Te : {0.0, -300.0, std::numeric_limits<double>::quiet_NaN()})
        {
            EXPECT_THROW(CollisionModel::electronElectronCollisionFrequency(
                             /*n_e=*/1.0e20, Te),
                         TrialStateError)
                << "Te = " << Te;
        }
    }
 
} // namespace