tsttabulate.cpp

./Core/fn/tests/tsttabulate.cpp

#include "Nemesis/gtest/nemesis_gtest.hh"

#include "Origen/Core/dc/FakeFactory.h"
#include "Origen/Core/fn/print.h"
#include "Origen/Core/fn/tabulate.h"
#include "Origen/Core/xf/Solver_Fake.h"

using Origen::tabulateLossXs;
using Origen::printTable;
using Origen::tabulateMaterialIsotopics;
using Origen::Vec_Int;
using Origen::Vec_Dbl;

TEST( Tabulate, Append )
{
    auto lib = Origen::FakeFactory::newspLibrary_10nuclide();

    // set of values for the first column
    int sizzzaaa = 0;
    std::string idform = "";
    int prec = 5;
    int pos = 1;
    std::string column_name = "x";
    bool append_column = false;

    ScaleUtils::IO::Table2D table;
    tabulateLossXs(
        *lib, sizzzaaa, idform, prec, pos, column_name, append_column, &table );

    // set for the second column
    pos = 4;
    column_name = "y";
    prec = 3;
    append_column = true;

    tabulateLossXs(
        *lib, sizzzaaa, idform, prec, pos, column_name, append_column, &table );

    // printTable( false, &table );
    EXPECT_EQ( "x", table.headersX[0] );
    EXPECT_EQ( "y", table.headersX[1] );
    EXPECT_EQ( "1.000e+00", table.data[1][1] );

    // printTable( false, &table );
}

class TabulateMaterial : public ::testing::Test
{
  protected:
    void SetUp()
    {
        // initialize materials
        {
            mat1 = Origen::FakeFactory::newspMaterial_scale_pwr();
            mat1->set_id( 1 );
            mat1->set_name( "mix1" );

            mat2 = Origen::FakeFactory::newspMaterial_scale_pwr();
            mat2->set_id( 2 );
            mat2->set_name( "mix2" );

            // reference bos data
            Vec_Int ref_ids;
            Vec_Dbl ref_vals;
            Origen::FakeFactory::vera_uox_e360( ref_ids, ref_vals );
            mat1->set_numden_bos( ref_vals, ref_ids );

            ref_ids.push_back( 72172 );
            ref_vals.push_back( 1e-20 );
            mat2->set_numden_bos( ref_vals, ref_ids );
        }

        // add solvers and take a step
        mat1->set_solver( std::make_shared<Origen::Solver_Fake>() );
        {
            Vec_Dbl flux, power, dtrel;
            dtrel = {1.0};
            mat1->add_step( 1.0 );
            mat1->set_flux( 1e14 );
            mat1->set_transition_matrix(
                mat1->library()->newsp_transition_matrix_at( 0 ) );
            mat1->solve( dtrel, &flux, &power );
        }
        mat2->set_solver( std::make_shared<Origen::Solver_Fake>() );
        {
            Vec_Dbl flux, power, dtrel;
            dtrel = {1.0};
            mat2->add_step( 1.0 );
            mat2->set_flux( 2e14 );
            mat2->set_transition_matrix(
                mat1->library()->newsp_transition_matrix_at( 0 ) );
            mat2->solve( dtrel, &flux, &power );
        }
    }

    Origen::SP_Material mat1;
    Origen::SP_Material mat2;
};

TEST_F( TabulateMaterial, Isotopics )
{
    ScaleUtils::IO::Table2D table;

    size_t point = 1;

    Origen::SCP_Vec_Int base_ids;  // ids that will be print in the table (set
                                   // by call with append_column=false)
    Origen::tabulateMaterialIsotopics( *mat1, point, &table, base_ids );
    Origen::tabulateMaterialIsotopics( *mat2, point, &table, base_ids );

    std::stringstream ss;
    Origen::printTable( false, &table, ss );
    // std::cout << ss.str() << std::endl;
    EXPECT_NE( "", ss.str() );
}

TEST_F( TabulateMaterial, TransitionRate )
{
    ScaleUtils::IO::Table2D table;

    size_t step = 0;

    Origen::SCP_TransitionStructure base_tstruct;
    Origen::tabulateMaterialTransitionRates(
        *mat1, step, &table, base_tstruct );
    Origen::tabulateMaterialTransitionRates(
        *mat2, step, &table, base_tstruct );

    std::stringstream ss;
    Origen::printTable( false, &table, ss );
    // std::cout << ss.str() << std::endl;
    EXPECT_NE( "", ss.str() );
}

TEST_F( TabulateMaterial, LossRate )
{
    ScaleUtils::IO::Table2D table;

    size_t step = 0;

    bool append = false;
    Origen::tabulateMaterialLossRate( *mat1, step, &table, append );
    Origen::tabulateMaterialLossRate( *mat2, step, &table, append );

    std::stringstream ss;
    Origen::printTable( false, &table, ss );
    // std::cout << ss.str() << std::endl;
    EXPECT_NE( "", ss.str() );
}

TEST_F( TabulateMaterial, FissionRate )
{
    ScaleUtils::IO::Table2D table;

    size_t step = 0;

    bool append = false;
    Origen::tabulateMaterialFissionRate( *mat1, step, &table, append );
    Origen::tabulateMaterialFissionRate( *mat2, step, &table, append );

    std::stringstream ss;
    Origen::printTable( false, &table, ss );
    // std::cout << ss.str() << std::endl;
    EXPECT_NE( "", ss.str() );
}