trilinos_residual_criteria.h

Go to the documentation of this file.

//  KRATOS  _____     _ _ _
//         |_   _| __(_) (_)_ __   ___  ___
//           | || '__| | | | '_ \ / _ \/ __|
//           | || |  | | | | | | | (_) \__
//           |_||_|  |_|_|_|_| |_|\___/|___/ APPLICATION
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Jordi Cotela
//
 
#pragma once
 
// System includes
 
// External includes
 
// Project includes
#include "solving_strategies/convergencecriterias/residual_criteria.h"
 
namespace Kratos
{
 
 
template<class TSparseSpace,
         class TDenseSpace
         >
class TrilinosResidualCriteria
    : public ResidualCriteria< TSparseSpace, TDenseSpace >
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(TrilinosResidualCriteria);
 
    using BaseConvergenceCriteriaType = ConvergenceCriteria< TSparseSpace, TDenseSpace >;
 
    using BaseType = ResidualCriteria< TSparseSpace, TDenseSpace >;
 
    using ClassType = TrilinosResidualCriteria< TSparseSpace, TDenseSpace >;
 
    using TDataType = typename BaseType::TDataType;
 
    using DofsArrayType = typename BaseType::DofsArrayType;
 
    using DofType = typename Node::DofType;
 
    using TSystemMatrixType = typename BaseType::TSystemMatrixType;
 
    using TSystemVectorType = typename BaseType::TSystemVectorType;
 
    using IndexType = std::size_t;
 
 
    explicit TrilinosResidualCriteria()
        : BaseType()
    {
    }
 
    explicit TrilinosResidualCriteria(Kratos::Parameters ThisParameters)
        : BaseType(ThisParameters)
    {
    }
 
    explicit TrilinosResidualCriteria(TDataType NewRatioTolerance,TDataType AlwaysConvergedNorm):
        BaseType(NewRatioTolerance, AlwaysConvergedNorm)
    {
    }
 
    explicit TrilinosResidualCriteria(const TrilinosResidualCriteria& rOther):
        BaseType(rOther)
    {
    }
 
    ~TrilinosResidualCriteria() override {}
 
 
    TrilinosResidualCriteria& operator=(TrilinosResidualCriteria const& rOther) = delete;
 
 
    typename BaseConvergenceCriteriaType::Pointer Create(Parameters ThisParameters) const override
    {
        return Kratos::make_shared<ClassType>(ThisParameters);
    }
 
    void InitializeSolutionStep(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& rA,
        const TSystemVectorType& rDx,
        const TSystemVectorType& rb
        ) override
    {
        // We set the initial Id
        const auto& r_data_communicator = rModelPart.GetCommunicator().GetDataCommunicator();
        const int rank = r_data_communicator.Rank();
        for (auto& r_dof : rDofSet) {
            if (r_dof.GetSolutionStepValue(PARTITION_INDEX) == rank) {
                BaseType::mInitialDoFId = r_dof.EquationId();
                break;
            }
        }
 
        // Calling base class
        BaseType::InitializeSolutionStep(rModelPart, rDofSet, rA, rDx, rb);
    }
 
    Parameters GetDefaultParameters() const override
    {
        Parameters default_parameters = Parameters(R"(
        {
            "name"                        : "trilinos_residual_criteria",
            "residual_absolute_tolerance" : 1.0e-4,
            "residual_relative_tolerance" : 1.0e-9
        })");
 
        // Getting base class default parameters
        const Parameters base_default_parameters = BaseType::GetDefaultParameters();
        default_parameters.RecursivelyAddMissingParameters(base_default_parameters);
        return default_parameters;
    }
 
    static std::string Name()
    {
        return "trilinos_residual_criteria";
    }
 
 
 
 
    std::string Info() const override
    {
        return "TrilionosResidualCriteria";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
 
protected:
 
    void ComputeActiveDofs(
        ModelPart& rModelPart,
        const ModelPart::DofsArrayType& rDofSet
        ) override
    {
        // Filling mActiveDofs when MPC exist
        ConstraintUtilities::DistributedComputeActiveDofs(rModelPart, BaseType::mActiveDofs, rDofSet, BaseType::mInitialDoFId);
    }
 
}; // Class TrilinosResidualCriteria
 
 
 
}  // namespace Kratos.