TpsaVector.hpp

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
  Copyright 2025 NORCE AS
 
  This file is part of the Open Porous Media project (OPM).
 
  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.
 
  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
 
  Consult the COPYING file in the top-level source directory of this
  module for the precise wording of the license and the list of
  copyright holders.
*/
#ifndef OPM_TPSA_VECTOR_HPP
#define OPM_TPSA_VECTOR_HPP
 
#include <opm/simulators/linalg/tpsa/TpsaTypes.hpp>
 
#include <dune/common/fvector.hh>
 
#include <array>
#include <cmath>
#include <cstddef>
 
namespace Opm::Linear
{
 
template <class ScalarT>
class TpsaVector
{
public:
    using Scalar = ScalarT;
 
    using field_type = ScalarT;
 
    using EqVector = Dune::FieldVector<Scalar, numTpsaEq>;
 
    using block_type = EqVector;
 
    using IstlVector = TpsaMultiVector<Scalar>;
 
    using size_type = std::size_t;
 
    class EntryProxy
    {
    public:
        EntryProxy(IstlVector& v, std::size_t dofIdx)
            : v_(&v)
            , i_(dofIdx)
        {
        }
 
        static constexpr std::size_t size()
        {
            return numTpsaEq;
        }
 
        Scalar& operator[](std::size_t eqIdx)
        {
            return at_(eqIdx);
        }
 
        Scalar operator[](std::size_t eqIdx) const
        {
            return at_(eqIdx);
        }
 
        operator EqVector() const;
 
        EntryProxy& operator=(Scalar value);
 
        EntryProxy& operator=(const EqVector& value);
 
        EntryProxy& operator=(const EntryProxy& other);
 
        EntryProxy& operator+=(const EqVector& value);
 
        EntryProxy& operator-=(const EqVector& value);
 
        EntryProxy& operator*=(Scalar factor);
 
    private:
        Scalar& at_(std::size_t eqIdx) const;
 
        IstlVector* v_;
        std::size_t i_;
    };
 
    TpsaVector() = default;
 
    explicit TpsaVector(std::size_t numDof)
    {
        resize(numDof);
    }
 
    void resize(std::size_t numDof);
 
    std::size_t size() const
    {
        return size_;
    }
 
    std::size_t N() const
    {
        return size_;
    }
 
    TpsaVector& operator=(Scalar value);
 
    TpsaVector& operator+=(const TpsaVector& other);
 
    TpsaVector& operator-=(const TpsaVector& other);
 
    TpsaVector& operator*=(Scalar factor);
 
    void scaleFields(const std::array<Scalar, numTpsaFields>& factors);
 
    Scalar one_norm() const;
 
    Scalar two_norm2() const;
 
    Scalar two_norm() const
    {
        return std::sqrt(two_norm2());
    }
 
    Scalar infinity_norm() const;
 
    EqVector operator[](std::size_t dofIdx) const;
 
    EntryProxy operator[](std::size_t dofIdx)
    {
        return EntryProxy(v_, dofIdx);
    }
 
    IstlVector& istlVector()
    {
        return v_;
    }
 
    const IstlVector& istlVector() const
    {
        return v_;
    }
 
private:
    IstlVector v_{};
    std::size_t size_{0};
};
 
} // namespace Opm::Linear
 
#endif // OPM_TPSA_VECTOR_HPP