Line data    Source code

       1              : // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
       2              : // SPDX-License-Identifier: Apache-2.0
       3              : 
       4              : #ifndef PALACE_LIBCEED_OPERATOR_HPP
       5              : #define PALACE_LIBCEED_OPERATOR_HPP
       6              : 
       7              : #include <memory>
       8              : #include <vector>
       9              : #include "fem/libceed/ceed.hpp"
      10              : #include "linalg/operator.hpp"
      11              : #include "linalg/vector.hpp"
      12              : 
      13              : namespace palace
      14              : {
      15              : 
      16              : class FiniteElementSpace;
      17              : 
      18              : namespace hypre
      19              : {
      20              : 
      21              : class HypreCSRMatrix;
      22              : 
      23              : }  // namespace hypre
      24              : 
      25              : namespace ceed
      26              : {
      27              : 
      28              : //
      29              : // Wrapper class for libCEED's CeedOperator, supporting composite operator construction and
      30              : // application with multiple threads.
      31              : //
      32              : class Operator : public palace::Operator
      33              : {
      34              : protected:
      35              :   std::vector<CeedOperator> op, op_t;
      36              :   std::vector<CeedVector> u, v;
      37              :   Vector dof_multiplicity;
      38              :   mutable Vector temp;
      39              : 
      40              : public:
      41              :   Operator(int h, int w);
      42              :   ~Operator() override;
      43              : 
      44              :   CeedOperator operator[](std::size_t i) const { return op[i]; }
      45              : 
      46              :   auto Size() const { return op.size(); }
      47              : 
      48              :   void AddSubOperator(CeedOperator sub_op, CeedOperator sub_op_t = nullptr);
      49              : 
      50              :   void Finalize();
      51              : 
      52              :   void DestroyAssemblyData() const;
      53              : 
      54          558 :   void SetDofMultiplicity(Vector &&mult) { dof_multiplicity = std::move(mult); }
      55              : 
      56              :   void AssembleDiagonal(Vector &diag) const override;
      57              : 
      58              :   void Mult(const Vector &x, Vector &y) const override;
      59              : 
      60              :   void AddMult(const Vector &x, Vector &y, const double a = 1.0) const override;
      61              : 
      62              :   void MultTranspose(const Vector &x, Vector &y) const override;
      63              : 
      64              :   void AddMultTranspose(const Vector &x, Vector &y, const double a = 1.0) const override;
      65              : };
      66              : 
      67              : // A symmetric ceed::Operator replaces *MultTranspose with *Mult (by default, libCEED
      68              : // operators do not have a transpose operation).
      69              : class SymmetricOperator : public Operator
      70              : {
      71              : public:
      72         5928 :   using Operator::Operator;
      73              : 
      74            0 :   void MultTranspose(const Vector &x, Vector &y) const override { Mult(x, y); }
      75            0 :   void AddMultTranspose(const Vector &x, Vector &y, double a = 1.0) const override
      76              :   {
      77            0 :     AddMult(x, y, a);
      78            0 :   }
      79              : };
      80              : 
      81              : // Assemble a ceed::Operator as a CSR matrix.
      82              : std::unique_ptr<hypre::HypreCSRMatrix> CeedOperatorFullAssemble(const Operator &op,
      83              :                                                                 bool skip_zeros, bool set);
      84              : 
      85              : // Construct a coarse-level ceed::Operator, reusing the quadrature data and quadrature
      86              : // function from the fine-level operator. Only available for square, symmetric operators
      87              : // (same input and output spaces).
      88              : std::unique_ptr<Operator> CeedOperatorCoarsen(const Operator &op_fine,
      89              :                                               const FiniteElementSpace &fespace_coarse);
      90              : 
      91              : }  // namespace ceed
      92              : 
      93              : }  // namespace palace
      94              : 
      95              : #endif  // PALACE_LIBCEED_OPERATOR_HPP