time_averaging_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Suneth Warnakulasuriya (https://github.com/sunethwarna)
//                   Riccardo Tosi
//
 
#if !defined(KRATOS_TIME_AVERAGING_PROCESS_H_INCLUDED)
#define KRATOS_TIME_AVERAGING_PROCESS_H_INCLUDED
 
// System includes
#include <functional>
#include <string>
#include <vector>
 
// External includes
 
// Project includes
#include "containers/model.h"
#include "processes/process.h"
 
namespace Kratos
{
 
 
 
 
 
 
class KRATOS_API(KRATOS_CORE) TimeAveragingProcess : public Process
{
public:
 
    using NodeType = ModelPart::NodeType;
    using ElementType = ModelPart::ElementType;
 
    KRATOS_CLASS_POINTER_DEFINITION(TimeAveragingProcess);
 
 
 
    TimeAveragingProcess(Model& rModel, Parameters rParameters);
 
    ~TimeAveragingProcess() override;
 
 
 
    int Check() override;
 
    void ExecuteInitialize() override;
 
    void ExecuteFinalizeSolutionStep() override;
 
    const Parameters GetDefaultParameters() const override;
 
 
 
 
    std::string Info() const override;
 
    void PrintInfo(std::ostream& rOStream) const override;
 
    void PrintData(std::ostream& rOStream) const override;
 
 
 
protected:
 
 
 
 
 
 
 
 
private:
 
 
    Model& mrModel;
    Parameters mrParameters;
 
    std::string mModelPartName;
    std::string mIntegrationControlVariableName;
    enum TimeAveragingContainers
    {
        NodalHistorical,
        NodalNonHistorical,
        ElementalNonHistorical
    };
    TimeAveragingContainers mTimeAveragingContainer;
    enum TimeAveragingMethods
    {
        Average,
        RootMeanSquare
    };
    TimeAveragingMethods mTimeAveragingMethod;
 
    std::vector<std::string> mVariableNamesList;
    std::vector<std::string> mAveragedVariableNamesList;
 
    int mEchoLevel;
 
    double mCurrentTime;
 
 
    bool IsIntegrationStep() const;
 
    template <typename TDataType>
    void CalculateTimeIntegratedNodalHistoricalQuantity(ModelPart::NodesContainerType& rNodes,
                                                        const Variable<TDataType>& rVariable,
                                                        const Variable<TDataType>& rAveragedVariable,
                                                        const double DeltaTime) const;
 
    template <typename TDataType, typename TContainerType>
    void CalculateTimeIntegratedNonHistoricalQuantity(
        TContainerType& rContainer,
        const Variable<TDataType>& rVariable,
        const Variable<TDataType>& rAveragedVariable,
        const double DeltaTime) const;
 
    template <typename TDataType>
    void AverageMethod(const TDataType& rTemporalVariable,
                       TDataType& rAveragedVariable,
                       const double DeltaTime) const;
 
    template <typename TDataType>
    void RootMeanSquareMethod(const TDataType& rTemporalVariable,
                              TDataType& rAveragedVariable,
                              const double DeltaTime) const;
 
    template <typename TDataType>
    std::function<void(const TDataType&, TDataType&, const double)> GetTimeAveragingMethod() const;
 
 
 
 
    TimeAveragingProcess& operator=(TimeAveragingProcess const& rOther);
 
    TimeAveragingProcess(TimeAveragingProcess const& rOther);
 
 
}; // Class TimeAveragingProcess
 
 
 
 
inline std::ostream& operator<<(std::ostream& rOStream, const TimeAveragingProcess& rThis);
 
 
 
} // namespace Kratos.
 
#endif // KRATOS_TIME_AVERAGING_PROCESS_H_INCLUDED defined