residualbased_incremental_aitken_static_scheme.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_RESIDUALBASED_INCREMENTAL_AITKEN_STATIC_SCHEME_H_INCLUDED )
#define  KRATOS_RESIDUALBASED_INCREMENTAL_AITKEN_STATIC_SCHEME_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "solving_strategies/schemes/residualbased_incrementalupdate_static_scheme.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
template< class TSparseSpace,class TDenseSpace >
class ResidualBasedIncrementalAitkenStaticScheme : public ResidualBasedIncrementalUpdateStaticScheme<TSparseSpace,TDenseSpace>
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(ResidualBasedIncrementalAitkenStaticScheme);
 
    typedef Scheme<TSparseSpace,TDenseSpace> BaseSchemeType;
 
    typedef ResidualBasedIncrementalUpdateStaticScheme<TSparseSpace,TDenseSpace> BaseType;
 
    typedef ResidualBasedIncrementalAitkenStaticScheme<TSparseSpace, TDenseSpace> ClassType;
 
    typedef typename BaseType::TDataType TDataType;
 
    typedef typename BaseType::DofsArrayType DofsArrayType;
 
    typedef typename BaseType::TSystemMatrixType TSystemMatrixType;
 
    typedef typename BaseType::TSystemVectorType TSystemVectorType;
 
 
    explicit ResidualBasedIncrementalAitkenStaticScheme() : BaseType()
    {
    }
 
    explicit ResidualBasedIncrementalAitkenStaticScheme(Parameters ThisParameters) :
        ResidualBasedIncrementalAitkenStaticScheme([](Parameters x) -> double {x.ValidateAndAssignDefaults(StaticGetDefaultParameters()); return x["default_omega"].GetDouble(); }(ThisParameters))
    {
    }
 
    explicit ResidualBasedIncrementalAitkenStaticScheme(double DefaultOmega):
        mDefaultOmega(DefaultOmega),
        mOldOmega(DefaultOmega)
    {}
 
    ~ResidualBasedIncrementalAitkenStaticScheme() override {}
 
 
 
 
 
    typename BaseSchemeType::Pointer Create(Parameters ThisParameters) const override
    {
        return Kratos::make_shared<ClassType>(ThisParameters);
    }
 
 
    void InitializeSolutionStep(ModelPart &r_model_part,
                                        TSystemMatrixType &A,
                                        TSystemVectorType &Dx,
                                        TSystemVectorType &b) override
    {
        BaseType::InitializeSolutionStep(r_model_part,A,Dx,b);
        if (TSparseSpace::Size(mPreviousDx) != TSparseSpace::Size(Dx)) {
            TSparseSpace::Resize(mPreviousDx, TSparseSpace::Size(Dx));
        }
        TSparseSpace::SetToZero(mPreviousDx);
        mIterationCounter = 0;
    }
 
 
 
    void Update(ModelPart &r_model_part,
                        DofsArrayType &rDofSet,
                        TSystemMatrixType &A,
                        TSystemVectorType &Dx,
                        TSystemVectorType &b) override
    {
        mIterationCounter++;
 
        // Compute relaxation factor
        double Omega;
 
        if (mIterationCounter > 1)
        {
            double Num = 0.0;
            double Den = 0.0;
 
            for (unsigned int i = 0; i < Dx.size(); i++)
            {
                double Diff = Dx[i] - mPreviousDx[i];
                Num += mPreviousDx[i] * Diff;
                Den += Diff * Diff;
            }
 
            Omega = - mOldOmega * Num / Den;
        }
        else
        {
            // Initialize the process using min(DefaultOmega,Omega_from_last_step)
            if (mOldOmega < mDefaultOmega)
                Omega = mOldOmega;
            else
                Omega = mDefaultOmega;
        }
 
        //KRATOS_WATCH(Omega);
 
        // Update using relaxation factor
        for(typename DofsArrayType::iterator i_dof = rDofSet.begin() ; i_dof != rDofSet.end() ; ++i_dof)
        {
            if(i_dof->IsFree())
            {
                i_dof->GetSolutionStepValue() += Omega * Dx[i_dof->EquationId()];
            }
        }
 
        // Store results for next iteration
        boost::numeric::ublas::noalias(mPreviousDx) = Dx;
        mOldOmega = Omega;
    }
 
    static Parameters StaticGetDefaultParameters()
    {
        Parameters default_parameters = Parameters(R"(
        {
            "name"          : "ResidualBasedIncrementalAitkenStaticScheme",
            "default_omega" : 0.1
        })");
 
        return default_parameters;
    }
 
    Parameters GetDefaultParameters() const override
    {
        return StaticGetDefaultParameters();
    }
 
 
 
 
 
    std::string Info() const override
    {
        return "ResidualBasedIncrementalAitkenStaticScheme";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    unsigned int mIterationCounter;
 
 
    const double mDefaultOmega;
 
    double mOldOmega;
 
    TSystemVectorType mPreviousDx;
 
 
 
 
 
 
 
 
 
 
    ResidualBasedIncrementalAitkenStaticScheme& operator=(ResidualBasedIncrementalAitkenStaticScheme const& rOther) {}
 
    ResidualBasedIncrementalAitkenStaticScheme(ResidualBasedIncrementalAitkenStaticScheme const& rOther) {}
 
 
 
}; // Class ResidualBasedIncrementalAitkenStaticScheme
 
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_RESIDUALBASED_INCREMENTAL_AITKEN_STATIC_SCHEME_H_INCLUDED  defined