/**
* Do the work on a boundary face.
*/
- void bdry(DoFInfo<dim>& face);
+ void boundary(DoFInfo<dim>& face);
/**
* Do the work on an interior face.
*
* First, you should consider if you need values from any vectors in a
* NamedData object. If so, fill the VectorSelector objects
- * #cell_selector, #bdry_selector and #face_selector with their names
+ * #cell_selector, #boundary_selector and #face_selector with their names
* and the data type (value, gradient, Hessian) to be extracted.
*
* Afterwards, you will need to consider UpdateFlags for FEValues
* Finally, we need to choose quadrature formulas. If you choose to
* use Gauss formulas only, use initialize_gauss_quadrature() with
* appropriate values. Otherwise, you can fill the variables
- * #cell_quadrature, #bdry_quadrature and #face_quadrature directly.
+ * #cell_quadrature, #boundary_quadrature and #face_quadrature directly.
*
* In order to save time, you can set the variables #boundary_fluxes
* and #interior_fluxes of the base class to false, thus telling the
* Initialize the
* VectorSelector objects
* #cell_selector,
- * #bdry_selector and
+ * #boundary_selector and
* #face_selector in order to
* save computational
* eeffort. If no selectors
* Add additional values for update.
*/
void add_update_flags(const UpdateFlags flags, bool cell = true,
- bool bdry = true, bool face = true,
- bool ngbr = true);
+ bool boundary = true, bool face = true,
+ bool neighbor = true);
/** Assign n-point Gauss
* quadratures to each of the
* performed.
*/
void initialize_gauss_quadrature(unsigned int n_cell_points,
- unsigned int n_bdry_points,
+ unsigned int n_boundary_points,
unsigned int n_face_points);
/**
* the quadrature points on
* boundary faces.
*/
- MeshWorker::VectorSelector bdry_selector;
+ MeshWorker::VectorSelector boundary_selector;
/**
* Select the vectors from
* #update_JxW_values and
* #update_normal_vectors.
*/
- UpdateFlags bdry_flags;
+ UpdateFlags boundary_flags;
/**
* The set of update flags
* quadrature weights are
* taken from the other cell.
*/
- UpdateFlags ngbr_flags;
+ UpdateFlags neighbor_flags;
/**
* The quadrature rule used
* The quadrature rule used
* on boundary faces.
*/
- Quadrature<dim-1> bdry_quadrature;
+ Quadrature<dim-1> boundary_quadrature;
/**
* The quadrature rule used
// private:
boost::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > cell_data;
- boost::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > bdry_data;
+ boost::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > boundary_data;
boost::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim> > face_data;
CellInfo cell_info;
- FaceInfo bdry_info;
+ FaceInfo boundary_info;
FaceInfo face_info;
FaceInfo subface_info;
FaceInfo neighbor_info;
IntegrationInfoBox<dim,sdim>::IntegrationInfoBox(const T& t)
:
cell_info(t),
- bdry_info(t),
+ boundary_info(t),
face_info(t),
subface_info(t),
neighbor_info(t)
const Mapping<dim,sdim>& mapping)
{
assembler.initialize_info(cell_info, false);
- assembler.initialize_info(bdry_info, false);
+ assembler.initialize_info(boundary_info, false);
assembler.initialize_info(face_info, true);
assembler.initialize_info(subface_info, true);
assembler.initialize_info(neighbor_info, true);
cell_info.initialize<FEValues<dim,sdim> >(el, mapping, integrator.cell_quadrature,
integrator.cell_flags);
- bdry_info.initialize<FEFaceValues<dim,sdim> >(el, mapping, integrator.bdry_quadrature,
- integrator.bdry_flags);
+ boundary_info.initialize<FEFaceValues<dim,sdim> >(el, mapping, integrator.boundary_quadrature,
+ integrator.boundary_flags);
face_info.initialize<FEFaceValues<dim,sdim> >(el, mapping, integrator.face_quadrature,
integrator.face_flags);
subface_info.initialize<FESubfaceValues<dim,sdim> >(el, mapping, integrator.face_quadrature,
integrator.face_flags);
neighbor_info.initialize<FEFaceValues<dim,sdim> >(el, mapping, integrator.face_quadrature,
- integrator.ngbr_flags);
+ integrator.neighbor_flags);
}
cell_data = p;
cell_info.initialize_data(p);
- p = boost::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (integrator.bdry_selector));
+ p = boost::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (integrator.boundary_selector));
p->initialize(data);
- bdry_data = p;
- bdry_info.initialize_data(p);
+ boundary_data = p;
+ boundary_info.initialize_data(p);
p = boost::shared_ptr<VectorData<VECTOR, dim, sdim> >(new VectorData<VECTOR, dim, sdim> (integrator.face_selector));
p->initialize(data);
{
loop<CELLINFO,FACEINFO>
(begin, end,
- box.cell_info, box.bdry_info,
+ box.cell_info, box.boundary_info,
box.face_info,
box.subface_info, box.neighbor_info,
cell_worker,
IntegrationWorker<dim>::IntegrationWorker ()
{
cell_flags = update_JxW_values;
- bdry_flags = UpdateFlags(update_JxW_values | update_normal_vectors);
- face_flags = bdry_flags;
- ngbr_flags = update_default;
+ boundary_flags = UpdateFlags(update_JxW_values | update_normal_vectors);
+ face_flags = boundary_flags;
+ neighbor_flags = update_default;
}
if (cell_selector.has_gradients() != 0) cell_flags |= update_gradients;
if (cell_selector.has_hessians() != 0) cell_flags |= update_hessians;
- if (bdry_selector.has_values() != 0) bdry_flags |= update_values;
- if (bdry_selector.has_gradients() != 0) bdry_flags |= update_gradients;
- if (bdry_selector.has_hessians() != 0) bdry_flags |= update_hessians;
+ if (boundary_selector.has_values() != 0) boundary_flags |= update_values;
+ if (boundary_selector.has_gradients() != 0) boundary_flags |= update_gradients;
+ if (boundary_selector.has_hessians() != 0) boundary_flags |= update_hessians;
if (face_selector.has_values() != 0) face_flags |= update_values;
if (face_selector.has_gradients() != 0) face_flags |= update_gradients;
if (face_selector.has_hessians() != 0) face_flags |= update_hessians;
- if (face_selector.has_values() != 0) ngbr_flags |= update_values;
- if (face_selector.has_gradients() != 0) ngbr_flags |= update_gradients;
- if (face_selector.has_hessians() != 0) ngbr_flags |= update_hessians;
+ if (face_selector.has_values() != 0) neighbor_flags |= update_values;
+ if (face_selector.has_gradients() != 0) neighbor_flags |= update_gradients;
+ if (face_selector.has_hessians() != 0) neighbor_flags |= update_hessians;
}
template<int dim>
void
IntegrationWorker<dim>::add_update_flags(
- const UpdateFlags flags, bool cell, bool bdry, bool face, bool ngbr)
+ const UpdateFlags flags, bool cell, bool boundary, bool face, bool neighbor)
{
if (cell) cell_flags |= flags;
- if (bdry) bdry_flags |= flags;
+ if (boundary) boundary_flags |= flags;
if (face) face_flags |= flags;
- if (ngbr) ngbr_flags |= flags;
+ if (neighbor) neighbor_flags |= flags;
}
unsigned int fp)
{
cell_quadrature = QGauss<dim>(cp);
- bdry_quadrature = QGauss<dim-1>(bp);
+ boundary_quadrature = QGauss<dim-1>(bp);
face_quadrature = QGauss<dim-1>(fp);
}