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