stokes_initialization_process.h

Go to the documentation of this file.

#ifndef KRATOS_STOKES_INITIALIZATION_PROCESS_H
#define KRATOS_STOKES_INITIALIZATION_PROCESS_H
 
// System includes
#include <string>
#include <iostream>
 
 
// External includes
 
 
// Project includes
#include "includes/define.h"
#include "containers/model.h"
#include "includes/model_part.h"
#include "processes/process.h"
#include "solving_strategies/strategies/implicit_solving_strategy.h"
#include "solving_strategies/strategies/residualbased_linear_strategy.h"
#include "solving_strategies/schemes/residualbased_incrementalupdate_static_scheme.h"
#include "solving_strategies/builder_and_solvers/residualbased_elimination_builder_and_solver.h"
#include "custom_strategies/builder_and_solvers/residualbased_block_builder_and_solver_periodic.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
template<class TSparseSpace,
         class TDenseSpace,
         class TLinearSolver
         >
class  StokesInitializationProcess : public Process
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION( StokesInitializationProcess);
 
 
    StokesInitializationProcess(ModelPart& rModelPart,
                                typename TLinearSolver::Pointer pLinearSolver,
                                unsigned int DomainSize,
                                const Variable<int>& PeriodicPairIndicesVar):
        Process(),
        mrReferenceModelPart(rModelPart),
        mpLinearSolver(pLinearSolver),
        mDomainSize(DomainSize)
    {
        KRATOS_TRY;
 
        if(!mrReferenceModelPart.GetModel().HasModelPart("StokesModelPart"))
            mrReferenceModelPart.GetModel().DeleteModelPart("StokesModelPart");
 
        ModelPart& r_stokes_part = mrReferenceModelPart.GetModel().CreateModelPart("StokesModelPart");
 
        r_stokes_part.GetNodalSolutionStepVariablesList() = mrReferenceModelPart.GetNodalSolutionStepVariablesList();
        r_stokes_part.SetBufferSize(1);
        r_stokes_part.SetNodes( mrReferenceModelPart.pNodes() );
        r_stokes_part.SetProcessInfo(mrReferenceModelPart.pGetProcessInfo());
        r_stokes_part.SetProperties(mrReferenceModelPart.pProperties());
 
        // Retrieve Stokes element model
        std::string ElementName;
        if (mDomainSize == 2)
            ElementName = std::string("StationaryStokes2D");
        else
            ElementName = std::string("StationaryStokes3D");
 
        const Element& rReferenceElement = KratosComponents<Element>::Get(ElementName);
 
        // Generate Stokes elements
        for (ModelPart::ElementsContainerType::const_iterator itElem = mrReferenceModelPart.ElementsBegin(); itElem != mrReferenceModelPart.ElementsEnd(); itElem++)
        {
            Element::Pointer pElem = rReferenceElement.Create(itElem->Id(), itElem->GetGeometry(), itElem->pGetProperties() );
            r_stokes_part.Elements().push_back(pElem);
        }
 
        // pointer types for the solution strategy construcion
        typedef typename Scheme< TSparseSpace, TDenseSpace >::Pointer SchemePointerType;
        typedef typename BuilderAndSolver<TSparseSpace, TDenseSpace, TLinearSolver>::Pointer BuilderSolverTypePointer;
        typedef typename ImplicitSolvingStrategy<TSparseSpace, TDenseSpace, TLinearSolver>::Pointer StrategyPointerType;
 
        // Solution scheme: Linear static scheme
        SchemePointerType pScheme = SchemePointerType( new ResidualBasedIncrementalUpdateStaticScheme< TSparseSpace, TDenseSpace > () );
 
        // Builder and solver
        BuilderSolverTypePointer pBuildAndSolver;
        pBuildAndSolver = BuilderSolverTypePointer(new ResidualBasedBlockBuilderAndSolverPeriodic<TSparseSpace, TDenseSpace, TLinearSolver > (mpLinearSolver,
                                                                                                                                              PeriodicPairIndicesVar));
 
 
        // Strategy
        bool ReactionFlag = false;
        bool ReformDofSetFlag = false;
        bool CalculateNormDxFlag = false;
        bool MoveMeshFlag = false;
        mpSolutionStrategy = StrategyPointerType(new ResidualBasedLinearStrategy<TSparseSpace, TDenseSpace, TLinearSolver>(
            r_stokes_part,
            pScheme,
            pBuildAndSolver,
            ReactionFlag,
            ReformDofSetFlag,
            CalculateNormDxFlag,
            MoveMeshFlag) );
        mpSolutionStrategy->SetEchoLevel(0);
        mpSolutionStrategy->Check();
 
        mIsCleared = false;
 
        KRATOS_CATCH("");
    }
 
 
    ~StokesInitializationProcess() override
    {
        mrReferenceModelPart.GetModel().DeleteModelPart("StokesModelPart");
       // mpSolutionStrategy->Clear();
    }
 
 
 
 
 
    void Execute() override
    {
        KRATOS_TRY;
 
        if (!mIsCleared)
        {
            // Solve Stokes problem.
            this->Solve();
 
            // Destroy the auxiliary ModelPart and solution structures.
            this->Clear();
        }
        else
        {
            KRATOS_THROW_ERROR(std::runtime_error,"Stokes initialization process was called twice","");
        }
 
        KRATOS_CATCH("");
    }
 
 
    void SetConditions(ModelPart& rStokesPart, ModelPart::ConditionsContainerType::Pointer pConditions)
    {
 
        ModelPart& r_stokes_part = mrReferenceModelPart.GetModel().GetModelPart("StokesModelPart");
        rStokesPart.SetConditions(pConditions);
        r_stokes_part.GetCommunicator().LocalMesh().SetConditions(pConditions);
    }
 
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << " StokesInitializationProcess";
        return buffer.str();
    }
 
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << " StokesInitializationProcess";
    }
 
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
 
 
 
protected:
 
 
 
    ModelPart& mrReferenceModelPart;
 
    typename TLinearSolver::Pointer mpLinearSolver;
 
    unsigned int mDomainSize;
 
    typename ImplicitSolvingStrategy<TSparseSpace, TDenseSpace, TLinearSolver>::Pointer mpSolutionStrategy;
 
    bool mIsCleared;
 
 
    StokesInitializationProcess(ModelPart& rModelPart,
                                typename TLinearSolver::Pointer pLinearSolver,
                                unsigned int DomainSize,
                                const StokesInitializationProcess* pThis):
        Process(),
        mrReferenceModelPart(rModelPart),
        mpLinearSolver(pLinearSolver),
        mDomainSize(DomainSize)
    {}
 
 
 
 
 
 
    // Solve Stokes problem.
    virtual void Solve()
    {
        KRATOS_TRY;
 
        mpSolutionStrategy->Solve();
 
        KRATOS_CATCH("");
    }
 
 
    // Liberate memory.
    void Clear() override
    {
        mpSolutionStrategy->Clear();
        mIsCleared = true;
    }
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    StokesInitializationProcess & operator=( StokesInitializationProcess const& rOther)
    {
        return *this;
    }
 
 
    StokesInitializationProcess( StokesInitializationProcess const& rOther)
    { }
 
 
 
}; // Class  StokesInitializationProcess
 
 
 
 
 
 
 
template<class TSparseSpace,
         class TDenseSpace,
         class TLinearSolver
         >
inline std::istream & operator >>(std::istream& rIStream,
                                  StokesInitializationProcess<TSparseSpace, TDenseSpace, TLinearSolver>& rThis)
{
    return rIStream;
}
 
 
template<class TSparseSpace,
         class TDenseSpace,
         class TLinearSolver
         >
inline std::ostream & operator <<(std::ostream& rOStream,
                                  const  StokesInitializationProcess<TSparseSpace, TDenseSpace, TLinearSolver>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
} // namespace Kratos.
 
 
#endif // KRATOS_STOKES_INITIALIZATION_PROCESS_H