[cig-commits] [commit] master: Copied functionality from minimum refinement function plugin. (31e5e8b)
cig_noreply at geodynamics.org
cig_noreply at geodynamics.org
Fri Aug 1 23:16:01 PDT 2014
Repository : https://github.com/geodynamics/aspect
On branch : master
Link : https://github.com/geodynamics/aspect/compare/b32ac5f8f385e349bb6bc11f421a0195296a179a...e9db016d5017ab6bacf537f5824c5b1b609de881
>---------------------------------------------------------------
commit 31e5e8bade349849bd86275f4bcc4a1023127024
Author: Jonathan Perry-Houts <jperryh2 at uoregon.edu>
Date: Wed Jul 2 14:19:08 2014 -0700
Copied functionality from minimum refinement function plugin.
>---------------------------------------------------------------
31e5e8bade349849bd86275f4bcc4a1023127024
...nt_function.h => maximum_refinement_function.h} | 14 ++---
..._function.cc => maximum_refinement_function.cc} | 60 +++++++++++-----------
2 files changed, 37 insertions(+), 37 deletions(-)
diff --git a/include/aspect/mesh_refinement/minimum_refinement_function.h b/include/aspect/mesh_refinement/maximum_refinement_function.h
similarity index 83%
copy from include/aspect/mesh_refinement/minimum_refinement_function.h
copy to include/aspect/mesh_refinement/maximum_refinement_function.h
index 696daa9..c00bd90 100644
--- a/include/aspect/mesh_refinement/minimum_refinement_function.h
+++ b/include/aspect/mesh_refinement/maximum_refinement_function.h
@@ -20,8 +20,8 @@
-#ifndef __aspect__mesh_refinement_minimum_refinement_function_h
-#define __aspect__mesh_refinement_minimum_refinement_function_h
+#ifndef __aspect__mesh_refinement_maximum_refinement_function_h
+#define __aspect__mesh_refinement_maximum_refinement_function_h
#include <aspect/mesh_refinement/interface.h>
#include <aspect/simulator_access.h>
@@ -34,13 +34,13 @@ namespace aspect
{
/**
- * A class that implements a minimum refinement level based on a
+ * A class that implements a maximum refinement level based on a
* functional description provided in the input file.
*
* @ingroup MeshRefinement
*/
template <int dim>
- class MinimumRefinementFunction : public Interface<dim>,
+ class MaximumRefinementFunction : public Interface<dim>,
public SimulatorAccess<dim>
{
public:
@@ -80,12 +80,12 @@ namespace aspect
} coordinate_system;
/**
- * A function object representing the minimum refinement level. Which
+ * A function object representing the maximum refinement level. Which
* of the two functions is actually evaluated is determined by the
* 'Coordinate dependence' input parameter.
*/
- Functions::ParsedFunction<1> min_refinement_level_depth;
- Functions::ParsedFunction<dim> min_refinement_level_position;
+ Functions::ParsedFunction<1> max_refinement_level_depth;
+ Functions::ParsedFunction<dim> max_refinement_level_position;
};
}
diff --git a/source/mesh_refinement/minimum_refinement_function.cc b/source/mesh_refinement/maximum_refinement_function.cc
similarity index 79%
copy from source/mesh_refinement/minimum_refinement_function.cc
copy to source/mesh_refinement/maximum_refinement_function.cc
index d941cb0..42e096a 100644
--- a/source/mesh_refinement/minimum_refinement_function.cc
+++ b/source/mesh_refinement/maximum_refinement_function.cc
@@ -20,7 +20,7 @@
-#include <aspect/mesh_refinement/minimum_refinement_function.h>
+#include <aspect/mesh_refinement/maximum_refinement_function.h>
#include <aspect/utilities.h>
#include <deal.II/base/quadrature_lib.h>
@@ -33,7 +33,7 @@ namespace aspect
{
template <int dim>
void
- MinimumRefinementFunction<dim>::tag_additional_cells () const
+ MaximumRefinementFunction<dim>::tag_additional_cells () const
{
for (typename Triangulation<dim>::active_cell_iterator
cell = this->get_triangulation().begin_active();
@@ -41,67 +41,67 @@ namespace aspect
{
if (cell->is_locally_owned())
{
- bool refine = false;
- bool clear_coarsen = false;
+ bool coarsen = false;
+ bool clear_refine = false;
for ( unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
{
const Point<dim> vertex = cell->vertex(v);
- double minimum_refinement_level = 0;
+ double maximum_refinement_level = 0;
if (coordinate_system == depth)
{
const double depth = this->get_geometry_model().depth(vertex);
const Point<1> point(depth);
- minimum_refinement_level = min_refinement_level_depth.value(point);
+ maximum_refinement_level = max_refinement_level_depth.value(point);
}
else if (coordinate_system == spherical)
{
const std_cxx1x::array<double,dim> spherical_coordinates =
aspect::Utilities::spherical_coordinates(vertex);
- // Conversion to evaluate the spherical coordinates in the minimum
+ // Conversion to evaluate the spherical coordinates in the maximum
// refinement level function.
Point<dim> point;
for (unsigned int i = 0;i<dim;++i)
point[i] = spherical_coordinates[i];
- minimum_refinement_level = min_refinement_level_position.value(point);
+ maximum_refinement_level = max_refinement_level_position.value(point);
}
else if (coordinate_system == cartesian)
{
- minimum_refinement_level = min_refinement_level_position.value(vertex);
+ maximum_refinement_level = max_refinement_level_position.value(vertex);
}
- if (cell->level() <= rint(minimum_refinement_level))
- clear_coarsen = true;
- if (cell->level() < rint(minimum_refinement_level))
+ if (cell->level() >= rint(maximum_refinement_level))
+ clear_refine = true;
+ if (cell->level() > rint(maximum_refinement_level))
{
- refine = true;
+ coarsen = true;
break;
}
}
- if (clear_coarsen)
- cell->clear_coarsen_flag ();
- if (refine)
- cell->set_refine_flag ();
+ if (clear_refine)
+ cell->clear_refine_flag ();
+ if (coarsen)
+ cell->set_coarsen_flag ();
}
}
}
template <int dim>
void
- MinimumRefinementFunction<dim>::
+ MaximumRefinementFunction<dim>::
declare_parameters (ParameterHandler &prm)
{
prm.enter_subsection("Mesh refinement");
{
- prm.enter_subsection("Minimum refinement function");
+ prm.enter_subsection("Maximum refinement function");
{
/**
- * Choose the coordinates to evaluate the minimum refinement level
+ * Choose the coordinates to evaluate the maximum refinement level
* function. The function can be declared in dependence of depth,
* cartesian coordinates or spherical coordinates. Note that the order
* of spherical coordinates is r,phi,theta and not r,theta,phi, since
@@ -118,13 +118,13 @@ namespace aspect
"are interpreted as r,phi or r,phi,theta in 2D/3D "
"respectively with theta being the polar angle.");
/**
- * Let the function that describes the minimal level of refinement
+ * Let the function that describes the maximal level of refinement
* as a function of position declare its parameters. This is actually
* not the one that parses the parameters in case the user choose
* 'depth' as coordinate dependence, but the parameters of the depth
* function are a subset of the parameters of this one so everything
* should work out ok.
- * This defines the minimum refinement level each cell should have,
+ * This defines the maximum refinement level each cell should have,
* and that can not be exceeded by coarsening.
*/
Functions::ParsedFunction<dim>::declare_parameters (prm, 1);
@@ -136,11 +136,11 @@ namespace aspect
template <int dim>
void
- MinimumRefinementFunction<dim>::parse_parameters (ParameterHandler &prm)
+ MaximumRefinementFunction<dim>::parse_parameters (ParameterHandler &prm)
{
prm.enter_subsection("Mesh refinement");
{
- prm.enter_subsection("Minimum refinement function");
+ prm.enter_subsection("Maximum refinement function");
{
if (prm.get ("Coordinate system") == "depth")
coordinate_system = depth;
@@ -154,14 +154,14 @@ namespace aspect
try
{
if (coordinate_system == depth)
- min_refinement_level_depth.parse_parameters (prm);
+ max_refinement_level_depth.parse_parameters (prm);
else
- min_refinement_level_position.parse_parameters (prm);
+ max_refinement_level_position.parse_parameters (prm);
}
catch (...)
{
std::cerr << "ERROR: FunctionParser failed to parse\n"
- << "\t'Mesh refinement.Minimum refinement function'\n"
+ << "\t'Mesh refinement.Maximum refinement function'\n"
<< "with expression\n"
<< "\t'" << prm.get("Function expression") << "'";
throw;
@@ -179,10 +179,10 @@ namespace aspect
{
namespace MeshRefinement
{
- ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(MinimumRefinementFunction,
- "minimum refinement function",
+ ASPECT_REGISTER_MESH_REFINEMENT_CRITERION(MaximumRefinementFunction,
+ "maximum refinement function",
"A mesh refinement criterion that ensures a "
- "minimum refinement level described by an "
+ "maximum refinement level described by an "
"explicit formula with the depth or position "
"as argument. Which coordinate representation "
"is used is determined by an input parameter. "
More information about the CIG-COMMITS
mailing list