Line data    Source code

       1             : // rbOOmit: An implementation of the Certified Reduced Basis method.
       2             : // Copyright (C) 2009, 2010 David J. Knezevic
       3             : 
       4             : // This file is part of rbOOmit.
       5             : 
       6             : // rbOOmit is free software; you can redistribute it and/or
       7             : // modify it under the terms of the GNU Lesser General Public
       8             : // License as published by the Free Software Foundation; either
       9             : // version 2.1 of the License, or (at your option) any later version.
      10             : 
      11             : // rbOOmit is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             : // Lesser General Public License for more details.
      15             : 
      16             : // You should have received a copy of the GNU Lesser General Public
      17             : // License along with this library; if not, write to the Free Software
      18             : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      19             : 
      20             : #ifndef LIBMESH_RB_ASSEMBLY_EXPANSION_H
      21             : #define LIBMESH_RB_ASSEMBLY_EXPANSION_H
      22             : 
      23             : // libMesh includes
      24             : #include "libmesh/reference_counted_object.h"
      25             : 
      26             : // C++ includes
      27             : #include <vector>
      28             : #include <memory>
      29             : 
      30             : namespace libMesh
      31             : {
      32             : 
      33             : // Forward declarations
      34             : class ElemAssembly;
      35             : class FEMContext;
      36             : 
      37             : /**
      38             :  * This class stores the set of ElemAssembly functor objects that define
      39             :  * the "parameter-independent expansion" of a PDE.
      40             :  *
      41             :  * \author David J. Knezevic
      42             :  * \date 2011
      43             :  */
      44             : class RBAssemblyExpansion : public ReferenceCountedObject<RBAssemblyExpansion>
      45             : {
      46             : public:
      47             : 
      48             :   /**
      49             :    * All special functions can be defaulted for this simple class.
      50             :    */
      51             :   RBAssemblyExpansion() = default;
      52             :   RBAssemblyExpansion (RBAssemblyExpansion &&) = default;
      53             :   RBAssemblyExpansion (const RBAssemblyExpansion &) = default;
      54             :   RBAssemblyExpansion & operator= (const RBAssemblyExpansion &) = default;
      55             :   RBAssemblyExpansion & operator= (RBAssemblyExpansion &&) = default;
      56           0 :   virtual ~RBAssemblyExpansion () = default;
      57             : 
      58             :   /**
      59             :    * Perform the specified A interior assembly.
      60             :    */
      61             :   void perform_A_interior_assembly(unsigned int q,
      62             :                                    FEMContext & context) const;
      63             : 
      64             :   /**
      65             :    * Perform the specified A boundary assembly.
      66             :    */
      67             :   void perform_A_boundary_assembly(unsigned int q,
      68             :                                    FEMContext & context) const;
      69             : 
      70             :   /**
      71             :    * Perform the specified F interior assembly.
      72             :    */
      73             :   void perform_F_interior_assembly(unsigned int q,
      74             :                                    FEMContext & context) const;
      75             : 
      76             :   /**
      77             :    * Perform the specified F boundary assembly.
      78             :    */
      79             :   void perform_F_boundary_assembly(unsigned int q,
      80             :                                    FEMContext & context) const;
      81             : 
      82             :   /**
      83             :    * Perform the specified output assembly.
      84             :    */
      85             :   void perform_output_interior_assembly(unsigned int output_index,
      86             :                                         unsigned int q_l,
      87             :                                         FEMContext & context) const;
      88             : 
      89             :   /**
      90             :    * Perform the specified output assembly.
      91             :    */
      92             :   void perform_output_boundary_assembly(unsigned int output_index,
      93             :                                         unsigned int q_l,
      94             :                                         FEMContext & context) const;
      95             : 
      96             :   /**
      97             :    * Get Q_a, the number of terms in the affine
      98             :    * expansion for the bilinear form.
      99             :    */
     100             :   unsigned int get_n_A_terms() const;
     101             : 
     102             :   /**
     103             :    * Get Q_f, the number of terms in the affine
     104             :    * expansion for the right-hand side.
     105             :    */
     106             :   unsigned int get_n_F_terms() const;
     107             : 
     108             :   /**
     109             :    * Get n_outputs, the number output functionals.
     110             :    */
     111             :   unsigned int get_n_outputs() const;
     112             : 
     113             :   /**
     114             :    * Get the number of affine terms associated with the specified output.
     115             :    */
     116             :   unsigned int get_n_output_terms(unsigned int output_index) const;
     117             : 
     118             :   /**
     119             :    * Attach ElemAssembly object for the left-hand side
     120             :    * (both interior and boundary assembly).
     121             :    */
     122             :   void attach_A_assembly(ElemAssembly * Aq_assembly);
     123             : 
     124             :   /**
     125             :    * Attach multiple ElemAssembly objects for the left-hand side
     126             :    * (both interior and boundary assembly).
     127             :    */
     128             :   void attach_multiple_A_assembly(std::vector<std::unique_ptr<ElemAssembly>> & Aq_assembly);
     129             : 
     130             :   /**
     131             :    * Attach ElemAssembly object for the right-hand side
     132             :    * (both interior and boundary assembly).
     133             :    */
     134             :   void attach_F_assembly(ElemAssembly * Fq_assembly);
     135             : 
     136             :   /**
     137             :    * Attach multiple ElemAssembly objects for the right-hand side
     138             :    * (both interior and boundary assembly).
     139             :    */
     140             :   void attach_multiple_F_assembly(std::vector<std::unique_ptr<ElemAssembly>> & Fq_assembly);
     141             : 
     142             :   /**
     143             :    * Attach ElemAssembly object for an output
     144             :    * (both interior and boundary assembly).
     145             :    * In this case we pass in vector arguments to allow for Q_l > 1.
     146             :    */
     147             :   virtual void attach_output_assembly(std::vector<std::unique_ptr<ElemAssembly>> & output_assembly);
     148             : 
     149             :   /**
     150             :    * Attach ElemAssembly object for an output
     151             :    * (both interior and boundary assembly).
     152             :    * In this case we pass in vector arguments to allow for Q_l > 1.
     153             :    */
     154             :   virtual void attach_output_assembly(std::vector<ElemAssembly *> output_assembly);
     155             : 
     156             :   /**
     157             :    * Attach ElemAssembly object for an output
     158             :    * (both interior and boundary assembly).
     159             :    * This function provides simpler syntax in the case that Q_l = 1; we
     160             :    * do not need to use a vector in this case.
     161             :    */
     162             :   virtual void attach_output_assembly(ElemAssembly * output_assembly);
     163             : 
     164             :   /**
     165             :    * Return a reference to the specified A_assembly object.
     166             :    */
     167             :   ElemAssembly & get_A_assembly(unsigned int q);
     168             : 
     169             :   /**
     170             :    * Return a reference to the specified F_assembly object.
     171             :    */
     172             :   ElemAssembly & get_F_assembly(unsigned int q);
     173             : 
     174             :   /**
     175             :    * Return a reference to the specified output assembly object.
     176             :    */
     177             :   ElemAssembly & get_output_assembly(unsigned int output_index, unsigned int q_l);
     178             : 
     179             : private:
     180             : 
     181             :   /**
     182             :    * Vectors storing the function pointers to the assembly
     183             :    * routines for the affine operators, both interior and boundary
     184             :    * assembly.
     185             :    */
     186             :   std::vector<ElemAssembly *> _A_assembly_vector;
     187             : 
     188             :   /**
     189             :    * Vector storing the function pointers to the assembly
     190             :    * routines for the rhs affine vectors.
     191             :    */
     192             :   std::vector<ElemAssembly *> _F_assembly_vector;
     193             : 
     194             :   /**
     195             :    * Vector storing the function pointers to the assembly
     196             :    * routines for the outputs. Element interior part.
     197             :    */
     198             :   std::vector<std::vector<ElemAssembly *>> _output_assembly_vector;
     199             : };
     200             : 
     201             : }
     202             : 
     203             : #endif // LIBMESH_RB_ASSEMBLY_EXPANSION_H