RadialAverage.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 "ElementUserObject.h"
#include "DataIO.h"
#include "PointListAdaptor.h"
#include "Function.h"
 
#include "libmesh/data_type.h"
 
#include <set>
#include <map>
#include <vector>
#include <memory>
 
class ThreadedRadialAverageLoop;
 
class RadialAverage : public ElementUserObject
{
public:
  static InputParameters validParams();
 
  RadialAverage(const InputParameters & parameters);
 
  virtual void initialSetup() override;
 
  virtual void initialize() override;
  virtual void execute() override;
  virtual void finalize() override;
  virtual void threadJoin(const UserObject & y) override;
  virtual void meshChanged() override;
 
  struct QPData
  {
    Point _q_point;
    dof_id_type _elem_id;
    short _qp;
    Real _volume;
    Real _value;
 
    QPData() : _q_point(), _elem_id(libMesh::invalid_uint), _qp(0), _volume(0.0), _value(0.0) {}
    QPData(const Point & q_point, dof_id_type elem_id, short qp, Real volume, Real value)
      : _q_point(q_point), _elem_id(elem_id), _qp(qp), _volume(volume), _value(value)
    {
    }
  };
 
  using Result = std::map<dof_id_type, std::vector<Real>>;
  const Result & getAverage() const { return _average; }
 
protected:
  void updateCommunicationLists();
 
  enum class WeightsType
  {
    CONSTANT,
    LINEAR,
    COSINE
  } _weights_type;
 
  const MaterialProperty<Real> & _prop;
 
  const Real _radius;
 
  const Real _padding;
 
  std::vector<QPData> _qp_data;
 
  Result _average;
 
  using KDTreeType = nanoflann::KDTreeSingleIndexAdaptor<
      nanoflann::L2_Simple_Adaptor<Real, PointListAdaptor<QPData>>,
      PointListAdaptor<QPData>,
      LIBMESH_DIM,
      std::size_t>;
 
  std::unique_ptr<KDTreeType> _kd_tree;
 
  std::vector<std::vector<const Elem *>> _nodes_to_elem_map;
 
  std::set<Point> _boundary_nodes;
 
  std::set<std::size_t> _boundary_data_indices;
 
  std::vector<std::set<std::size_t>> _communication_lists;
  bool _update_communication_lists;
 
  std::vector<processor_id_type> _candidate_procs;
 
  processor_id_type _my_pid;
 
  PerfID _perf_meshchanged;
  PerfID _perf_updatelists;
  PerfID _perf_finalize;
 
  friend class ThreadedRadialAverageLoop;
};
 
namespace TIMPI
{
 
template <>
class StandardType<RadialAverage::QPData> : public DataType
{
public:
  explicit StandardType(const RadialAverage::QPData * example = nullptr);
  StandardType(const StandardType<RadialAverage::QPData> & t);
  ~StandardType() { this->free(); }
};
 
} // namespace TIMPI