or_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_OR_CRITERIA_H)
#define  KRATOS_OR_CRITERIA_H
 
/* System includes */
 
/* External includes */
 
/* Project includes */
#include "includes/define.h"
#include "includes/model_part.h"
#include "solving_strategies/convergencecriterias/convergence_criteria.h"
 
namespace Kratos
{
 
 
 
 
 
template<class TSparseSpace,
         class TDenseSpace
         >
class Or_Criteria
    : public ConvergenceCriteria< TSparseSpace, TDenseSpace >
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(Or_Criteria );
 
    typedef ConvergenceCriteria< TSparseSpace, TDenseSpace > BaseType;
 
    typedef Or_Criteria< TSparseSpace, TDenseSpace > ClassType;
 
    typedef TSparseSpace SparseSpaceType;
 
    typedef typename BaseType::TDataType TDataType;
 
    typedef typename BaseType::DofsArrayType DofsArrayType;
 
    typedef typename BaseType::TSystemMatrixType TSystemMatrixType;
 
    typedef typename BaseType::TSystemVectorType TSystemVectorType;
 
    typedef typename ConvergenceCriteria < TSparseSpace, TDenseSpace >::Pointer ConvergenceCriteriaPointerType;
 
 
    //* Constructor.
    explicit Or_Criteria()
        : BaseType()
    {
    }
 
    explicit Or_Criteria(Kratos::Parameters ThisParameters)
        :BaseType()
    {
        // Validate and assign defaults
        ThisParameters = this->ValidateAndAssignParameters(ThisParameters, this->GetDefaultParameters());
        this->AssignSettings(ThisParameters);
 
        KRATOS_ERROR << "IMPLEMENTATION PENDING IN CONSTRUCTOR WITH PARAMETERS" << std::endl;
    }
 
    explicit Or_Criteria(
        ConvergenceCriteriaPointerType pFirstCriterion,
        ConvergenceCriteriaPointerType pSecondCriterion
        ) :BaseType(),
           mpFirstCriterion(pFirstCriterion),
           mpSecondCriterion(pSecondCriterion)
    {
        this->mActualizeRHSIsNeeded = false;
        if(mpFirstCriterion->GetActualizeRHSflag()) this->mActualizeRHSIsNeeded = true;
        if(mpSecondCriterion->GetActualizeRHSflag()) this->mActualizeRHSIsNeeded = true;
 
    }
 
    explicit Or_Criteria(Or_Criteria const& rOther)
        :BaseType(rOther),
         mpFirstCriterion(rOther.mpFirstCriterion),
         mpSecondCriterion(rOther.mpSecondCriterion)
     {
        this->mActualizeRHSIsNeeded = false;
        if(mpFirstCriterion->GetActualizeRHSflag()) this->mActualizeRHSIsNeeded = true;
        if(mpSecondCriterion->GetActualizeRHSflag()) this->mActualizeRHSIsNeeded = true;
     }
 
    ~Or_Criteria () override {}
 
 
 
 
    typename BaseType::Pointer Create(Parameters ThisParameters) const override
    {
        return Kratos::make_shared<ClassType>(ThisParameters);
    }
 
    void SetEchoLevel(int Level) override
    {
        BaseType::SetEchoLevel(Level);
        mpFirstCriterion->SetEchoLevel(Level);
        mpSecondCriterion->SetEchoLevel(Level);
    }
 
    bool PreCriteria(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& A,
        const TSystemVectorType& Dx,
        const TSystemVectorType& b
        ) override
    {
        const bool first_criterion_result  = mpFirstCriterion ->PreCriteria(rModelPart,rDofSet,A,Dx,b);
        const bool second_criterion_result = mpSecondCriterion ->PreCriteria(rModelPart,rDofSet,A,Dx,b);
 
        return (first_criterion_result || second_criterion_result);
    }
 
    bool PostCriteria(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& A,
        const TSystemVectorType& Dx,
        const TSystemVectorType& b
        ) override
    {
        const bool first_criterion_result  = mpFirstCriterion ->PostCriteria(rModelPart,rDofSet,A,Dx,b);
        const bool second_criterion_result = mpSecondCriterion ->PostCriteria(rModelPart,rDofSet,A,Dx,b);
 
        return (first_criterion_result || second_criterion_result);
    }
 
    void Initialize(ModelPart& rModelPart) override
    {
        mpFirstCriterion->Initialize(rModelPart);
        mpSecondCriterion->Initialize(rModelPart);
    }
 
    void InitializeSolutionStep(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& A,
        const TSystemVectorType& Dx,
        const TSystemVectorType& b
        ) override
    {
        mpFirstCriterion->InitializeSolutionStep(rModelPart,rDofSet,A,Dx,b);
        mpSecondCriterion->InitializeSolutionStep(rModelPart,rDofSet,A,Dx,b);
    }
 
    void InitializeNonLinearIteration(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& A,
        const TSystemVectorType& Dx,
        const TSystemVectorType& b
        ) override
    {
        mpFirstCriterion->InitializeNonLinearIteration(rModelPart,rDofSet,A,Dx,b);
        mpSecondCriterion->InitializeNonLinearIteration(rModelPart,rDofSet,A,Dx,b);
    }
 
    void FinalizeSolutionStep(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& A,
        const TSystemVectorType& Dx,
        const TSystemVectorType& b
        ) override
    {
        mpFirstCriterion->FinalizeSolutionStep(rModelPart,rDofSet,A,Dx,b);
        mpSecondCriterion->FinalizeSolutionStep(rModelPart,rDofSet,A,Dx,b);
    }
 
    void FinalizeNonLinearIteration(
        ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        const TSystemMatrixType& A,
        const TSystemVectorType& Dx,
        const TSystemVectorType& b
        ) override
    {
        mpFirstCriterion->FinalizeNonLinearIteration(rModelPart,rDofSet,A,Dx,b);
        mpSecondCriterion->FinalizeNonLinearIteration(rModelPart,rDofSet,A,Dx,b);
    }
 
    int Check(ModelPart& rModelPart) override
    {
        KRATOS_TRY
 
        const int check1 = mpFirstCriterion->Check(rModelPart);
        const int check2 = mpSecondCriterion->Check(rModelPart);
 
        return check1 + check2;
 
        KRATOS_CATCH("");
    }
 
    Parameters GetDefaultParameters() const override
    {
        Parameters default_parameters = Parameters(R"(
        {
            "name"                     : "or_criteria",
            "first_criterion_settings" : {
                "name"                            : "residual_criteria",
                "residual_absolute_tolerance"     : 1.0e-4,
                "residual_relative_tolerance"     : 1.0e-9
            },
            "second_criterion_settings" : {
                "name"                            : "displacement_criteria",
                "displacement_relative_tolerance" : 1.0e-4,
                "displacement_absolute_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 "or_criteria";
    }
 
 
 
 
    std::string Info() const override
    {
        return "Or_Criteria";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
 
 
protected:
 
 
 
 
 
 
 
 
private:
 
 
    ConvergenceCriteriaPointerType mpFirstCriterion;  
    ConvergenceCriteriaPointerType mpSecondCriterion; 
 
 
 
 
 
 
 
 
}; /* Class Or_Criteria */
 
 
 
 
 
}  /* namespace Kratos.*/
 
#endif /* KRATOS_OR_CRITERIA_H  defined */