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 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;
};