Line data    Source code

       1             : /**********************************************************************/
       2             : /*                     DO NOT MODIFY THIS HEADER                      */
       3             : /* MAGPIE - Mesoscale Atomistic Glue Program for Integrated Execution */
       4             : /*                                                                    */
       5             : /*            Copyright 2017 Battelle Energy Alliance, LLC            */
       6             : /*                        ALL RIGHTS RESERVED                         */
       7             : /**********************************************************************/
       8             : 
       9             : #pragma once
      10             : 
      11             : #include "MooseVariable.h"
      12             : 
      13             : class MooseFFTVariable : public MooseVariable
      14             : {
      15             : public:
      16             :   static InputParameters validParams();
      17             : 
      18             :   MooseFFTVariable(const InputParameters & parameters);
      19             : 
      20          18 :   virtual bool isNodal() const { return false; }
      21             : 
      22             :   /**
      23             :    * Clear out the dof indices.  We do this in case this variable is not going to be prepared at
      24             :    * all...
      25             :    */
      26           0 :   virtual void clearDofIndices() {}
      27             : 
      28             :   /**
      29             :    * Prepare the elemental degrees of freedom
      30             :    */
      31           0 :   virtual void prepare() {}
      32             : 
      33             :   /**
      34             :    * Prepare the neighbor element degrees of freedom
      35             :    */
      36           0 :   virtual void prepareNeighbor() { mooseError("Neighbor FFT variables are not supported yet."); }
      37             : 
      38             :   /**
      39             :    * Prepare a lower dimensional element's degrees of freedom
      40             :    */
      41           0 :   virtual void prepareLowerD()
      42             :   {
      43           0 :     mooseError("Lower dimensional FFT variables are not supported yet.");
      44             :   }
      45             : 
      46           0 :   virtual void prepareAux() {}
      47             : 
      48           0 :   virtual void reinitNode() {}
      49           0 :   virtual void reinitAux() {}
      50           0 :   virtual void reinitAuxNeighbor() { mooseError("Neighbor FFT variables are not supported yet."); }
      51             : 
      52           0 :   virtual void reinitNodes(const std::vector<dof_id_type> &)
      53             :   {
      54           0 :     mooseError("Nodal FFT variables are not supported.");
      55             :   }
      56           0 :   virtual void reinitNodesNeighbor(const std::vector<dof_id_type> &)
      57             :   {
      58           0 :     mooseError("Nodal FFT variables are not supported.");
      59             :   }
      60             : 
      61             :   /**
      62             :    * Field type of this variable
      63             :    */
      64           0 :   virtual Moose::VarFieldType fieldType() const { return Moose::VarFieldType::VAR_FIELD_STANDARD; }
      65             : 
      66             :   /**
      67             :    * @returns true if this is a vector-valued element, false otherwise.
      68             :    */
      69           0 :   virtual bool isVector() const { return false; };
      70             : 
      71             :   /**
      72             :    * Is this variable defined at nodes
      73             :    * @return true if it the variable is defined at nodes, otherwise false
      74             :    */
      75           0 :   virtual bool isNodalDefined() const { return false; }
      76             : 
      77           0 :   virtual const dof_id_type & nodalDofIndex() const
      78             :   {
      79           0 :     mooseError("Nodal FFT variables are not supported.");
      80             :   }
      81             : 
      82           0 :   virtual const dof_id_type & nodalDofIndexNeighbor() const
      83             :   {
      84           0 :     mooseError("Nodal FFT variables are not supported.");
      85             :   }
      86             : 
      87             :   /**
      88             :    * Current element this variable is evaluated at
      89             :    */
      90           0 :   virtual const Elem * const & currentElem() const
      91             :   {
      92           0 :     mooseError("Current element access not supported.");
      93             :   }
      94             : 
      95             :   /**
      96             :    * The subdomains the variable is active on
      97             :    */
      98           0 :   virtual const std::set<SubdomainID> & activeSubdomains() const { return _all_subdomains; }
      99             :   /**
     100             :    * Is the variable active on the subdomain?
     101             :    * @param subdomain The subdomain id in question
     102             :    * @return true if active on subdomain, false otherwise
     103             :    */
     104           0 :   virtual bool activeOnSubdomain(SubdomainID /*subdomain*/) const { return true; }
     105             : 
     106             :   /**
     107             :    * Prepare the initial condition
     108             :    */
     109           0 :   virtual void prepareIC() {}
     110             : 
     111             :   /**
     112             :    * Compute values at interior quadrature points
     113             :    */
     114           0 :   virtual void computeElemValues()
     115             :   { // meat!
     116           0 :   }
     117             : 
     118             :   /**
     119             :    * Compute values at facial quadrature points
     120             :    */
     121           0 :   virtual void computeElemValuesFace() {}
     122             :   /**
     123             :    * Compute values at facial quadrature points for the neighbor
     124             :    */
     125           0 :   virtual void computeNeighborValuesFace() {}
     126             :   /**
     127             :    * Compute values at quadrature points for the neighbor
     128             :    */
     129           0 :   virtual void computeNeighborValues() {}
     130             :   /**
     131             :    * compute values at quadrature points on the lower dimensional element
     132             :    */
     133           0 :   virtual void computeLowerDValues() {}
     134             :   /**
     135             :    * Compute nodal values of this variable in the neighbor
     136             :    */
     137           0 :   virtual void computeNodalNeighborValues() {}
     138             :   /**
     139             :    * Compute nodal values of this variable
     140             :    */
     141           0 :   virtual void computeNodalValues() {}
     142             : 
     143           0 :   virtual void getDofIndices(const Elem * /*elem*/,
     144             :                              std::vector<dof_id_type> & /*dof_indices*/) const
     145             :   {
     146           0 :   }
     147             : 
     148           0 :   virtual unsigned int numberOfDofsNeighbor() { return 0; }
     149             : 
     150           0 :   virtual void insert(NumericVector<Number> & /*residual*/) {}
     151           0 :   virtual void add(NumericVector<Number> & /*residual*/) {}
     152             : 
     153             : protected:
     154             :   std::vector<dof_id_type> _no_dofs;
     155             :   std::set<SubdomainID> _all_subdomains;
     156             : };