ThreadedElementLoopBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "ParallelUniqueId.h"
#include "MooseMesh.h"
#include "MooseTypes.h"
#include "MooseException.h"
#include "libmesh/libmesh_exceptions.h"
#include "libmesh/elem.h"

template <typename RangeType>
class ThreadedElementLoopBase
{
public:
  ThreadedElementLoopBase(MooseMesh & mesh);

  ThreadedElementLoopBase(ThreadedElementLoopBase & x, Threads::split split);

  virtual ~ThreadedElementLoopBase();

  void operator()(const RangeType & range, bool bypass_threading = false);

  virtual void pre();

  virtual void post();

  virtual void onElement(const Elem * elem);

  virtual void preElement(const Elem * elem);

  virtual void postElement(const Elem * elem);

  virtual void onBoundary(const Elem * elem, unsigned int side, BoundaryID bnd_id);

  virtual void preInternalSide(const Elem * elem, unsigned int side);

  virtual void postInternalSide(const Elem * elem, unsigned int side);

  virtual void onInternalSide(const Elem * elem, unsigned int side);

  virtual void onInterface(const Elem * elem, unsigned int side, BoundaryID bnd_id);

  virtual void subdomainChanged();

  virtual void neighborSubdomainChanged();

  virtual void caughtMooseException(MooseException &){};

  virtual bool keepGoing() { return true; }

protected:
  MooseMesh & _mesh;
  THREAD_ID _tid;

  SubdomainID _subdomain;

  SubdomainID _old_subdomain;

  SubdomainID _neighbor_subdomain;

  SubdomainID _old_neighbor_subdomain;
};

template <typename RangeType>
ThreadedElementLoopBase<RangeType>::ThreadedElementLoopBase(MooseMesh & mesh) : _mesh(mesh)
{
}

template <typename RangeType>
ThreadedElementLoopBase<RangeType>::ThreadedElementLoopBase(ThreadedElementLoopBase & x,
                                                            Threads::split /*split*/)
  : _mesh(x._mesh)
{
}

template <typename RangeType>
ThreadedElementLoopBase<RangeType>::~ThreadedElementLoopBase()
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::operator()(const RangeType & range, bool bypass_threading)
{
  try
  {
    try
    {
      ParallelUniqueId puid;
      _tid = bypass_threading ? 0 : puid.id;

      pre();

      _subdomain = Moose::INVALID_BLOCK_ID;
      _neighbor_subdomain = Moose::INVALID_BLOCK_ID;
      typename RangeType::const_iterator el = range.begin();
      for (el = range.begin(); el != range.end(); ++el)
      {
        if (!keepGoing())
          break;

        const Elem * elem = *el;

        preElement(elem);

        _old_subdomain = _subdomain;
        _subdomain = elem->subdomain_id();
        if (_subdomain != _old_subdomain)
          subdomainChanged();

        onElement(elem);

        for (unsigned int side = 0; side < elem->n_sides(); side++)
        {
          std::vector<BoundaryID> boundary_ids = _mesh.getBoundaryIDs(elem, side);

          if (boundary_ids.size() > 0)
            for (std::vector<BoundaryID>::iterator it = boundary_ids.begin();
                 it != boundary_ids.end();
                 ++it)
              onBoundary(elem, side, *it);

          const Elem * neighbor = elem->neighbor_ptr(side);
          if (neighbor != nullptr)
          {
            preInternalSide(elem, side);

            _old_neighbor_subdomain = _neighbor_subdomain;
            _neighbor_subdomain = neighbor->subdomain_id();
            if (_neighbor_subdomain != _old_neighbor_subdomain)
              neighborSubdomainChanged();

            onInternalSide(elem, side);

            if (boundary_ids.size() > 0)
              for (std::vector<BoundaryID>::iterator it = boundary_ids.begin();
                   it != boundary_ids.end();
                   ++it)
                onInterface(elem, side, *it);

            postInternalSide(elem, side);
          }
        } // sides
        postElement(elem);

      } // range

      post();
    }
    catch (libMesh::LogicError & e)
    {
      throw MooseException("We caught a libMesh error");
    }
  }
  catch (MooseException & e)
  {
    caughtMooseException(e);
  }
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::pre()
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::post()
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::onElement(const Elem * /*elem*/)
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::preElement(const Elem * /*elem*/)
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::postElement(const Elem * /*elem*/)
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::onBoundary(const Elem * /*elem*/,
                                               unsigned int /*side*/,
                                               BoundaryID /*bnd_id*/)
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::preInternalSide(const Elem * /*elem*/, unsigned int /*side*/)
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::postInternalSide(const Elem * /*elem*/, unsigned int /*side*/)
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::onInternalSide(const Elem * /*elem*/, unsigned int /*side*/)
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::onInterface(const Elem * /*elem*/,
                                                unsigned int /*side*/,
                                                BoundaryID /*bnd_id*/)
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::subdomainChanged()
{
}

template <typename RangeType>
void
ThreadedElementLoopBase<RangeType>::neighborSubdomainChanged()
{
}