periodic_variables_container.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Jordi Cotela Dalmau
//
//
 
#ifndef KRATOS_PERIODIC_VARIABLES_CONTAINER_H
#define KRATOS_PERIODIC_VARIABLES_CONTAINER_H
 
// System includes
#include <string>
#include <iostream>
 
 
// External includes
#include <boost/iterator/indirect_iterator.hpp>
 
// Project includes
#include "includes/define.h"
#include "includes/serializer.h"
#include "containers/variable.h"
 
 
namespace Kratos
{
 
 
 
 
 
 
 
class PeriodicVariablesContainer final
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(PeriodicVariablesContainer);
 
    typedef Variable<double> DoubleVariableType;
 
    typedef std::vector<const DoubleVariableType*> DoubleVariablesContainerType;
 
    typedef boost::indirect_iterator<DoubleVariablesContainerType::const_iterator> DoubleVariablesConstIterator;
 
    typedef std::size_t SizeType;
 
 
    PeriodicVariablesContainer():
        mPeriodicDoubleVars()
    {
    }
 
    PeriodicVariablesContainer(PeriodicVariablesContainer const& rOther):
        mPeriodicDoubleVars(rOther.mPeriodicDoubleVars)
    {
    }
 
    ~PeriodicVariablesContainer()
    {
    }
 
 
 
    PeriodicVariablesContainer& operator=(PeriodicVariablesContainer const& rOther)
    {
        this->mPeriodicDoubleVars = rOther.mPeriodicDoubleVars;
        return *this;
    }
 
 
    void Add(DoubleVariableType const& rThisVariable)
    {
        mPeriodicDoubleVars.push_back(&rThisVariable);
    }
 
    void Clear()
    {
        mPeriodicDoubleVars.clear();
    }
 
 
    DoubleVariablesConstIterator DoubleVariablesBegin() const
    {
        return DoubleVariablesConstIterator( mPeriodicDoubleVars.begin() );
    }
 
    DoubleVariablesConstIterator DoubleVariablesEnd() const
    {
        return DoubleVariablesConstIterator( mPeriodicDoubleVars.end() );
    }
 
    SizeType size() const
    {
        return mPeriodicDoubleVars.size();
    }
 
 
 
 
    std::string Info() const
    {
        std::stringstream buffer;
        buffer << "PeriodicVariablesContainer";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << "PeriodicVariablesContainer";
    }
 
    void PrintData(std::ostream& rOStream) const
    {
        rOStream << "Double Variables:" << std::endl;
        for (DoubleVariablesContainerType::const_iterator it = mPeriodicDoubleVars.begin(); it != mPeriodicDoubleVars.end(); ++it)
        {
            (*it)->PrintInfo(rOStream);
            rOStream << std::endl;
        }
    }
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    DoubleVariablesContainerType mPeriodicDoubleVars;
 
 
 
 
 
 
    friend class Serializer;
 
    virtual void save(Serializer& rSerializer) const
    {
        std::size_t DoubleVarSize= mPeriodicDoubleVars.size();
        rSerializer.save("DoubleVarSize",DoubleVarSize);
        for(std::size_t i = 0; i < DoubleVarSize; i++)
            rSerializer.save("Variable Name", mPeriodicDoubleVars[i]->Name());
    }
 
    virtual void load(Serializer& rSerializer)
    {
        std::string Name;
        std::size_t DoubleVarSize;
        rSerializer.load("DoubleVarSize",DoubleVarSize);
        for(std::size_t i = 0; i < DoubleVarSize; i++)
        {
            rSerializer.load("Variable Name", Name);
            Add( *(static_cast<DoubleVariableType*>(KratosComponents<VariableData>::pGet(Name))) );
        }
    }
 
 
 
 
 
 
 
 
}; // Class PeriodicVariablesContainer
 
 
 
 
 
 
inline std::istream & operator >>(std::istream& rIStream,
                                  PeriodicVariablesContainer& rThis)
{
    return rIStream;
}
 
inline std::ostream & operator <<(std::ostream& rOStream,
                                  const PeriodicVariablesContainer& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
} // namespace Kratos.
 
#endif  /* KRATOS_PERIODIC_VARIABLES_CONTAINER_H */