relaxed_dof_updater.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Suneth Warnakulasuriya
//
 
#if !defined(KRATOS_RELAXED_DOF_UPDATER_H_INCLUDED )
#define  KRATOS_RELAXED_DOF_UPDATER_H_INCLUDED
 
// Project includes
#include "includes/define.h"
#include "includes/model_part.h"
#include "utilities/dof_updater.h"
 
#ifdef KRATOS_USING_MPI // mpi-parallel compilation
class Epetra_Import;
#endif
 
 
 
namespace Kratos
{
 
 
 
template< class TSparseSpace >
class KRATOS_API(RANS_APPLICATION) RelaxedDofUpdater
    :public DofUpdater<TSparseSpace>
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(RelaxedDofUpdater);
 
    using BaseType = DofUpdater<TSparseSpace>;
 
    using DofType = typename BaseType::DofType;
 
    using DofsArrayType = typename BaseType::DofsArrayType;
 
    using SystemVectorType = typename TSparseSpace::VectorType;
 
 
 
 
    RelaxedDofUpdater(const double RelaxationFactor)
        : mRelaxationFactor(RelaxationFactor)
    {}
 
    RelaxedDofUpdater(RelaxedDofUpdater const& rOther) = delete;
 
    virtual ~RelaxedDofUpdater() = default;
 
    RelaxedDofUpdater& operator=(RelaxedDofUpdater const& rOther) = delete;
 
 
 
    typename BaseType::UniquePointer Create() const override
    {
        return Kratos::make_unique<RelaxedDofUpdater>(mRelaxationFactor);
    }
 
 
    void Initialize(
        const DofsArrayType& rDofSet,
        const SystemVectorType& rDx) override;
 
 
    void Clear() override;
 
 
    void UpdateDofs(
        DofsArrayType& rDofSet,
        const SystemVectorType& rDx) override;
 
 
    std::string Info() const override;
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << this->Info() << std::endl;
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << this->Info() << std::endl;
    }
 
private:
 
    //@name Member Variables
 
    bool mImportIsInitialized = false;
    const double mRelaxationFactor;
 
    #ifdef KRATOS_USING_MPI // mpi-parallel compilation
    std::shared_ptr<Epetra_Import> mpDofImport = nullptr;
    #endif
 
 
 
}; // Class RelaxedDofUpdater
 
 
 
template< class TSparseSpace >
inline std::istream& operator >> (
    std::istream& rIStream,
    RelaxedDofUpdater<TSparseSpace>& rThis)
{
    return rIStream;
}
 
template< class TSparseSpace >
inline std::ostream& operator << (
    std::ostream& rOStream,
    const RelaxedDofUpdater<TSparseSpace>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_RELAXED_DOF_UPDATER_H_INCLUDED  defined