process_info.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
//
 
#if !defined( KRATOS_PROCESS_INFO_H_INCLUDED )
#define  KRATOS_PROCESS_INFO_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
#include <sstream>
#include <cstddef>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "containers/data_value_container.h"
#include "containers/flags.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
class KRATOS_API(KRATOS_CORE) ProcessInfo : public DataValueContainer, public Flags
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(ProcessInfo);
 
    typedef DataValueContainer BaseType;
 
    typedef std::size_t SizeType;
 
    typedef std::size_t IndexType;
 
 
    ProcessInfo() :
        BaseType(),
        Flags(),
        mIsTimeStep(true),
        mSolutionStepIndex(),
        mpPreviousSolutionStepInfo(),
        mpPreviousTimeStepInfo()
    {
    }
 
    ProcessInfo(const ProcessInfo& Other) :
        BaseType(Other),
        Flags(Other),
        mIsTimeStep(Other.mIsTimeStep),
        mSolutionStepIndex(Other.mSolutionStepIndex),
        mpPreviousSolutionStepInfo(Other.mpPreviousSolutionStepInfo),
        mpPreviousTimeStepInfo(Other.mpPreviousTimeStepInfo)
    {
    }
 
    ~ProcessInfo() override {}
 
 
 
    ProcessInfo& operator=(const ProcessInfo& rOther)
    {
        BaseType::operator=(rOther);
        Flags::operator=(rOther);
 
        mIsTimeStep = rOther.mIsTimeStep;
        mSolutionStepIndex = rOther.mSolutionStepIndex;
        mpPreviousSolutionStepInfo = rOther.mpPreviousSolutionStepInfo;
        mpPreviousTimeStepInfo = rOther.mpPreviousTimeStepInfo;
 
        return *this;
    }
 
 
    void CreateTimeStepInfo(IndexType SolutionStepIndex = 0)
    {
        CreateSolutionStepInfo(SolutionStepIndex);
        mIsTimeStep = true;
    }
 
    void CloneTimeStepInfo(IndexType SolutionStepIndex = 0)
    {
        CreateSolutionStepInfo(SolutionStepIndex);
        mIsTimeStep = true;
    }
 
    /*       void CloneTimeStepInfo(IndexType SolutionStepIndex, IndexType SourceSolutionStepIndex) */
    /*  { */
    /*    CloneSolutionStepInfo(SolutionStepIndex, SourceSolutionStepIndex); */
    /*    mIsTimeStep = true; */
    /*  } */
 
    void CloneTimeStepInfo(IndexType SolutionStepIndex, ProcessInfo const &  SourceSolutionStepInfo)
    {
        CloneSolutionStepInfo(SolutionStepIndex, SourceSolutionStepInfo);
        mIsTimeStep = true;
    }
 
    void CreateTimeStepInfo(double NewTime, IndexType SolutionStepIndex = 0)
    {
        CreateTimeStepInfo(SolutionStepIndex);
        SetCurrentTime(NewTime);
    }
 
    void CloneTimeStepInfo(double NewTime, IndexType SourceSolutionStepIndex = 0)
    {
        CloneTimeStepInfo(SourceSolutionStepIndex);
        SetCurrentTime(NewTime);
    }
 
    /*       void CloneTimeStepInfo(double NewTime, IndexType SolutionStepIndex = 0) */
    /*  { */
    /*    CloneTimeStepInfo(SolutionStepIndex); */
    /*    SetCurrentTime(NewTime); */
    /*  } */
 
    /*       void CloneTimeStepInfo(double NewTime, IndexType SolutionStepIndex = 0, IndexType SourceSolutionStepIndex = 0) */
    /*  { */
    /*    CloneTimeStepInfo(SolutionStepIndex, SourceSolutionStepIndex); */
    /*    SetCurrentTime(NewTime); */
    /*  } */
 
    void CloneTimeStepInfo(double NewTime, IndexType SolutionStepIndex, ProcessInfo const &  SourceSolutionStepInfo)
    {
        CloneTimeStepInfo(SolutionStepIndex, SourceSolutionStepInfo);
        SetCurrentTime(NewTime);
    }
 
    void SetAsTimeStepInfo();
 
    void SetAsTimeStepInfo(double NewTime);
 
    ProcessInfo::Pointer pGetPreviousTimeStepInfo(IndexType StepsBefore = 1);
 
    const ProcessInfo::Pointer pGetPreviousTimeStepInfo(IndexType StepsBefore = 1) const;
 
    ProcessInfo& GetPreviousTimeStepInfo(IndexType StepsBefore = 1)
    {
        return *pGetPreviousTimeStepInfo(StepsBefore);
    }
 
    ProcessInfo const& GetPreviousTimeStepInfo(IndexType StepsBefore = 1) const
    {
        return *pGetPreviousTimeStepInfo(StepsBefore);
    }
 
    IndexType GetPreviousTimeStepIndex(IndexType StepsBefore = 1) const
    {
        return GetPreviousTimeStepInfo(StepsBefore).GetSolutionStepIndex();
    }
 
 
    void SetCurrentTime(double NewTime);
 
    void ReIndexBuffer(SizeType BufferSize, IndexType BaseIndex = 0);
 
 
 
    void CreateSolutionStepInfo(IndexType SolutionStepIndex = 0);
 
//       void CloneSolutionStepInfo(IndexType SolutionStepIndex = 0)
//  {
//    mpPreviousSolutionStepInfo = Pointer(new ProcessInfo(*this));
//    mSolutionStepIndex = SolutionStepIndex;
//    if(mIsTimeStep)
//      mpPreviousTimeStepInfo = mpPreviousSolutionStepInfo;
//    mIsTimeStep = false;
//  }
 
//       void CloneSolutionStepInfo(IndexType SolutionStepIndex = 0, IndexType SourceSolutionStepIndex = 0)
//  {
//    ProcessInfo& source_info = FindSolutionStepInfo(SourceSolutionStepIndex);
//    if(source_info.GetSolutionStepIndex() == SourceSolutionStepIndex)
//      {
//        mpPreviousSolutionStepInfo = Pointer(new ProcessInfo(*this));
//        mSolutionStepIndex = SolutionStepIndex;
//        BaseType::operator=(source_info);
//        if(mIsTimeStep)
//      mpPreviousTimeStepInfo = mpPreviousSolutionStepInfo;
//        mIsTimeStep = false;
//      }
//    else
//      CreateSolutionStepInfo(SolutionStepIndex);
//  }
 
    void CloneSolutionStepInfo();
 
    void CloneSolutionStepInfo(IndexType SourceSolutionStepIndex);
 
    void CloneSolutionStepInfo(IndexType SolutionStepIndex, ProcessInfo const &  SourceSolutionStepInfo);
 
    ProcessInfo& FindSolutionStepInfo(IndexType ThisIndex);
 
    void RemoveSolutionStepInfo(IndexType SolutionStepIndex);
 
    void ClearHistory(IndexType StepsBefore = 0);
 
    ProcessInfo::Pointer pGetPreviousSolutionStepInfo(IndexType StepsBefore = 1);
 
    const ProcessInfo::Pointer pGetPreviousSolutionStepInfo(IndexType StepsBefore = 1) const;
 
    ProcessInfo& GetPreviousSolutionStepInfo(IndexType StepsBefore = 1)
    {
        return *pGetPreviousSolutionStepInfo(StepsBefore);
    }
 
    ProcessInfo const& GetPreviousSolutionStepInfo(IndexType StepsBefore = 1) const
    {
        return *pGetPreviousSolutionStepInfo(StepsBefore);
    }
 
    IndexType GetPreviousSolutionStepIndex(IndexType StepsBefore = 1) const
    {
        return GetPreviousSolutionStepInfo(StepsBefore).GetSolutionStepIndex();
    }
 
 
    IndexType GetSolutionStepIndex() const
    {
        return mSolutionStepIndex;
    }
 
    void SetSolutionStepIndex(IndexType NewIndex)
    {
        mSolutionStepIndex = NewIndex;
    }
 
 
 
 
    std::string Info() const override
    {
        return "Process Info";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << "    Current solution step index : " << mSolutionStepIndex << std::endl;
        BaseType::PrintData(rOStream);
    }
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    bool mIsTimeStep;
 
    IndexType mSolutionStepIndex;
 
    ProcessInfo::Pointer mpPreviousSolutionStepInfo;
 
    ProcessInfo::Pointer mpPreviousTimeStepInfo;
 
 
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override;
 
    void load(Serializer& rSerializer) override;
 
 
 
 
 
 
 
 
}; // Class ProcessInfo
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  ProcessInfo& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const ProcessInfo& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_PROCESS_INFO_H_INCLUDED  defined