Functions
void	integrate_function (const MeshBase &mesh)

Real	distance (const Point &p)

Real	integrand (const Point &p)

int	main (int argc, char **argv)

Variables
const Real	radius = 0.5

Function Documentation

◆ distance()

Real distance ( const Point & p )

Definition at line 50 of file subdomains_ex3.C.

 {
   Point cent(0.8, 0.9);
   return ((p-cent).norm() - radius);
 }

References std::norm(), and radius.

Referenced by OverlappingTestPartitioner::_do_partition(), libMesh::MeshCommunication::assign_global_indices(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshCommunication::find_global_indices(), libMesh::RBParametrized::get_closest_value(), libMesh::ParmetisPartitioner::initialize(), libMesh::ExodusII_IO_Helper::initialize(), LinearElasticityWithContact::initialize_contact_load_paths(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), integrand(), integrate_function(), libMesh::StoredRange< iterator_type, object_type >::is_divisible(), libMesh::Parallel::Histogram< KeyType, IdxType >::local_bin_size(), libMesh::DistributedVector< T >::localize(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::ReplicatedMesh::n_active_elem(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_elem_of_type(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::BoundaryInfo::n_boundary_ids(), libMesh::MeshTools::n_elem(), libMesh::MeshTools::n_elem_of_type(), libMesh::MeshBase::n_elem_on_proc(), libMesh::DofMap::n_local_constrained_dofs(), libMesh::MeshTools::n_nodes(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::PetscMatrix< libMesh::Number >::operator()(), libMesh::LinearPartitioner::partition_range(), libMesh::MetisPartitioner::partition_range(), libMesh::SFCPartitioner::partition_range(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::LaspackMatrix< T >::pos(), OverlappingFunctorTest::run_coupling_functor_test(), libMesh::FE< Dim, LAGRANGE_VEC >::shape(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_deriv(), libMesh::FE< Dim, LAGRANGE_VEC >::shape_second_deriv(), libMesh::StoredRange< iterator_type, object_type >::size(), libMesh::Parallel::BinSorter< KeyType, IdxType >::sizeof_bin(), libMesh::StoredRange< iterator_type, object_type >::StoredRange(), DefaultCouplingTest::testCoupling(), EquationSystemsTest::testDisableDefaultGhosting(), PartitionerTest< PartitionerSubclass, MeshClass >::testPartition(), CheckpointIOTest::testSplitter(), libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::Nemesis_IO_Helper::write_exodus_initialization_info(), libMesh::Nemesis_IO_Helper::write_nodal_solution(), and libMesh::VariationalMeshSmoother::writegr().

◆ integrand()

Real integrand ( const Point & p )

Definition at line 56 of file subdomains_ex3.C.

 {
   return (distance(p) < 0) ? 10. : 1.;
 }

References distance().

Referenced by integrate_function().

◆ integrate_function()

void integrate_function ( const MeshBase & mesh )

Definition at line 121 of file subdomains_ex3.C.

 {
 #if defined(LIBMESH_HAVE_TRIANGLE) && defined(LIBMESH_HAVE_TETGEN)
  
   std::vector<Real> vertex_distance;
  
   QComposite<QGauss> qrule (mesh.mesh_dimension(), FIRST);
   //QGauss qrule (mesh.mesh_dimension(), FIRST);
  
   std::unique_ptr<FEBase> fe (FEBase::build (mesh.mesh_dimension(), FEType (FIRST, LAGRANGE)));
  
   Real int_val=0.;
  
   const std::vector<Point> & q_points = fe->get_xyz();
   const std::vector<Real>  & JxW      = fe->get_JxW();
  
   for (const auto & elem : mesh.active_local_element_ptr_range())
     {
       vertex_distance.clear();
  
       for (unsigned int v=0; v<elem->n_vertices(); v++)
         vertex_distance.push_back (distance(elem->point(v)));
  
       qrule.init (*elem, vertex_distance);
  
       fe->reinit (elem,
                   &(qrule.get_points()),
                   &(qrule.get_weights()));
  
  
       // TODO:  would it be valuable to have the composite quadrature rule sort
       // from smallest to largest JxW value to help prevent
       // ... large + small + large + large + small ...
       // type truncation errors?
       for (std::size_t qp=0; qp<q_points.size(); qp++)
         int_val += JxW[qp] * integrand(q_points[qp]);
     }
  
   mesh.comm().sum (int_val);
  
   libMesh::out << "\n***********************************\n"
                << " int_val   = " << int_val << std::endl
                << " exact_val = " <<  1*(2*2 - radius*radius*pi) + 10.*(radius*radius*pi)
                << "\n***********************************\n"
                << std::endl;
 #else
   libmesh_ignore(mesh);
 #endif
 }

References libMesh::MeshBase::active_local_element_ptr_range(), libMesh::FEGenericBase< OutputType >::build(), libMesh::ParallelObject::comm(), distance(), libMesh::FIRST, libMesh::QComposite< QSubCell >::init(), integrand(), libMesh::LAGRANGE, libMesh::libmesh_ignore(), mesh, libMesh::MeshBase::mesh_dimension(), libMesh::out, libMesh::pi, radius, and libMesh::Real.

Referenced by main().

◆ main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 64 of file subdomains_ex3.C.

 {
   // Initialize libMesh and any dependent libraries, like in example 2.
   LibMeshInit init (argc, argv);
  
   // This example requires Adaptive Mesh Refinement support - although
   // it only refines uniformly, the refinement code used is the same
   // underneath.  It also requires libmesh support for Triangle and
   // Tetgen, which means that libmesh must be configured with
   // --disable-strict-lgpl for this example to run.
 #if !defined(LIBMESH_HAVE_TRIANGLE) || !defined(LIBMESH_HAVE_TETGEN) || !defined(LIBMESH_ENABLE_AMR)
   libmesh_example_requires(false, "--disable-strict-lgpl --enable-amr");
 #else
  
   // Skip this 2D example if libMesh was compiled as 1D-only.
   libmesh_example_requires(2 <= LIBMESH_DIM, "2D support");
  
   // Read the mesh from file.  This is the coarse mesh that will be used
   // in example 10 to demonstrate adaptive mesh refinement.  Here we will
   // simply read it in and uniformly refine it 5 times before we compute
   // with it.
   Mesh mesh(init.comm());
  
   {
     unsigned int dim=2;
  
     if (argc == 3 && std::atoi(argv[2]) == 3)
       {
         libmesh_here();
         dim=3;
       }
  
     mesh.read ((dim==2) ? "mesh.xda" : "hybrid_3d.xda");
   }
  
   // Create a MeshRefinement object to handle refinement of our mesh.
   // This class handles all the details of mesh refinement and coarsening.
   MeshRefinement mesh_refinement (mesh);
  
   // Uniformly refine the mesh 4 times.  This is the
   // first time we use the mesh refinement capabilities
   // of the library.
   mesh_refinement.uniformly_refine (4);
  
   // Print information about the mesh to the screen.
   mesh.print_info();
  
   // integrate the desired function
   integrate_function (mesh);
  
   // All done.
   return 0;
 #endif
 }

References dim, libMesh::TriangleWrapper::init(), integrate_function(), mesh, libMesh::MeshBase::print_info(), libMesh::MeshBase::read(), and libMesh::MeshRefinement::uniformly_refine().

Variable Documentation

◆ radius

const Real radius = 0.5

Definition at line 48 of file subdomains_ex3.C.

Referenced by distance(), integrate_function(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

Functions