NonlinearThread.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "ThreadedElementLoop.h"
#include "MooseObjectTagWarehouse.h"
 
#include "libmesh/elem_range.h"
 
// Forward declarations
class FEProblemBase;
class NonlinearSystemBase;
class IntegratedBCBase;
class DGKernelBase;
class InterfaceKernelBase;
class TimeKernel;
class KernelBase;
class Kernel;
class ResidualObject;
class FVElementalKernel;
class HDGKernel;
 
class NonlinearThread : public ThreadedElementLoop<ConstElemRange>
{
public:
  NonlinearThread(FEProblemBase & fe_problem);
 
  // Splitting Constructor
  NonlinearThread(NonlinearThread & x, Threads::split split);
 
  virtual ~NonlinearThread();
 
  virtual void operator()(const ConstElemRange & range, bool bypass_threading = false) override;
 
  virtual void subdomainChanged() override;
  virtual void onElement(const Elem * elem) override;
  virtual void onBoundary(const Elem * elem,
                          unsigned int side,
                          BoundaryID bnd_id,
                          const Elem * lower_d_elem = nullptr) override;
  virtual void onInterface(const Elem * elem, unsigned int side, BoundaryID bnd_id) override;
  virtual void onInternalSide(const Elem * elem, unsigned int side) override;
  virtual void onExternalSide(const Elem * elem, unsigned int side) override;
  virtual void postElement(const Elem * /*elem*/) override;
  virtual void post() override;
  bool shouldComputeInternalSide(const Elem & elem, const Elem & neighbor) const override;
 
protected:
  void prepareFace(const Elem * elem,
                   unsigned int side,
                   BoundaryID bnd_id = Moose::INVALID_BOUNDARY_ID,
                   const Elem * lower_d_elem = nullptr);
 
  virtual void computeOnElement();
  virtual void computeOnBoundary(BoundaryID bnd_id, const Elem * lower_d_elem);
  virtual void computeOnInterface(BoundaryID bnd_id);
  virtual void computeOnInternalFace(const Elem * neighbor);
  virtual void computeOnInternalFace() = 0;
 
  virtual void compute(ResidualObject & ro) = 0;
 
  virtual void compute(KernelBase & kernel);
  virtual void compute(FVElementalKernel & kernel);
  virtual void compute(IntegratedBCBase & bc);
  virtual void compute(DGKernelBase & dg, const Elem * neighbor);
  virtual void compute(InterfaceKernelBase & ik);
 
  virtual void accumulateNeighbor() = 0;
 
  virtual void accumulateNeighborLower() = 0;
 
  virtual void accumulateLower() = 0;
 
  virtual void accumulate() = 0;
 
  virtual void determineObjectWarehouses() = 0;
 
  void printGeneralExecutionInformation() const override;
 
  void printBlockExecutionInformation() const override;
 
  void printBoundaryExecutionInformation(const unsigned int bid) const override;
 
  virtual std::string objectType() const { return ""; };
 
  NonlinearSystemBase & _nl;
 
  unsigned int _num_cached;
 
  MooseObjectTagWarehouse<IntegratedBCBase> & _integrated_bcs;
 
  MooseObjectWarehouse<IntegratedBCBase> * _ibc_warehouse;
 
  MooseObjectTagWarehouse<DGKernelBase> & _dg_kernels;
 
  MooseObjectWarehouse<DGKernelBase> * _dg_warehouse;
 
  MooseObjectTagWarehouse<InterfaceKernelBase> & _interface_kernels;
 
  MooseObjectWarehouse<InterfaceKernelBase> * _ik_warehouse;
 
  MooseObjectTagWarehouse<KernelBase> & _kernels;
 
  MooseObjectWarehouse<KernelBase> * _tag_kernels;
 
  MooseObjectTagWarehouse<HDGKernel> & _hdg_kernels;
 
  MooseObjectWarehouse<HDGKernel> * _hdg_warehouse;
 
  std::vector<FVElementalKernel *> _fv_kernels;
 
  const bool _has_active_objects;
 
private:
  mutable bool _should_execute_dg;
  bool _subdomain_has_dg;
  bool _subdomain_has_hdg;
};