convergence_criteria.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//
//
 
#if !defined(KRATOS_BASE_CONVERGENCE_CRITERIA_H )
#define  KRATOS_BASE_CONVERGENCE_CRITERIA_H
 
/* System includes */
 
/* External includes */
 
/* Project includes */
#include "includes/model_part.h"
#include "includes/kratos_parameters.h"
 
namespace Kratos
{
 
 
 
 
 
template<class TSparseSpace,
         class TDenseSpace //= DenseSpace<double>
         >
class ConvergenceCriteria
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(ConvergenceCriteria);
 
    typedef ConvergenceCriteria< TSparseSpace, TDenseSpace > ClassType;
 
    typedef typename TSparseSpace::DataType TDataType;
    typedef typename TSparseSpace::MatrixType TSystemMatrixType;
    typedef typename TSparseSpace::VectorType TSystemVectorType;
    typedef typename TDenseSpace::MatrixType LocalSystemMatrixType;
    typedef typename TDenseSpace::VectorType LocalSystemVectorType;
 
    typedef ModelPart::DofsArrayType DofsArrayType;
 
 
    explicit ConvergenceCriteria()
    {
        mActualizeRHSIsNeeded = false;
        mConvergenceCriteriaIsInitialized = false;
        SetEchoLevel(1);
    }
 
    explicit ConvergenceCriteria(Kratos::Parameters ThisParameters)
    {
        // Validate and assign defaults
        ThisParameters = this->ValidateAndAssignParameters(ThisParameters, this->GetDefaultParameters());
        this->AssignSettings(ThisParameters);
 
        mActualizeRHSIsNeeded = false;
        mConvergenceCriteriaIsInitialized = false;
    }
 
    explicit ConvergenceCriteria( ConvergenceCriteria const& rOther)
      :mActualizeRHSIsNeeded(rOther.mActualizeRHSIsNeeded)
      ,mConvergenceCriteriaIsInitialized(rOther.mConvergenceCriteriaIsInitialized)
      ,mEchoLevel(rOther.mEchoLevel)
    {
    }
 
    virtual ~ConvergenceCriteria()
    {
    }
 
 
 
 
    virtual typename ClassType::Pointer Create(Parameters ThisParameters) const
    {
        return Kratos::make_shared<ClassType>(ThisParameters);
    }
 
    virtual std::vector<TSystemVectorType>&  GetRHS_Element_Components()
    {
        KRATOS_ERROR <<"Asking for Global Components to the CONVERGENCE CRITERION base class which is not component wise and not contains this member variable" << std::endl;
    }
 
    virtual std::vector< Variable< LocalSystemVectorType > >&  GetRHS_Element_Variables()
    {
        KRATOS_ERROR <<"Asking for Global Components to the CONVERGENCE CRITERION base class which is not component wise and not contains this member variable" << std::endl;
    }
 
    virtual std::vector<TSystemVectorType>&  GetRHS_Condition_Components()
    {
        KRATOS_ERROR <<"Asking for Global Components to the CONVERGENCE CRITERION base class which is not component wise and not contains this member variable" << std::endl;
    }
 
    virtual std::vector< Variable< LocalSystemVectorType > >&  GetRHS_Condition_Variables()
    {
        KRATOS_ERROR <<"Asking for Global Components to the CONVERGENCE CRITERION base class which is not component wise and not contains this member variable" << std::endl;
    }
 
    virtual void SetEchoLevel(int Level)
    {
        mEchoLevel = Level;
    }
 
    int GetEchoLevel()
    {
        return mEchoLevel;
    }
 
    void SetActualizeRHSFlag(bool ActualizeRHSIsNeeded)
    {
        mActualizeRHSIsNeeded = ActualizeRHSIsNeeded;
    }
 
    bool GetActualizeRHSflag()
    {
        return mActualizeRHSIsNeeded;
    }
 
    virtual bool PreCriteria(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& rA,
        const TSystemVectorType& rDx,
        const TSystemVectorType& rb
        )
    {
        return true;
    }
 
    virtual bool PostCriteria(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& rA,
        const TSystemVectorType& rDx,
        const TSystemVectorType& rb
        )
    {
        return true;
    }
 
    virtual void Initialize(ModelPart& rModelPart)
    {
        mConvergenceCriteriaIsInitialized = true;
    }
 
    virtual bool IsInitialized()
    {
        return mConvergenceCriteriaIsInitialized;
    }
 
    virtual void InitializeSolutionStep(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& rA,
        const TSystemVectorType& rDx,
        const TSystemVectorType& rb
        )
    {
    }
 
    virtual void InitializeNonLinearIteration(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& rA,
        const TSystemVectorType& rDx,
        const TSystemVectorType& rb
        )
    {
    }
 
    virtual void FinalizeSolutionStep(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& rA,
        const TSystemVectorType& rDx,
        const TSystemVectorType& rb
        )
    {
    }
 
    virtual void FinalizeNonLinearIteration(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& rA,
        const TSystemVectorType& rDx,
        const TSystemVectorType& rb
        )
    {
    }
 
    virtual int Check(ModelPart& rModelPart)
    {
        KRATOS_TRY
 
        return 0;
        KRATOS_CATCH("");
    }
 
    virtual Parameters GetDefaultParameters() const
    {
        const Parameters default_parameters = Parameters(R"(
        {
            "name"       : "convergence_criteria",
            "echo_level" : 1
        })");
        return default_parameters;
    }
 
    static std::string Name()
    {
        return "convergence_criteria";
    }
 
 
 
 
    virtual std::string Info() const
    {
        return "ConvergenceCriteria";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << Info();
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
        rOStream << Info();
    }
 
 
 
protected:
 
 
    bool mActualizeRHSIsNeeded = false;             
    bool mConvergenceCriteriaIsInitialized = false; 
 
    int mEchoLevel; 
 
 
 
    virtual Parameters ValidateAndAssignParameters(
        Parameters ThisParameters,
        const Parameters DefaultParameters
        ) const
    {
        ThisParameters.ValidateAndAssignDefaults(DefaultParameters);
        return ThisParameters;
    }
 
    virtual void AssignSettings(const Parameters ThisParameters)
    {
        mEchoLevel = ThisParameters["echo_level"].GetInt();
    }
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
}; /* Class ConvergenceCriteria */
} /* namespace Kratos.*/
 
#endif /* KRATOS_BASE_CONVERGENCE_CRITERIA_H  defined */