variable.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//                   Riccardo Rossi
//  Collaborator:    Vicente Mataix Ferrandiz
//
//
 
#if !defined(KRATOS_VARIABLE_H_INCLUDED )
#define  KRATOS_VARIABLE_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/registry.h"
#include "variable_data.h"
#include "utilities/stl_vector_io.h"
 
namespace Kratos
{
 
 
 
 
 
 
template<class TDataType>
class Variable : public VariableData
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(Variable);
 
    typedef TDataType Type;
 
    // Type used for key values which defined in VariableData
    typedef VariableData::KeyType KeyType;
 
    // Type of this varible with given TDataType
    typedef Variable<TDataType> VariableType;
 
 
    explicit Variable(
        const std::string& NewName,
        const TDataType Zero = TDataType(),
        const VariableType* pTimeDerivativeVariable = nullptr
        )
        : VariableData(NewName, sizeof(TDataType)),
          mZero(Zero),
          mpTimeDerivativeVariable(pTimeDerivativeVariable)
    {
        RegisterThisVariable();
    }
    explicit Variable(
        const std::string& NewName,
        const VariableType* pTimeDerivativeVariable
        )
        : VariableData(NewName, sizeof(TDataType)),
          mZero(TDataType()),
          mpTimeDerivativeVariable(pTimeDerivativeVariable)
    {
         RegisterThisVariable();
   }
 
    template<typename TSourceVariableType>
    explicit Variable(
        const std::string& rNewName,
        TSourceVariableType* pSourceVariable,
        char ComponentIndex,
        const TDataType Zero = TDataType()
        )
        : VariableData(rNewName, sizeof(TDataType), pSourceVariable, ComponentIndex),
          mZero(Zero)
    {
        RegisterThisVariable();
    }
 
    template<typename TSourceVariableType>
    explicit Variable(
        const std::string& rNewName,
        TSourceVariableType* pSourceVariable,
        char ComponentIndex,
        const VariableType* pTimeDerivativeVariable,
        const TDataType Zero = TDataType()
        )
        : VariableData(rNewName, sizeof(TDataType), pSourceVariable, ComponentIndex),
          mZero(Zero),
          mpTimeDerivativeVariable(pTimeDerivativeVariable)
    {
        RegisterThisVariable();
    }
 
    explicit Variable(const VariableType& rOtherVariable) :
        VariableData(rOtherVariable),
        mZero(rOtherVariable.mZero),
        mpTimeDerivativeVariable(rOtherVariable.mpTimeDerivativeVariable)
    {
        // Here we don't register as we asume that the origin is already registered
    }
 
    ~Variable() override {}
 
 
    VariableType& operator=(const VariableType& rOtherVariable) = delete;
 
 
    void* Clone(const void* pSource) const override
    {
        return new TDataType(*static_cast<const TDataType* >(pSource) );
    }
 
    void* Copy(const void* pSource, void* pDestination) const override
    {
        return new(pDestination) TDataType(*static_cast<const TDataType* >(pSource) );
    }
 
    void Assign(const void* pSource, void* pDestination) const override
    {
        (*static_cast<TDataType* >(pDestination) ) = (*static_cast<const TDataType* >(pSource) );
    }
 
    void AssignZero(void* pDestination) const override
    {
        //(*static_cast<TDataType* >(pDestination) ) = mZero;
        new (pDestination) TDataType(mZero);
    }
 
    void Delete(void* pSource) const override
    {
        delete static_cast<TDataType* >(pSource);
    }
 
    void Destruct(void* pSource) const override
    {
        static_cast<TDataType* >(pSource)->~TDataType();
    }
 
    void Print(const void* pSource, std::ostream& rOStream) const override
    {
        if(IsComponent()) {
            rOStream << Name() << " component of " <<  GetSourceVariable().Name() << " variable : " <<  *static_cast<const TDataType* >(pSource) ;
        }
        else {
            rOStream << Name() << " : " << *static_cast<const TDataType* >(pSource) ;
        }
    }
 
    void PrintData(const void* pSource, std::ostream& rOStream) const override
    {
        rOStream <<  *static_cast<const TDataType* >(pSource) ;
    }
 
    void Save(Serializer& rSerializer, void* pData) const override
    {
        // I'm saving by the value, it can be done by the pointer to detect shared data. Pooyan.
        rSerializer.save("Data",*static_cast<TDataType* >(pData));
    }
 
    void Allocate(void** pData) const override
    {
        *pData = new TDataType;
    }
 
    void Load(Serializer& rSerializer, void* pData) const override
    {
        rSerializer.load("Data",*static_cast<TDataType* >(pData));
    }
 
    static const VariableType& StaticObject()
    {
        const static Variable<TDataType> static_object("NONE");
        return static_object;
    }
 
    TDataType& GetValue(void* pSource) const
    {
        return GetValueByIndex(static_cast<TDataType*>(pSource),GetComponentIndex());
    }
 
    const TDataType& GetValue(const void* pSource) const
    {
        return GetValueByIndex(static_cast<TDataType*>(pSource),GetComponentIndex());
    }
 
 
    const VariableType& GetTimeDerivative() const
    {
        KRATOS_DEBUG_ERROR_IF(mpTimeDerivativeVariable == nullptr) << "Time derivative for Variable \"" << Name() << "\" was not assigned" << std::endl;
        return *mpTimeDerivativeVariable;
    }
 
    const TDataType& Zero() const
    {
        return mZero;
    }
 
    const void* pZero() const override {
       return &mZero;
    }
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << Name() << " variable" <<" #" << static_cast<unsigned int>(Key());
        if(IsComponent()){
            buffer << Name() << " variable #" << static_cast<unsigned int>(Key()) << " component " << GetComponentIndex() << " of " <<  GetSourceVariable().Name();
        }
        else {
            buffer << Name() << " variable #" << static_cast<unsigned int>(Key());
        }
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override{
        VariableData::PrintData(rOStream);
    }
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
    static const VariableType msStaticObject;               
 
 
    TDataType mZero;                                        
 
    const VariableType* mpTimeDerivativeVariable = nullptr; 
 
 
 
 
 
    template<typename TValueType>
    TDataType& GetValueByIndex(TValueType* pValue, std::size_t index) const
    {
        return *static_cast<TDataType*>(pValue + index);
    }
 
    template<typename TValueType>
    const TDataType& GetValueByIndex(const TValueType* pValue, std::size_t index) const
    {
        return *static_cast<const TDataType*>(pValue + index);
    }
 
    void RegisterThisVariable(){
        std::string variable_path = "variables.all." + Name();
        if(!Registry::HasItem(variable_path)){
            Registry::AddItem<VariableType>(variable_path, *this);
        }
    }
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, VariableData );
        rSerializer.save("Zero",mZero);
        rSerializer.save("TimeDerivativeVariable",mpTimeDerivativeVariable);
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, VariableData );
        rSerializer.load("Zero",mZero);
        rSerializer.load("TimeDerivativeVariable",mpTimeDerivativeVariable);
    }
 
 
 
 
 
 
    Variable() {}
 
 
}; // Class Variable
 
 
 
 
 
 
template<class TDataType>
inline std::istream& operator >> (std::istream& rIStream,
                                  Variable<TDataType>& rThis);
 
template<class TDataType>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const Variable<TDataType>& rThis)
{
    rThis.PrintInfo(rOStream);
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}  // namespace Kratos.
 
#endif // KRATOS_VARIABLE_H_INCLUDED  defined