ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl Struct Reference

Detailed Description

Data shared among all copied CompareJacobiansJacobianAssembler instances.

Definition at line 172 of file CompareJacobiansJacobianAssembler.cpp.

Public Member Functions
	CompareJacobiansJacobianAssemblerImpl (std::unique_ptr< AbstractJacobianAssembler > &&asm1, std::unique_ptr< AbstractJacobianAssembler > &&asm2, double abs_tol_Jac, double rel_tol_Jac, double abs_tol_res, double rel_tol_res, bool fail_on_error, std::string const &log_file_path)
void	assembleWithJacobian (std::size_t const mesh_item_id, LocalAssemblerInterface &local_assembler, double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)

Private Attributes
std::unique_ptr< AbstractJacobianAssembler >	asm1_
std::unique_ptr< AbstractJacobianAssembler >	asm2_
double const	abs_tol_Jac_
double const	rel_tol_Jac_
double const	abs_tol_res_
double const	rel_tol_res_
bool const	fail_on_error_
	Whether to abort if the tolerances are exceeded.
std::ofstream	log_file_
std::ptrdiff_t	counter_ = -1
unsigned	iter_ = 0

Friends
class	ProcessLib::CompareJacobiansJacobianAssembler

Constructor & Destructor Documentation

CompareJacobiansJacobianAssemblerImpl()

ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::CompareJacobiansJacobianAssemblerImpl ( std::unique_ptr< AbstractJacobianAssembler > && asm1, std::unique_ptr< AbstractJacobianAssembler > && asm2, double abs_tol_Jac, double rel_tol_Jac, double abs_tol_res, double rel_tol_res, bool fail_on_error, std::string const & log_file_path )

inline

Definition at line 176 of file CompareJacobiansJacobianAssembler.cpp.

        : asm1_{std::move(asm1)},
          asm2_{std::move(asm2)},
          abs_tol_Jac_{abs_tol_Jac},
          rel_tol_Jac_{rel_tol_Jac},
          abs_tol_res_{abs_tol_res},
          rel_tol_res_{rel_tol_res},
          fail_on_error_{fail_on_error},
          log_file_{log_file_path}
    {
        log_file_.precision(std::numeric_limits<double>::max_digits10);
        log_file_ << "#!/usr/bin/env python\n"
                     "import numpy as np\n"
                     "from numpy import nan\n"
                  << std::endl;
    }

References abs_tol_Jac_, abs_tol_res_, asm1_, asm2_, fail_on_error_, log_file_, rel_tol_Jac_, and rel_tol_res_.

Member Function Documentation

assembleWithJacobian()

void ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::assembleWithJacobian	(	std::size_t const	mesh_item_id,
		LocalAssemblerInterface &	local_assembler,
		double const	t,
		double const	dt,
		std::vector< double > const &	local_x,
		std::vector< double > const &	local_x_prev,
		std::vector< double > &	local_b_data,
		std::vector< double > &	local_Jac_data )

Definition at line 234 of file CompareJacobiansJacobianAssembler.cpp.

{
    ++counter_;
 
    auto const num_dof = local_x.size();
 
    // First assembly -- the one whose results will be added to the global
    // equation system finally.
    asm1_->assembleWithJacobian(mesh_item_id, local_assembler, t, dt, local_x,
                                local_x_prev, local_b_data, local_Jac_data);
 
    auto const local_b1 = MathLib::toVector(local_b_data);
 
    std::vector<double> local_b_data2;
    std::vector<double> local_Jac_data2;
 
    // Second assembly -- used for checking only.
    asm2_->assembleWithJacobian(mesh_item_id, local_assembler, t, dt, local_x,
                                local_x_prev, local_b_data2, local_Jac_data2);
 
    auto const local_b2 = MathLib::toVector(local_b_data2);
 
    auto const local_Jac1 = MathLib::toMatrix(local_Jac_data, num_dof, num_dof);
    auto const local_Jac2 =
        MathLib::toMatrix(local_Jac_data2, num_dof, num_dof);
 
    auto const [abs_diff, rel_diff] =
        signedAbsDiffRelDiff(local_Jac1, local_Jac2);
 
    auto const abs_diff_mask =
        oneIfAboveThresholdElseZero(abs_diff.abs(), abs_tol_Jac_);
    auto const rel_diff_mask =
        oneIfAboveThresholdElseZero(rel_diff.abs(), rel_tol_Jac_);
 
    auto const abs_diff_OK = !abs_diff_mask.any();
    auto const rel_diff_OK = !rel_diff_mask.any();
 
    std::ostringstream msg_tolerance;
    bool tol_exceeded = true;
    bool fatal_error = false;
 
    if (abs_diff_OK)
    {
        tol_exceeded = false;
    }
    else
    {
        msg_tolerance << "absolute tolerance of " << abs_tol_Jac_
                      << " exceeded";
    }
 
    if (rel_diff_OK)
    {
        tol_exceeded = false;
    }
    else
    {
        if (!msg_tolerance.str().empty())
        {
            msg_tolerance << " and ";
        }
 
        msg_tolerance << "relative tolerance of " << rel_tol_Jac_
                      << " exceeded";
    }
 
    fatal_error |= !isSimilar(local_b1, local_b2, abs_tol_res_, rel_tol_res_);
 
    Eigen::VectorXd res1 = Eigen::VectorXd::Zero(num_dof);
    auto const x = MathLib::toVector(local_x);
    auto const x_dot = ((x - MathLib::toVector(local_x_prev)) / dt).eval();
    if (local_b1.size() != 0)
    {
        res1.noalias() -= local_b1;
    }
 
    Eigen::VectorXd res2 = Eigen::VectorXd::Zero(num_dof);
    if (local_b2.size() != 0)
    {
        res2.noalias() -= local_b2;
    }
 
    fatal_error |= !isSimilar(res1, res2, abs_tol_res_, rel_tol_res_);
 
    if (tol_exceeded)
    {
        WARN("Compare Jacobians: {:s}", msg_tolerance.str());
    }
 
    bool const output = tol_exceeded || fatal_error;
 
    if (output)
    {
        log_file_ << "\n### counter: " << std::to_string(counter_)
                  << ", t: " << t << ", element_id: " << mesh_item_id
                  << " (begin)\n";
    }
 
    if (fatal_error)
    {
        log_file_ << '\n'
                  << "#######################################################\n"
                  << "# FATAL ERROR: " << msg_fatal << '\n'
                  << "#              You cannot expect any meaningful insights "
                     "from the Jacobian data printed below!\n"
                  << "#              The reason for the mentioned differences "
                     "might be\n"
                  << "#              (a) that the assembly routine has side "
                     "effects or\n"
                  << "#              (b) that the assembly routines for b "
                     "themselves differ.\n"
                  << "#######################################################\n"
                  << '\n';
    }
 
    if (tol_exceeded)
    {
        log_file_ << "# " << msg_tolerance.str() << "\n\n";
    }
 
    if (output)
    {
        dump_py(log_file_, "counter", counter_);
        dump_py(log_file_, "nonlinear_iteration", iter_);
        dump_py(log_file_, "t", t);
        dump_py(log_file_, "dt", dt);
        dump_py(log_file_, "element_id", mesh_item_id);
 
        log_file_ << '\n';
 
        dump_py(log_file_, "num_dof", num_dof);
        dump_py(log_file_, "abs_tol", abs_tol_Jac_);
        dump_py(log_file_, "rel_tol", rel_tol_Jac_);
 
        log_file_ << '\n';
 
        dump_py(log_file_, "local_x", local_x);
        dump_py(log_file_, "local_x_prev", local_x_prev);
 
        log_file_ << '\n';
 
        dump_py(log_file_, "Jacobian_1", local_Jac1);
        dump_py(log_file_, "Jacobian_2", local_Jac2);
 
        log_file_ << '\n';
 
        log_file_ << "# Jacobian_2 - Jacobian_1\n";
        dump_py(log_file_, "abs_diff", abs_diff);
        log_file_ << "# max(|abs_diff|) = " << abs_diff.abs().maxCoeff()
                  << '\n';
        log_file_ << "# Componentwise: 2 * abs_diff / (|Jacobian_1| + "
                     "|Jacobian_2|)\n";
        dump_py(log_file_, "rel_diff", rel_diff);
        log_file_ << "# max(|rel_diff|) = " << rel_diff.abs().maxCoeff()
                  << '\n';
 
        log_file_ << '\n';
 
        log_file_ << "# Masks: 0 ... tolerance met, 1 ... tolerance exceeded\n";
        dump_py(log_file_, "abs_diff_mask", abs_diff_mask);
        dump_py(log_file_, "rel_diff_mask", rel_diff_mask);
 
        log_file_ << '\n';
 
        dump_py(log_file_, "b_1", local_b_data);
        dump_py(log_file_, "b_2", local_b_data2);
        if (fatal_error && local_b1.size() == local_b2.size())
        {
            dump_py(log_file_, "delta_b", local_b2 - local_b1);
            log_file_ << '\n';
        }
 
        dump_py(log_file_, "res_1", res1);
        dump_py(log_file_, "res_2", res2);
        if (fatal_error)
        {
            dump_py(log_file_, "delta_res", res2 - res1);
        }
 
        log_file_ << '\n';
 
        log_file_ << "### counter: " << std::to_string(counter_) << " (end)\n";
    }
 
    if (fatal_error)
    {
        log_file_ << std::flush;
        OGS_FATAL("{:s}", msg_fatal);
    }
 
    if (tol_exceeded && fail_on_error_)
    {
        log_file_ << std::flush;
        OGS_FATAL(
            "OGS failed, because the two Jacobian implementations returned "
            "different results.");
    }
}

References abs_tol_Jac_, abs_tol_res_, asm1_, asm2_, counter_, fail_on_error_, iter_, log_file_, OGS_FATAL, rel_tol_Jac_, rel_tol_res_, MathLib::toMatrix(), MathLib::toVector(), and WARN().

Friends And Related Symbol Documentation

ProcessLib::CompareJacobiansJacobianAssembler

friend class ProcessLib::CompareJacobiansJacobianAssembler

friend

Definition at line 174 of file CompareJacobiansJacobianAssembler.cpp.

Member Data Documentation

abs_tol_Jac_

double const ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::abs_tol_Jac_

private

Definition at line 213 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by CompareJacobiansJacobianAssemblerImpl(), and assembleWithJacobian().

abs_tol_res_

double const ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::abs_tol_res_

private

Definition at line 215 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by CompareJacobiansJacobianAssemblerImpl(), and assembleWithJacobian().

asm1_

std::unique_ptr<AbstractJacobianAssembler> ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::asm1_

private

Definition at line 210 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by CompareJacobiansJacobianAssemblerImpl(), and assembleWithJacobian().

asm2_

std::unique_ptr<AbstractJacobianAssembler> ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::asm2_

private

Definition at line 211 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by CompareJacobiansJacobianAssemblerImpl(), and assembleWithJacobian().

counter_

std::ptrdiff_t ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::counter_ = -1

private

Counter used for identifying blocks in the log_file_. It is incremented upon each call of the assembly routine, i.e., for each element in each iteration etc.

Definition at line 229 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by assembleWithJacobian().

fail_on_error_

bool const ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::fail_on_error_

private

Whether to abort if the tolerances are exceeded.

Definition at line 219 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by CompareJacobiansJacobianAssemblerImpl(), and assembleWithJacobian().

iter_

unsigned ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::iter_ = 0

private

Definition at line 231 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by assembleWithJacobian().

log_file_

std::ofstream ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::log_file_

private

Path where a Python script will be placed, which contains information about exceeded tolerances and assembled local matrices.

Definition at line 224 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by CompareJacobiansJacobianAssemblerImpl(), and assembleWithJacobian().

rel_tol_Jac_

double const ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::rel_tol_Jac_

private

Definition at line 214 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by CompareJacobiansJacobianAssemblerImpl(), and assembleWithJacobian().

rel_tol_res_

double const ProcessLib::detail::CompareJacobiansJacobianAssemblerImpl::rel_tol_res_

private

Definition at line 216 of file CompareJacobiansJacobianAssembler.cpp.

Referenced by CompareJacobiansJacobianAssemblerImpl(), and assembleWithJacobian().

---

The documentation for this struct was generated from the following file:

• CompareJacobiansJacobianAssembler.cpp