MultiVariable.h

Go to the documentation of this file.

#ifndef included_AMP_MultiVariable_h
#define included_AMP_MultiVariable_h
 
#include "AMP/vectors/Variable.h"
#include "AMP/vectors/VectorSelector.h"
 
#include <vector>
 
 
namespace AMP::LinearAlgebra {
 
 
class MultiVariable final : public Variable
{
public:
    inline auto begin() { return d_vVariables.begin(); }
 
    inline auto end() { return d_vVariables.end(); }
 
    inline auto begin() const { return d_vVariables.begin(); }
 
    inline auto end() const { return d_vVariables.end(); }
 
    void removeDuplicateVariables();
 
    explicit MultiVariable( const std::string &name,
                            std::vector<std::shared_ptr<Variable>> vars = {} );
 
    explicit MultiVariable( std::shared_ptr<Variable> var );
 
 
    virtual std::shared_ptr<Variable> getVariable( size_t which );
 
    virtual std::shared_ptr<const Variable> getVariable( size_t which ) const;
 
    virtual size_t numVariables() const;
 
    virtual void add( std::shared_ptr<Variable> newVar );
 
    virtual void setVariable( size_t i, std::shared_ptr<Variable> &var );
 
    // These are adequately documented elsewhere.
    virtual bool operator==( const Variable &rhs ) const override;
    virtual std::shared_ptr<Variable> clone( const std::string &name ) const override;
    virtual void setUnits( const Units &units ) override;
 
 
public: // Default constructors
    MultiVariable() : Variable() {}
    MultiVariable( MultiVariable && )      = default;
    MultiVariable( const MultiVariable & ) = default;
    MultiVariable &operator=( MultiVariable && ) = default;
    MultiVariable &operator=( const MultiVariable & ) = default;
    virtual ~MultiVariable()                          = default;
 
public: // Functions inherited from Variable
    std::string className() const override { return "MultiVariable"; }
    std::shared_ptr<VectorSelector> createVectorSelector() const override;
    void writeRestart( int64_t ) const override;
    MultiVariable( int64_t, AMP::IO::RestartManager *manager );
    void registerChildObjects( AMP::IO::RestartManager *manager ) const override;
 
protected:
    std::vector<std::shared_ptr<Variable>> d_vVariables;
};
 
 
class VS_MultiVariable : public VectorSelector
{
 
public:
    explicit VS_MultiVariable( const std::shared_ptr<MultiVariable> &var );
 
    std::string getName() const;
 
public: // Functions inherited from VectorSelector
    bool isSelected( const Vector & ) const override;
    Vector::shared_ptr subset( Vector::shared_ptr vec ) const override;
 
protected:
    std::shared_ptr<MultiVariable> d_var;
};
 
 
} // namespace AMP::LinearAlgebra
 
 
#endif