data_value_container.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
 
#pragma once
 
// System includes
#include <string>
#include <iostream>
#include <cstddef>
#include <vector>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "containers/variable.h"
#include "includes/kratos_components.h"
#include "includes/exception.h"
 
#ifdef KRATOS_DEBUG
#include "utilities/openmp_utils.h"
#endif
 
namespace Kratos
{
 
 
 
 
 
 
class KRATOS_API(KRATOS_CORE) DataValueContainer
{
public:
    
    KRATOS_DEFINE_LOCAL_FLAG(OVERWRITE_OLD_VALUES);
 
    KRATOS_CLASS_POINTER_DEFINITION(DataValueContainer);
 
    using ValueType = std::pair<const VariableData*, void*>;
 
    using ContainerType = std::vector<ValueType>;
 
    using iterator = ContainerType::iterator;
 
    using const_iterator = ContainerType::const_iterator;
 
    using SizeType = ContainerType::size_type;
 
 
    DataValueContainer() {}
 
    DataValueContainer(DataValueContainer const& rOther)
    {
        for(const_iterator i = rOther.mData.begin() ; i != rOther.mData.end() ; ++i)
            mData.push_back(ValueType(i->first, i->first->Clone(i->second)));
    }
 
    virtual ~DataValueContainer()
    {
        for(iterator i = mData.begin() ; i != mData.end() ; ++i)
            i->first->Delete(i->second);
    }
 
 
    template<class TDataType> 
    const TDataType& operator()(const VariableData& rThisVariable) const
    {
        return GetValue<TDataType>(rThisVariable);
    }
 
    template<class TDataType> 
    TDataType& operator()(const Variable<TDataType>& rThisVariable)
    {
        return GetValue<TDataType>(rThisVariable);
    }
 
    template<class TDataType> 
    const TDataType& operator()(const Variable<TDataType>& rThisVariable) const
    {
        return GetValue<TDataType>(rThisVariable);
    }
 
    template<class TDataType> 
    TDataType& operator[](const VariableData& rThisVariable)
    {
        return GetValue<TDataType>(rThisVariable);
    }
 
    template<class TDataType> 
    const TDataType& operator[](const VariableData& rThisVariable) const
    {
        return GetValue<TDataType>(rThisVariable);
    }
 
    template<class TDataType> 
    TDataType& operator[](const Variable<TDataType>& rThisVariable)
    {
        return GetValue<TDataType>(rThisVariable);
    }
 
    template<class TDataType> 
    const TDataType& operator[](const Variable<TDataType>& rThisVariable) const
    {
        return GetValue<TDataType>(rThisVariable);
    }
 
    iterator begin()
    {
        return mData.begin();
    }
 
    const_iterator begin() const
    {
        return mData.begin();
    }
 
    iterator end()
    {
        return mData.end();
    }
 
    const_iterator end() const
    {
        return mData.end();
    }
 
    DataValueContainer& operator=(const DataValueContainer& rOther)
    {
        Clear();
 
        for(const_iterator i = rOther.mData.begin() ; i != rOther.mData.end() ; ++i)
            mData.push_back(ValueType(i->first, i->first->Clone(i->second)));
 
        return *this;
    }
 
 
    template<class TDataType> 
    TDataType& GetValue(const Variable<TDataType>& rThisVariable)
    {
        typename ContainerType::iterator i;
 
        if ((i = std::find_if(mData.begin(), mData.end(), IndexCheck(rThisVariable.SourceKey())))  != mData.end())
            return *(static_cast<TDataType*>(i->second) + rThisVariable.GetComponentIndex());
 
#ifdef KRATOS_DEBUG
        if(OpenMPUtils::IsInParallel() != 0)
            KRATOS_ERROR << "attempting to do a GetValue for: " << rThisVariable << " unfortunately the variable is not in the database and the operations is not threadsafe (this function is being called from within a parallel region)" << std::endl;
#endif
 
        auto p_source_variable = &rThisVariable.GetSourceVariable();
        mData.push_back(ValueType(p_source_variable,p_source_variable->Clone(p_source_variable->pZero())));
 
        return *(static_cast<TDataType*>(mData.back().second) + rThisVariable.GetComponentIndex());
    }
 
    template<class TDataType> 
    const TDataType& GetValue(const Variable<TDataType>& rThisVariable) const
    {
        typename ContainerType::const_iterator i;
 
        if ((i = std::find_if(mData.begin(), mData.end(), IndexCheck(rThisVariable.SourceKey())))  != mData.end())
            return *(static_cast<const TDataType*>(i->second) + rThisVariable.GetComponentIndex());
 
        return rThisVariable.Zero();
    }
 
    SizeType Size()
    {
        return mData.size();
    }
 
    template<class TDataType> 
    void SetValue(const Variable<TDataType>& rThisVariable, TDataType const& rValue)
    {
        typename ContainerType::iterator i;
 
        if ((i = std::find_if(mData.begin(), mData.end(), IndexCheck(rThisVariable.SourceKey())))  != mData.end()) {
            *(static_cast<TDataType*>(i->second) + rThisVariable.GetComponentIndex()) = rValue;
        } else {
            auto p_source_variable = &rThisVariable.GetSourceVariable();
            mData.push_back(ValueType(p_source_variable,p_source_variable->Clone(p_source_variable->pZero())));
            *(static_cast<TDataType*>(mData.back().second) + rThisVariable.GetComponentIndex()) = rValue;
        }
    }
 
    template<class TDataType> 
    void Erase(const Variable<TDataType>& rThisVariable)
    {
        typename ContainerType::iterator i;
 
        if ((i = std::find_if(mData.begin(), mData.end(), IndexCheck(rThisVariable.SourceKey()))) != mData.end()) {
            i->first->Delete(i->second);
            mData.erase(i);
        }
    }
 
    void Clear()
    {
        for(ContainerType::iterator i = mData.begin() ; i != mData.end() ; i++)
            i->first->Delete(i->second);
 
        mData.clear();
    }
 
    void Merge(const DataValueContainer& rOther, const Flags Options);
 
 
 
    template<class TDataType> 
    bool Has(const Variable<TDataType>& rThisVariable) const
    {
        return (std::find_if(mData.begin(), mData.end(), IndexCheck(rThisVariable.SourceKey())) != mData.end());
    }
 
    bool IsEmpty() const
    {
        return mData.empty();
    }
 
 
    virtual std::string Info() const
    {
        return std::string("data value container");
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << "data value container";
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
        for(const_iterator i = mData.begin() ; i != mData.end() ; ++i) {
            rOStream <<"    ";
            i->first->Print(i->second, rOStream);
            rOStream << std::endl;
        }
    }
 
 
protected:
 
 
 
 
 
 
 
private:
 
    class IndexCheck
    {
        std::size_t mI; 
 
    public:
 
        explicit IndexCheck(std::size_t I) : mI(I) {}
 
        bool operator()(const ValueType& I)
        {
            return I.first->SourceKey() == mI;
        }
    };
 
 
 
    ContainerType mData; 
 
 
 
 
    friend class Serializer;
 
    virtual void save(Serializer& rSerializer) const;
 
    virtual void load(Serializer& rSerializer);
 
 
 
 
}; // Class DataValueContainer
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  DataValueContainer& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const DataValueContainer& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}  // namespace Kratos.