ParameterMesh.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 "MooseTypes.h"
#include "KDTree.h"
 
#include "libmesh/id_types.h"
#include <unordered_map>
#include "libmesh/parallel.h"
#include "libmesh/fe_type.h"
#include "libmesh/point.h"
#include "libmesh/replicated_mesh.h"
#include "libmesh/equation_systems.h"
#include "libmesh/point_locator_base.h"
#include "libmesh/exodusII_io.h"
#include <vector>
#include <functional>
 
namespace libMesh
{
class System;
class DofMap;
}
 
class ParameterMesh
{
public:
  ParameterMesh(const libMesh::FEType & param_type,
                const std::string & exodus_mesh,
                const bool find_closest = false,
                const unsigned int kdtree_candidates = 5);
 
  enum class RegularizationType
  {
    L2_GRADIENT,
    // Future regularization types can be added here:
    // L1,
    // H1,
    // TV (Total Variation)
  };
 
  dof_id_type size() const { return _param_dofs; }
  void getIndexAndWeight(const Point & pt,
                         std::vector<dof_id_type> & dof_indices,
                         std::vector<Real> & weights) const;
  void getIndexAndWeight(const Point & pt,
                         std::vector<dof_id_type> & dof_indices,
                         std::vector<RealGradient> & weights) const;
  Real computeRegularizationObjective(const std::vector<Real> & parameter_values,
                                      RegularizationType reg_type) const;
 
  std::vector<Real> computeRegularizationGradient(const std::vector<Real> & parameter_values,
                                                  RegularizationType reg_type) const;
 
private:
  template <typename T>
  T computeRegularizationLoop(const std::vector<Real> & parameter_values,
                              RegularizationType reg_type) const;
 
protected:
  libMesh::Parallel::Communicator _communicator;
  libMesh::ReplicatedMesh _mesh;
  const bool _find_closest;
  std::unique_ptr<libMesh::EquationSystems> _eq;
  libMesh::System * _sys;
  std::unique_ptr<libMesh::PointLocatorBase> _point_locator;
  std::unique_ptr<libMesh::ExodusII_IO> _exodusII_io;
 
  dof_id_type _param_dofs;
 
  std::vector<Point> _mesh_nodes;
  std::unique_ptr<KDTree> _node_kdtree;
  std::unordered_map<dof_id_type, std::set<const libMesh::Elem *>> _node_to_elements;
  unsigned int _kdtree_candidates;
 
private:
  Point projectToMesh(const Point & p) const;
 
  Point closestPoint(const Elem & elem, const Point & p) const;
 
  Real computeRegularizationQp(const std::vector<Real> & parameter_values,
                               const std::vector<std::vector<Real>> & phi,
                               const std::vector<std::vector<RealGradient>> & dphi,
                               const unsigned int qp,
                               const std::vector<dof_id_type> & dof_indices,
                               const std::vector<Real> & JxW,
                               RegularizationType reg_type) const;
 
  void computeRegularizationGradientQp(const std::vector<Real> & parameter_values,
                                       const std::vector<std::vector<Real>> & phi,
                                       const std::vector<std::vector<RealGradient>> & dphi,
                                       const unsigned int qp,
                                       const std::vector<dof_id_type> & dof_indices,
                                       const std::vector<Real> & JxW,
                                       RegularizationType reg_type,
                                       std::vector<Real> & gradient) const;
  // Cached values for gradient computations
  const unsigned short int _param_var_id;
  const libMesh::DofMap * _dof_map;
  const libMesh::FEType _fe_type;
};