LinearFunction.H

Go to the documentation of this file.

/* Copyright 2025 Debojyoti Ghosh
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef LinearFunction_H_
#define LinearFunction_H_
 
#include "Preconditioner.H"
 
#include <string>

 
template <class T, class Ops>
class LinearFunction
{
    public:
 
        using RT = typename T::value_type;

        LinearFunction() = default;
        virtual ~LinearFunction() = default;
 
        // Default move and copy operations
        LinearFunction(const LinearFunction&) = default;
        LinearFunction& operator=(const LinearFunction&) = default;
        LinearFunction(LinearFunction&&) noexcept = default;
        LinearFunction& operator=(LinearFunction&&) noexcept = default;

        virtual void apply ( T& a_dF, const T& a_dU ) = 0;

        virtual void precond ( T& a_U, const T& a_X ) = 0;

        virtual void updatePreCondMat ( const T&  a_X ) = 0;

        virtual void getPCMatrix( amrex::Gpu::DeviceVector<int>&,
                                  amrex::Gpu::DeviceVector<int>&,
                                  amrex::Gpu::DeviceVector<int>&,
                                  amrex::Gpu::DeviceVector<RT>&,
                                  int&, int& ) = 0;

        inline void create ( T& a_Z, const T& a_U )
        {
            a_Z.define(a_U);
        }

        virtual T makeVecLHS () const = 0;

        virtual T makeVecRHS () const = 0;

        inline void assign( T& a_Z, const T& a_U ) {
            a_Z.Copy(a_U);
        }

        inline void increment( T& a_Z, const T& a_U, RT a_scale )
        {
            a_Z.increment(a_U,a_scale);
        }

        inline void scale ( T& a_U, RT a_scale )
        {
            a_U.scale(a_scale);
        }

        inline void linComb ( T& a_U, RT a, const T& X, RT b, const T& Y )
        {
            a_U.linComb( a, X, b, Y );
        }

        inline void setToZero ( T& a_U )
        {
            a_U.zero();
        }

        inline void setVal ( T& a_U, RT a_val )
        {
            a_U.setVal(a_val);
        }

        inline RT dotProduct( const T& a_X, const T& a_Y )
        {
            return( a_X.dotProduct(a_Y) );
        }

        inline RT norm2( const T& a_U )
        {
            return ( a_U.norm2() );
        }

        virtual void define( const T&, Ops*, const PreconditionerType& ) = 0;

        virtual PreconditionerType pcType () const = 0;
 
    protected:
 
    private:
 
};
 
#endif