system_matrix);
VectorTools::create_right_hand_side (mapping, dof_handler,
QGauss<dim>(gauss_degree),
- ConstantFunction<dim>(-2),
+ Functions::ConstantFunction<dim>(-2),
system_rhs);
// That's quite simple, right?
//
Vector<double> tmp (system_rhs.size());
VectorTools::create_boundary_right_hand_side (mapping, dof_handler,
QGauss<dim-1>(gauss_degree),
- ConstantFunction<dim>(1),
+ Functions::ConstantFunction<dim>(1),
tmp);
// Then add the contributions from the boundary to those from the interior
// of the domain:
Vector<float> norm_per_cell (triangulation.n_active_cells());
VectorTools::integrate_difference (mapping, dof_handler,
solution,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
norm_per_cell,
QGauss<dim>(gauss_degree+1),
VectorTools::H1_seminorm);
// We need a class to denote the boundary values of the problem. In this
// case, this is simple: it's the zero function, so don't even declare a
// class, just a typedef:
- typedef ZeroFunction<dim> BoundaryValues;
+ typedef Functions::ZeroFunction<dim> BoundaryValues;
// Second, a class that denotes the right hand side. Since they are
// constant, just subclass the corresponding class of the library and be
// done:
- class RightHandSide : public ConstantFunction<dim>
+ class RightHandSide : public Functions::ConstantFunction<dim>
{
public:
- RightHandSide () : ConstantFunction<dim> (1.) {}
+ RightHandSide () : Functions::ConstantFunction<dim> (1.) {}
};
// Finally a function to generate the coarse grid. This is somewhat more
const SmartPointer<const DualFunctional::DualFunctionalBase<dim> > dual_functional;
virtual void assemble_rhs (Vector<double> &rhs) const;
- static const ZeroFunction<dim> boundary_values;
+ static const Functions::ZeroFunction<dim> boundary_values;
};
template <int dim>
- const ZeroFunction<dim> DualSolver<dim>::boundary_values;
+ const Functions::ZeroFunction<dim> DualSolver<dim>::boundary_values;
template <int dim>
DualSolver<dim>::
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::set<types::boundary_id> dirichlet_boundary_ids;
typename FunctionMap<dim>::type dirichlet_boundary_functions;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary_ids.insert(0);
dirichlet_boundary_functions[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (static_cast<const DoFHandler<dim>&>(dof_handler),
std::vector<double> lambda_values (n_q_points);
std::vector<double> mu_values (n_q_points);
- ConstantFunction<dim> lambda(1.), mu(1.);
+ Functions::ConstantFunction<dim> lambda(1.), mu(1.);
RightHandSide<dim> right_hand_side;
std::vector<Vector<double> > rhs_values (n_q_points,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
// For the purposes of this program, we choose a simple form of boundary
// displacement: we displace the top boundary with constant velocity
// downwards. The rest of the boundary is either going to be fixed (and is
- // then described using an object of type <code>ZeroFunction</code>) or free
+ // then described using an object of type <code>Functions::ZeroFunction</code>) or free
// (Neumann-type, in which case nothing special has to be done). The
// implementation of the class describing the constant downward motion
// should then be obvious using the knowledge we gained through all the
VectorTools::
interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (dim),
+ Functions::ZeroFunction<dim> (dim),
boundary_values);
VectorTools::
interpolate_boundary_values (dof_handler,
//
// We therefore simply create a function that returns zero in all
// components. We do that by simply forward every function to the
- // ZeroFunction class. Why not use that right away in the places of this
+ // Functions::ZeroFunction class. Why not use that right away in the places of this
// program where we presently use the <code>InitialValues</code> class?
// Because this way it is simpler to later go back and choose a different
// function for initial values.
InitialValues<dim>::value (const Point<dim> &p,
const unsigned int component) const
{
- return ZeroFunction<dim>(dim+2).value (p, component);
+ return Functions::ZeroFunction<dim>(dim+2).value (p, component);
}
InitialValues<dim>::vector_value (const Point<dim> &p,
Vector<double> &values) const
{
- ZeroFunction<dim>(dim+2).vector_value (p, values);
+ Functions::ZeroFunction<dim>(dim+2).vector_value (p, values);
}
VectorTools::interpolate(dof_handler,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
old_solution);
solution = old_solution;
constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close ();
for (unsigned int i=0; i<dim; ++i)
VectorTools::interpolate_boundary_values (dof_handler,
2*i+1,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
}
{
for (unsigned int group=0; group<parameters.n_groups; ++group)
{
- energy_groups[group]->assemble_ingroup_rhs (ZeroFunction<dim>());
+ energy_groups[group]->assemble_ingroup_rhs (Functions::ZeroFunction<dim>());
for (unsigned int bgroup=0; bgroup<parameters.n_groups; ++bgroup)
energy_groups[group]->assemble_cross_group_rhs (*energy_groups[bgroup]);
// the boundary.
//
// The function describing the boundary values is an object of type Function
- // or of a derived class. One of the derived classes is ZeroFunction, which
+ // or of a derived class. One of the derived classes is Functions::ZeroFunction, which
// describes (not unexpectedly) a function which is zero everywhere. We
// create such an object in-place and pass it to the
// VectorTools::interpolate_boundary_values() function.
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<2>(),
+ Functions::ZeroFunction<2>(),
boundary_values);
// Now that we got the list of boundary DoFs and their respective boundary
// values, let's use them to modify the system of equations
FEValuesExtractors::Vector velocity_components(0);
VectorTools::interpolate_boundary_values (stokes_dof_handler,
0,
- ZeroFunction<dim>(dim+1),
+ Functions::ZeroFunction<dim>(dim+1),
stokes_constraints,
stokes_fe.component_mask(velocity_components));
{
vel_exact.set_time (t_0);
vel_exact.set_component(d);
- VectorTools::interpolate (dof_handler_velocity, ZeroFunction<dim>(), u_n_minus_1[d]);
+ VectorTools::interpolate (dof_handler_velocity, Functions::ZeroFunction<dim>(), u_n_minus_1[d]);
vel_exact.advance_time (dt);
- VectorTools::interpolate (dof_handler_velocity, ZeroFunction<dim>(), u_n[d]);
+ VectorTools::interpolate (dof_handler_velocity, Functions::ZeroFunction<dim>(), u_n[d]);
}
}
VectorTools::
interpolate_boundary_values (dof_handler_velocity,
*boundaries,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
break;
case 2:
VectorTools::
interpolate_boundary_values (dof_handler_velocity,
*boundaries,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
break;
case 4:
VectorTools::
interpolate_boundary_values (dof_handler_velocity,
*boundaries,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
break;
default:
static std::map<types::global_dof_index, double> bval;
if (reinit_prec)
VectorTools::interpolate_boundary_values (dof_handler_pressure, 3,
- ZeroFunction<dim>(), bval);
+ Functions::ZeroFunction<dim>(), bval);
MatrixTools::apply_boundary_values (bval, pres_iterative, phi_n, pres_tmp);
constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
setup_time += time.wall_time();
// simply be omitted for scalar functions.
//
// Function objects are used in lots of places in the library (for example, in
-// step-2 we used a ZeroFunction instance as an argument to
+// step-2 we used a Functions::ZeroFunction instance as an argument to
// VectorTools::interpolate_boundary_values) and this is the first step where
// we define a new class that inherits from Function. Since we only ever call
// Function::value, we could get away with just a plain function (and this is
// As the final step in this function, we wanted to have non-homogeneous
// boundary values in this example, unlike the one before. This is a simple
- // task, we only have to replace the ZeroFunction used there by an object of
+ // task, we only have to replace the Functions::ZeroFunction used there by an object of
// the class which describes the boundary values we would like to use
// (i.e. the <code>BoundaryValues</code> class declared above):
std::map<types::global_dof_index,double> boundary_values;
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close ();
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(x_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(x_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(y_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(y_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(z_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(z_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
}
const FEValuesExtractors::Vector displacements(dim+1);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(dim+1+dim),
+ Functions::ZeroFunction<dim>(dim+1+dim),
constraints,
fe_collection.component_mask(displacements));
}
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(2),
+ Functions::ZeroFunction<dim>(2),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
solution.update_ghost_values();
VectorTools::integrate_difference (dof_handler,
solution,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
norm_per_cell,
QGauss<dim>(fe_degree+1),
VectorTools::L2_norm);
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::set<types::boundary_id> dirichlet_boundary_ids;
typename FunctionMap<dim>::type dirichlet_boundary;
- ConstantFunction<dim> homogeneous_dirichlet_bc (1.0);
+ Functions::ConstantFunction<dim> homogeneous_dirichlet_bc (1.0);
dirichlet_boundary_ids.insert(0);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (mg_dof_handler,
{
dof_handler.distribute_dofs(fe);
- VectorTools::interpolate_boundary_values(dof_handler,1,ZeroFunction<2>(),constraint_matrix);
+ VectorTools::interpolate_boundary_values(dof_handler,1,Functions::ZeroFunction<2>(),constraint_matrix);
constraint_matrix.close();
DynamicSparsityPattern dsp(dof_handler.n_dofs());
DoFTools::make_hanging_node_constraints(dof_handler, zero_constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
- ZeroFunction<dim>(dim+1),
+ Functions::ZeroFunction<dim>(dim+1),
zero_constraints,
fe.component_mask(velocities));
}
constraints);
- // Now we are ready to interpolate the ZeroFunction to our boundary with
+ // Now we are ready to interpolate the Functions::ZeroFunction to our boundary with
// indicator 0 (the whole boundary) and store the resulting constraints in
// our <code>constraints</code> object. Note that we do not to apply the
// boundary conditions after assembly, like we did in earlier steps. As
// values into the ContraintMatrix after the hanging node constraints.
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
// value 1.0. Although we could omit the respective factors in the
// assemblage of the matrix, we use them here for purpose of
// demonstration.
- ConstantFunction<dim> lambda(1.), mu(1.);
+ Functions::ConstantFunction<dim> lambda(1.), mu(1.);
// Like the two constant functions above, we will call the function
// right_hand_side just once per cell to make things simpler.
// The interpolation of the boundary values needs a small modification:
// since the solution function is vector-valued, so need to be the
- // boundary values. The <code>ZeroFunction</code> constructor accepts a
+ // boundary values. The <code>Functions::ZeroFunction</code> constructor accepts a
// parameter that tells it that it shall represent a vector valued,
// constant zero function with that many components. By default, this
- // parameter is equal to one, in which case the <code>ZeroFunction</code>
+ // parameter is equal to one, in which case the <code>Functions::ZeroFunction</code>
// object would represent a scalar function. Since the solution vector has
// <code>dim</code> components, we need to pass <code>dim</code> as number
// of components to the zero function as well.
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
dealii::DoFTools::make_hanging_node_constraints (dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values (dof_handler,
0,
- dealii::ZeroFunction<dim> (),
+ dealii::Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (),
+ Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
- ZeroFunction<dim> potential;
+ Functions::ZeroFunction<dim> potential;
std::vector<double> potential_values (n_q_points);
std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
- ZeroFunction<dim> potential;
+ Functions::ZeroFunction<dim> potential;
std::vector<double> potential_values (n_q_points);
dealii::DoFTools::make_hanging_node_constraints (dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values (dof_handler,
0,
- dealii::ZeroFunction<dim> (),
+ dealii::Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (),
+ Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (),
+ Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (),
+ Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (),
+ Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
#define LOG_FILE "output"
#define NUMBER double
-#define TESTEE ConstantFunction
+#define TESTEE Functions::ConstantFunction
// Test a given TESTEE object f on n_points points
template <int dim, typename Number>
// Here comes the crucial call....
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (2),
+ Functions::ZeroFunction<dim> (2),
dirichlet_dofs,
component_mask);
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ConstantFunction<dim>(1.),
+ Functions::ConstantFunction<dim>(1.),
boundary_values);
std::vector<types::global_dof_index> local_dofs (fe.dofs_per_cell);
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ConstantFunction<dim>(1.),
+ Functions::ConstantFunction<dim>(1.),
boundary_values);
std::vector<types::global_dof_index> local_dofs (fe.dofs_per_cell);
// First error check. Simply the interpolation error of the used FE-Space
// on the given triangulation.
VectorTools::integrate_difference (dof_handler, solution,
- ZeroFunction<dim>(1),
+ Functions::ZeroFunction<dim>(1),
norm_per_cell,
quadrature,
VectorTools::L2_norm);
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ConstantFunction<dim>(1.),
+ Functions::ConstantFunction<dim>(1.),
boundary_values);
ConstraintMatrix constraints;
constraints.clear();
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
1,
- ConstantFunction<dim>(1.),
+ Functions::ConstantFunction<dim>(1.),
boundary_values);
ConstraintMatrix constraints;
constraints.clear();
deallog << difference(0) << std::endl;
Assert (difference(0) < 2e-4, ExcInternalError());
- VectorTools::point_difference (dof, v, ZeroFunction<dim>(),
+ VectorTools::point_difference (dof, v, Functions::ZeroFunction<dim>(),
difference, p[i]);
deallog << difference(0) << std::endl;
Assert (std::abs(-difference(0) - function.value(p[i])) < 2e-4,
deallog << difference(0) << std::endl;
Assert (difference(0) < 2e-4, ExcInternalError());
- VectorTools::point_difference (mapping, dof, v, ZeroFunction<dim>(),
+ VectorTools::point_difference (mapping, dof, v, Functions::ZeroFunction<dim>(),
difference, p[i]);
deallog << difference(0) << std::endl;
Assert (std::abs(-difference(0) - function.value(p[i])) < 2e-4,
system_matrix);
VectorTools::create_right_hand_side (mapping, dof_handler,
QGauss<dim>(gauss_degree),
- ConstantFunction<dim>(-2),
+ Functions::ConstantFunction<dim>(-2),
system_rhs);
Vector<double> tmp (system_rhs.size());
VectorTools::create_boundary_right_hand_side (mapping, dof_handler,
QGauss<dim-1>(gauss_degree),
- ConstantFunction<dim>(1),
+ Functions::ConstantFunction<dim>(1),
tmp);
system_rhs += tmp;
Vector<float> norm_per_cell (triangulation.n_active_cells());
VectorTools::integrate_difference (mapping, dof_handler,
solution,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
norm_per_cell,
QGauss<dim>(gauss_degree+1),
VectorTools::H1_seminorm);
template <int dim>
struct Exercise_2_3
{
- typedef ZeroFunction<dim> BoundaryValues;
+ typedef Functions::ZeroFunction<dim> BoundaryValues;
- class RightHandSide : public ConstantFunction<dim>
+ class RightHandSide : public Functions::ConstantFunction<dim>
{
public:
- RightHandSide () : ConstantFunction<dim> (1.) {}
+ RightHandSide () : Functions::ConstantFunction<dim> (1.) {}
};
static
const SmartPointer<const DualFunctional::DualFunctionalBase<dim> > dual_functional;
virtual void assemble_rhs (Vector<double> &rhs) const;
- static const ZeroFunction<dim> boundary_values;
+ static const Functions::ZeroFunction<dim> boundary_values;
friend class WeightedResidual<dim>;
};
template <int dim>
- const ZeroFunction<dim> DualSolver<dim>::boundary_values;
+ const Functions::ZeroFunction<dim> DualSolver<dim>::boundary_values;
template <int dim>
DualSolver<dim>::
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
if (dim == 1)
VectorTools::interpolate_boundary_values (dof_handler,
1,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
Vector<double> dummy (residual.size());
MatrixTools::apply_boundary_values (boundary_values,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<2>(),
+ Functions::ZeroFunction<2>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::vector<double> lambda_values (n_q_points);
std::vector<double> mu_values (n_q_points);
- ConstantFunction<dim> lambda(1.), mu(1.);
+ Functions::ConstantFunction<dim> lambda(1.), mu(1.);
RightHandSide<dim> right_hand_side;
std::vector<Vector<double> > rhs_values (n_q_points,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
for (unsigned int i=0; i <real_one.size(); ++i)
real_one(i) = 1.;
- ConstantFunction<spacedim> constant(1.);
+ Functions::ConstantFunction<spacedim> constant(1.);
VectorTools::interpolate(dof_handler, constant, interpolated_one);
real_one.add(-1, interpolated_one);
std::string::npos)
return;
- ConstantFunction<dim> test_func (1, dof_handler.get_fe().n_components ());
+ Functions::ConstantFunction<dim> test_func (1, dof_handler.get_fe().n_components ());
// don't run this test if hanging
// nodes are not implemented
cell->set_material_id(cell->index() % 128);
if (functions.find(cell->index() % 128) == functions.end())
functions[cell->index() % 128]
- = new ConstantFunction<dim>(cell->index() % 128);
+ = new Functions::ConstantFunction<dim>(cell->index() % 128);
}
for (unsigned int p=1; p<7-dim; ++p)
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
template <int dim>
struct Exercise_2_3
{
- typedef ZeroFunction<dim> BoundaryValues;
+ typedef Functions::ZeroFunction<dim> BoundaryValues;
- class RightHandSide : public ConstantFunction<dim>
+ class RightHandSide : public Functions::ConstantFunction<dim>
{
public:
- RightHandSide () : ConstantFunction<dim> (1.) {}
+ RightHandSide () : Functions::ConstantFunction<dim> (1.) {}
};
static
const SmartPointer<const DualFunctional::DualFunctionalBase<dim> > dual_functional;
virtual void assemble_rhs (Vector<double> &rhs) const;
- static const ZeroFunction<dim> boundary_values;
+ static const Functions::ZeroFunction<dim> boundary_values;
friend class WeightedResidual<dim>;
};
template <int dim>
- const ZeroFunction<dim> DualSolver<dim>::boundary_values;
+ const Functions::ZeroFunction<dim> DualSolver<dim>::boundary_values;
template <int dim>
DualSolver<dim>::
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
if (dim == 1)
VectorTools::interpolate_boundary_values (dof_handler,
1,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
Vector<double> dummy (residual.size());
MatrixTools::apply_boundary_values (boundary_values,
std::string::npos)
return;
- ConstantFunction<dim> test_func (1, dof_handler.get_fe().n_components ());
+ Functions::ConstantFunction<dim> test_func (1, dof_handler.get_fe().n_components ());
// don't run this test if hanging
// nodes are not implemented
hn_constraints.close ();
MappingQGeneric<2> map_default(1);
project (map_default, *dof_handler, hn_constraints,
- QGauss<2> (6), ConstantFunction<2>(1., 2),
+ QGauss<2> (6), Functions::ConstantFunction<2>(1., 2),
solution);
EvaluateDerivative (dof_handler, solution);
hn_constraints.close ();
MappingQGeneric<3> map_default(1);
project (map_default, dof_handler, hn_constraints,
- QGauss<3> (6), ConstantFunction<3>(1., 3),
+ QGauss<3> (6), Functions::ConstantFunction<3>(1., 3),
solution);
EvaluateDerivative (dof_handler, solution);
DoFHandler<dim> dof_handler(tria);
dof_handler.distribute_dofs (fe);
ConstraintMatrix constraints;
- ZeroFunction<dim> boundary_values(fe.n_components());
+ Functions::ZeroFunction<dim> boundary_values(fe.n_components());
VectorTools::project_boundary_values_curl_conforming (dof_handler, 0, boundary_values, 0, constraints);
}
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (1),
+ Functions::ZeroFunction<dim> (1),
constraints);
constraints.close ();
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (2),
+ Functions::ZeroFunction<dim> (2),
constraints);
constrain_pou_dofs();
constraints.close ();
deallog.push("3d");
test<3>();
deallog.pop();
-}
\ No newline at end of file
+}
deallog.push("3d");
test<3>();
deallog.pop();
-}
\ No newline at end of file
+}
for (unsigned int c=0; c<6; ++c)
VectorTools::interpolate_boundary_values (dh,
c,
- ConstantFunction<dim>(c),
+ Functions::ConstantFunction<dim>(c),
constraints);
constraints.close();
constraints.distribute(vec);
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
constraints);
constraints.close ();
// the sum over the elements of the
// resulting rhs vector, you need to get
// four
- ConstantFunction< 2 > rhs_function(1);
+ Functions::ConstantFunction< 2 > rhs_function(1);
VectorTools::create_boundary_right_hand_side ( hp_dof_handler2,
quadrature,
std::map<types::global_dof_index, double> bv;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(1),
+ Functions::ZeroFunction<dim>(1),
bv);
for (std::map<types::global_dof_index, double>::iterator
p = bv.begin(); p!=bv.end(); ++p)
std::map<types::global_dof_index, double> bv;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(2),
+ Functions::ZeroFunction<dim>(2),
bv);
for (std::map<types::global_dof_index, double>::iterator
p = bv.begin(); p!=bv.end(); ++p)
std::map<types::global_dof_index, double> bv;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(4),
+ Functions::ZeroFunction<dim>(4),
bv);
for (std::map<types::global_dof_index, double>::iterator
p = bv.begin(); p!=bv.end(); ++p)
Vector<double> solution(dof_handler.n_dofs());
VectorTools::interpolate(dof_handler,
- ZeroFunction<dim>(2*dim+1),
+ Functions::ZeroFunction<dim>(2*dim+1),
solution);
deallog << "l2_norm = " << solution.l2_norm() << std::endl;
Vector<double> solution(dof_handler.n_dofs());
VectorTools::interpolate(dof_handler,
- ZeroFunction<dim>(2),
+ Functions::ZeroFunction<dim>(2),
solution);
deallog << "l2_norm = " << solution.l2_norm() << std::endl;
test<2>(false,1);
test<2>(false,2);
#endif
-}
\ No newline at end of file
+}
{
VectorTools::integrate_difference (dof_handler,
vec,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
diff,
q_collection,
VectorTools::L1_norm);
{
VectorTools::integrate_difference (dof_handler,
vec,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
diff,
q_collection,
VectorTools::H1_seminorm);
{
VectorTools::integrate_difference (dof_handler,
vec,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
diff,
q_collection,
VectorTools::W1infty_seminorm);
{
VectorTools::integrate_difference (dof_handler,
vec,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
diff,
q_collection,
VectorTools::W1infty_norm);
{
VectorTools::integrate_difference (dof_handler,
vec,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
diff,
q_collection,
VectorTools::H1_seminorm);
{
VectorTools::integrate_difference (dof_handler,
vec,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
diff,
q_collection,
VectorTools::W1infty_seminorm);
// interpolate the function
VectorTools::interpolate (dof_handler,
- ZeroFunction<dim>(hp_fe[0].n_components()),
+ Functions::ZeroFunction<dim>(hp_fe[0].n_components()),
interpolant);
deallog << interpolant.l2_norm() << std::endl;
}
//Initial conditions
VectorTools::interpolate(dof_handler, InitialConditions<dim>(), Un);
- // VectorTools::interpolate(dof_handler, ZeroFunction<dim>(fe_collection.n_components()), Un);
+ // VectorTools::interpolate(dof_handler, Functions::ZeroFunction<dim>(fe_collection.n_components()), Un);
U=Un;
U0=Un;
// interpolate the function
VectorTools::interpolate(dof_handler,
- ConstantFunction<dim>(3.14),
+ Functions::ConstantFunction<dim>(3.14),
interpolant);
deallog << interpolant.mean_value() << std::endl;
}
system_matrix);
VectorTools::create_right_hand_side (mapping, dof_handler,
hp::QCollection<dim>(QGauss<dim>(gauss_degree)),
- ConstantFunction<dim>(-2),
+ Functions::ConstantFunction<dim>(-2),
system_rhs);
Vector<double> tmp (system_rhs.size());
VectorTools::create_boundary_right_hand_side (mapping, dof_handler,
hp::QCollection<dim-1>(QGauss<dim-1>(gauss_degree)),
- ConstantFunction<dim>(1),
+ Functions::ConstantFunction<dim>(1),
tmp);
system_rhs += tmp;
Vector<float> norm_per_cell (triangulation.n_active_cells());
VectorTools::integrate_difference (mapping, dof_handler,
solution,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
norm_per_cell,
hp::QCollection<dim>(QGauss<dim>(gauss_degree+1)),
VectorTools::H1_seminorm);
constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close ();
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<2>(),
+ Functions::ZeroFunction<2>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<2>(),
+ Functions::ZeroFunction<2>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<2>(),
+ Functions::ZeroFunction<2>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<2>(),
+ Functions::ZeroFunction<2>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::vector<double> lambda_values (n_q_points);
std::vector<double> mu_values (n_q_points);
- ConstantFunction<dim> lambda(1.), mu(1.);
+ Functions::ConstantFunction<dim> lambda(1.), mu(1.);
RightHandSide<dim> right_hand_side;
std::vector<Vector<double> > rhs_values (n_q_points,
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
std::map<types::global_dof_index,typename VectorType::value_type> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<2,typename VectorType::value_type>(),
+ Functions::ZeroFunction<2,typename VectorType::value_type>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ConstantFunction<dim>(1.),
+ Functions::ConstantFunction<dim>(1.),
constraints);
constraints.close ();
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof,
0,
- ConstantFunction<dim>(1.),
+ Functions::ConstantFunction<dim>(1.),
boundary_values);
std::map<types::global_dof_index,double>::const_iterator boundary_value =
boundary_values.begin();
<< "Total number of constraints: "
<< correct_constraints.n_constraints() << std::endl;
- VectorTools::interpolate_boundary_values (dof, 0, ConstantFunction<dim>(1.),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ConstantFunction<dim>(1.),
library_constraints);
library_constraints.close();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 1, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 1, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 1, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 1, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
boundary_values);
std::map<types::global_dof_index,double>::const_iterator boundary_value =
boundary_values.begin();
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
reference_matrix,
constraints.clear();
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ConstantFunction<dim>(1),
+ Functions::ConstantFunction<dim>(1),
constraints);
constraints.close();
sparsity_pattern.reinit (dof_handler.n_dofs(),
#endif
VectorTools::interpolate_boundary_values (dof_handler,
0,
- BoundaryValues<dim>(),//ZeroFunction<dim>(dim+1),
+ BoundaryValues<dim>(),//Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
VectorTools::interpolate_boundary_values (dof_handler,
1,
- BoundaryValues<dim>(),//ZeroFunction<dim>(dim+1),
+ BoundaryValues<dim>(),//Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
}
}
}
-}
\ No newline at end of file
+}
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (),
+ Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
Point<3>(1, 0, 0)) << std::endl
<< manifold.get_tangent_vector (Point<3>(0, 0, -1),
Point<3>(0, 1, 0)) << std::endl;
-}
\ No newline at end of file
+}
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<2>(),
+ Functions::ZeroFunction<2>(),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values,
system_matrix,
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 1, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 1, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 1, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 1, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
DoFTools::extract_locally_relevant_dofs (dof, relevant_set);
ConstraintMatrix constraints_0 (relevant_set), constraints_1(relevant_set);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints_0);
constraints_0.close();
constraints_1.close();
DoFHandler<dim> dof (tria);
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
// only interior DoFs on the elements, but try
// anyway
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(dim),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(dim),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
constraints);
VectorTools::interpolate_boundary_values (dof,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close ();
DynamicSparsityPattern csp (dof.n_dofs(),
ConstraintMatrix constraints (relevant_set);
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
ConstraintMatrix constraints;
VectorTools::interpolate_boundary_values (dof,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close ();
mg_ref_matrices.resize (0, nlevels-1);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
std::vector<std::set<types::global_dof_index> > boundary_indices(nlevels);
MGTools::make_boundary_list (dof, dirichlet_boundary, boundary_indices);
// extract the constraints due to Dirichlet boundary conditions
ConstraintMatrix constraints;
- ZeroFunction<dim> zero;
+ Functions::ZeroFunction<dim> zero;
typename FunctionMap<dim>::type functions;
for (std::set<types::boundary_id>::const_iterator it=dirichlet_boundaries.begin();
it != dirichlet_boundaries.end(); ++it)
DoFTools::extract_locally_relevant_dofs(dof, locally_relevant_dofs);
// Dirichlet BC
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
hanging_node_constraints.close();
MGConstrainedDoFs mg_constrained_dofs;
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
mg_constrained_dofs.initialize(dof, dirichlet_boundary);
DoFTools::extract_locally_relevant_dofs(dof, locally_relevant_dofs);
// Dirichlet BC
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
hanging_node_constraints.close();
MGConstrainedDoFs mg_constrained_dofs;
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
mg_constrained_dofs.initialize(dof, dirichlet_boundary);
DoFTools::extract_locally_relevant_dofs(dof, locally_relevant_dofs);
// Dirichlet BC
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
hanging_node_constraints.close();
MGConstrainedDoFs mg_constrained_dofs;
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
mg_constrained_dofs.initialize(dof, dirichlet_boundary);
// extract the constraints due to Dirichlet boundary conditions
ConstraintMatrix constraints;
- ZeroFunction<dim> zero;
+ Functions::ZeroFunction<dim> zero;
typename FunctionMap<dim>::type functions;
for (std::set<types::boundary_id>::const_iterator it=dirichlet_boundaries.begin();
it != dirichlet_boundaries.end(); ++it)
}
MGConstrainedDoFs mg_constrained_dofs;
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
mg_constrained_dofs.initialize(dof, dirichlet_boundary);
constraints.clear();
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
mg_constraints.resize (0, nlevels-1);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
std::vector<std::set<types::global_dof_index> > boundary_indices(triangulation.n_levels());
MGTools::make_boundary_list (dof_handler,
Vector<float> norm_per_cell (triangulation.n_active_cells());
VectorTools::integrate_difference (dof_handler,
solution,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
norm_per_cell,
QGauss<dim>(fe_degree+1),
VectorTools::L2_norm);
Vector<float> norm_per_cell (triangulation.n_active_cells());
VectorTools::integrate_difference (dof_handler,
solution,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
norm_per_cell,
QGauss<dim>(fe_degree+1),
VectorTools::L2_norm);
Vector<float> norm_per_cell (triangulation.n_active_cells());
VectorTools::integrate_difference (dof_handler,
solution,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
norm_per_cell,
QGauss<dim>(fe_degree+1),
VectorTools::L2_norm);
dof.distribute_dofs(fe);
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints(dof, constraints);
- VectorTools::interpolate_boundary_values (dof, 0, ZeroFunction<dim>(),
+ VectorTools::interpolate_boundary_values (dof, 0, Functions::ZeroFunction<dim>(),
constraints);
constraints.close();
constraints);
VectorTools::interpolate_boundary_values (dof,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close ();
VectorTools::interpolate_boundary_values (dofh,
0,
- ZeroFunction<dim>(dim+1),
+ Functions::ZeroFunction<dim>(dim+1),
cm,
velocity_mask);
constraints.clear ();
constraints.reinit (locally_relevant_dofs);
DoFTools::make_hanging_node_constraints (dof_handler,constraints);
- VectorTools::interpolate_boundary_values (dof_handler, 0, ConstantFunction<dim> (1.0), constraints);
+ VectorTools::interpolate_boundary_values (dof_handler, 0, Functions::ConstantFunction<dim> (1.0), constraints);
constraints.close ();
constraints.distribute(locally_relevant_solution);
}
// ones printed in the output are correct
Vector<float> results (tr.n_active_cells());
VectorTools::integrate_difference (dofh, x_rel,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
results,
QGauss<dim>(3),
VectorTools::L2_norm);
x.reinit(owned_set, MPI_COMM_WORLD);
VectorTools::interpolate(dofh,
- ConstantFunction<dim>(1),
+ Functions::ConstantFunction<dim>(1),
x);
const double norm = x.l2_norm();
if (myid == 0)
PETScWrappers::MPI::Vector x (MPI_COMM_WORLD,dofh.n_dofs(),owned_set.n_elements());
VectorTools::interpolate(dofh,
- ConstantFunction<dim,PetscScalar>(1),
+ Functions::ConstantFunction<dim,PetscScalar>(1),
x);
const double norm = x.l2_norm();
if (myid == 0)
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close ();
DynamicSparsityPattern csp (locally_relevant_dofs);
#endif
VectorTools::interpolate_boundary_values (dof_handler,
0,
- BoundaryValues<dim>(),//ZeroFunction<dim>(dim+1),
+ BoundaryValues<dim>(),//Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
VectorTools::interpolate_boundary_values (dof_handler,
1,
- BoundaryValues<dim>(),//ZeroFunction<dim>(dim+1),
+ BoundaryValues<dim>(),//Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (static_cast<const DoFHandler<dim>&>(mg_dof_handler),
dirichlet_boundary,
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (static_cast<const DoFHandler<dim>&>(mg_dof_handler),
dirichlet_boundary,
VectorTools::interpolate_boundary_values (dofh,
0,
- ZeroFunction<dim>(dim+1),
+ Functions::ZeroFunction<dim>(dim+1),
cm,
velocity_mask);
VectorTools::interpolate_boundary_values (dofh,
0,
- ZeroFunction<dim>(1),
+ Functions::ZeroFunction<dim>(1),
cm,
velocity_mask); */
TrilinosWrappers::MPI::Vector x_ref;
x_ref.reinit(owned_set, MPI_COMM_WORLD);
VectorTools::interpolate(dofh,
- ConstantFunction<dim> (1.),
+ Functions::ConstantFunction<dim> (1.),
x_ref);
TrilinosWrappers::MPI::Vector x1 (x_ref);
VectorTools::interpolate_boundary_values (dofh,
0,
- ZeroFunction<dim>(1),
+ Functions::ZeroFunction<dim>(1),
cm,
velocity_mask); */
v2_interpolated(v2);
// set first vector to 1
- VectorTools::interpolate(dof2, ConstantFunction<dim>(1.), v2);
+ VectorTools::interpolate(dof2, Functions::ConstantFunction<dim>(1.), v2);
for (unsigned int i=0; i<v2.local_size(); ++i)
Assert(v2.local_element(i) == 1., ExcInternalError());
v2(dof2.locally_owned_dofs(), locally_relevant_dofs2, MPI_COMM_WORLD);
// set first vector to 1
- VectorTools::interpolate(dof1, ConstantFunction<dim>(1.), v1);
+ VectorTools::interpolate(dof1, Functions::ConstantFunction<dim>(1.), v1);
for (unsigned int i=0; i<v1.local_size(); ++i)
Assert(v1.local_element(i) == 1., ExcInternalError());
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
constraints.close ();
#endif
VectorTools::interpolate_boundary_values (dof_handler,
0,
- BoundaryValues<dim>(),//ZeroFunction<dim>(dim+1),
+ BoundaryValues<dim>(),//Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
VectorTools::interpolate_boundary_values (dof_handler,
1,
- BoundaryValues<dim>(),//ZeroFunction<dim>(dim+1),
+ BoundaryValues<dim>(),//Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
VectorTools::interpolate_boundary_values (dof_handler,
1,
- ZeroFunction<dim>(dim+1),
+ Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
VectorTools::interpolate_boundary_values (dof_handler,
2,
- ZeroFunction<dim>(dim+1),
+ Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
VectorTools::interpolate_boundary_values (dof_handler,
3,
- ZeroFunction<dim>(dim+1),
+ Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
VectorTools::interpolate_boundary_values (dof_handler,
5,
- ZeroFunction<dim>(dim+1),
+ Functions::ZeroFunction<dim>(dim+1),
constraints,
fe.component_mask(velocities));
}
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close ();
DoFTools::make_hanging_node_constraints (dof_handler, constraints);
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
constraints);
constraints.close ();
DoFTools::make_hanging_node_constraints (dofh, cm);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (dofh,
dirichlet_boundary,
Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- ZeroFunction<dim> zero;
+ Functions::ZeroFunction<dim> zero;
typename FunctionMap<dim>::type fmap;
fmap.insert(std::make_pair(0, &zero));
parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy);
setup_tria(tr);
- ZeroFunction<dim> zero;
+ Functions::ZeroFunction<dim> zero;
typename FunctionMap<dim>::type fmap;
fmap.insert(std::make_pair(0, &zero));
}
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
mg_constrained_dofs_ref.initialize(dofhref, dirichlet_boundary);
}
MGConstrainedDoFs mg_constrained_dofs;
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
mg_constrained_dofs.initialize(dofh, dirichlet_boundary);
parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy);
setup_tria(tr);
- ZeroFunction<dim> zero;
+ Functions::ZeroFunction<dim> zero;
typename FunctionMap<dim>::type fmap;
fmap.insert(std::make_pair(0, &zero));
}
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
mg_constrained_dofs_ref.initialize(dofhref, dirichlet_boundary);
}
MGConstrainedDoFs mg_constrained_dofs;
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
mg_constrained_dofs.initialize(dofh, dirichlet_boundary);
Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- ZeroFunction<dim> zero;
+ Functions::ZeroFunction<dim> zero;
typename FunctionMap<dim>::type fmap;
fmap.insert(std::make_pair(0, &zero));
Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
GridGenerator::hyper_cube(tr);
tr.refine_global(2);
- ZeroFunction<dim> zero;
+ Functions::ZeroFunction<dim> zero;
typename FunctionMap<dim>::type fmap;
fmap.insert(std::make_pair(0, &zero));
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ConstantFunction<dim> homogeneous_dirichlet_bc (0.0);
+ Functions::ConstantFunction<dim> homogeneous_dirichlet_bc (0.0);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (mg_dof_handler,
dirichlet_boundary,
Triangulation<dim> tr(Triangulation<dim>::limit_level_difference_at_vertices);
GridGenerator::hyper_cube(tr,-1,1);
typename FunctionMap<dim>::type dirichlet_boundary_functions;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary_functions[0] = &homogeneous_dirichlet_bc;
tr.refine_global (1);
void LaplaceProblem<dim>::test ()
{
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> dirichlet_bc(fe.n_components());
+ Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
dirichlet_boundary[0] = &dirichlet_bc;
const unsigned int min_l = mg_matrices.min_level();
void LaplaceProblem<dim>::test_boundary ()
{
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> dirichlet_bc(fe.n_components());
+ Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
dirichlet_boundary[0] = &dirichlet_bc;
MGTools::make_boundary_list (mg_dof_handler_renumbered, dirichlet_boundary,
boundary_indices_renumbered);
void LaplaceProblem<dim>::test ()
{
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> dirichlet_bc(fe.n_components());
+ Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
dirichlet_boundary[0] = &dirichlet_bc;
MGConstrainedDoFs mg_constrained_dofs;
constraints.clear ();
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MappingQGeneric<dim> mapping(1);
VectorTools::interpolate_boundary_values (mapping,
constraints.clear ();
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MappingQGeneric<dim> mapping(1);
VectorTools::interpolate_boundary_values (mapping,
constraints.clear ();
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MappingQGeneric<dim> mapping(1);
VectorTools::interpolate_boundary_values (mapping,
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
DoFTools::make_hanging_node_constraints (mg_dof_handler, hanging_node_constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MappingQGeneric<dim> mapping(1);
VectorTools::interpolate_boundary_values (mapping,
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
DoFTools::make_hanging_node_constraints (mg_dof_handler, hanging_node_constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MappingQGeneric<dim> mapping(1);
VectorTools::interpolate_boundary_values (mapping,
constraints.clear ();
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MappingQGeneric<dim> mapping(1);
VectorTools::interpolate_boundary_values (mapping,
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc;
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc;
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (mg_dof_handler,
dirichlet_boundary,
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc;
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc;
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (mg_dof_handler,
dirichlet_boundary,
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc;
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc;
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (mg_dof_handler,
dirichlet_boundary,
constraints.clear ();
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MappingQGeneric<dim> mapping(1);
VectorTools::interpolate_boundary_values (mapping,
constraints.clear ();
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MappingQGeneric<dim> mapping(1);
VectorTools::interpolate_boundary_values (mapping,
constraints.clear ();
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MappingQGeneric<dim> mapping(1);
VectorTools::interpolate_boundary_values (mapping,
DoFTools::make_hanging_node_constraints (mg_dof_handler, constraints);
typename FunctionMap<dim>::type dirichlet_boundary;
- ConstantFunction<dim> homogeneous_dirichlet_bc (0.0);
+ Functions::ConstantFunction<dim> homogeneous_dirichlet_bc (0.0);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
VectorTools::interpolate_boundary_values (mg_dof_handler,
dirichlet_boundary,
}
- ZeroFunction<dim> zero;
+ Functions::ZeroFunction<dim> zero;
typename FunctionMap<dim>::type fmap;
fmap.insert(std::make_pair(0, &zero));
mgdof.distribute_mg_dofs(fe);
MGConstrainedDoFs mg_constrained_dofs;
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);
mgdof.distribute_mg_dofs(fe);
MGConstrainedDoFs mg_constrained_dofs;
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);
mgdof.distribute_mg_dofs(fe);
MGConstrainedDoFs mg_constrained_dofs;
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);
mgdof.distribute_mg_dofs(fe);
MGConstrainedDoFs mg_constrained_dofs;
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);
mgdof.distribute_mg_dofs(fe);
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> homogeneous_dirichlet_bc (1);
+ Functions::ZeroFunction<dim> homogeneous_dirichlet_bc (1);
dirichlet_boundary[0] = &homogeneous_dirichlet_bc;
MGConstrainedDoFs mg_constrained_dofs;
mgdof.distribute_mg_dofs(fe);
MGConstrainedDoFs mg_constrained_dofs;
- ZeroFunction<dim> zero_function;
+ Functions::ZeroFunction<dim> zero_function;
typename FunctionMap<dim>::type dirichlet_boundary;
dirichlet_boundary[0] = &zero_function;
mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);
std::vector<std::set<unsigned int> > boundary_indices(tr.n_levels());
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> dirichlet_bc(fe.n_components());
+ Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
dirichlet_boundary[3] = &dirichlet_bc;
MGConstrainedDoFs mg_constrained_dofs;
std::vector<std::set<types::global_dof_index> > boundary_indices(tr.n_levels());
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> dirichlet_bc(fe.n_components());
+ Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
dirichlet_boundary[3] = &dirichlet_bc;
MGTools::make_boundary_list (mg_dof_handler, dirichlet_boundary,
std::vector<std::set<types::global_dof_index> > boundary_indices(tr.n_levels());
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> dirichlet_bc(fe.n_components());
+ Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
dirichlet_boundary[3] = &dirichlet_bc;
MGTools::make_boundary_list (mg_dof_handler, dirichlet_boundary,
std::vector<std::set<types::global_dof_index> > boundary_indices(tr.n_levels());
typename FunctionMap<dim>::type dirichlet_boundary;
- ZeroFunction<dim> dirichlet_bc(fe.n_components());
+ Functions::ZeroFunction<dim> dirichlet_bc(fe.n_components());
dirichlet_boundary[3] = &dirichlet_bc;
MGTools::make_boundary_list (mg_dof_handler, dirichlet_boundary,
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1,1.),
+ Functions::ConstantFunction<dim>(1,1.),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ZeroFunction<dim>(2),
+ Functions::ZeroFunction<dim>(2),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1,1.),
+ Functions::ConstantFunction<dim>(1,1.),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1,1.),
+ Functions::ConstantFunction<dim>(1,1.),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ZeroFunction<dim>(2),
+ Functions::ZeroFunction<dim>(2),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1,1.),
+ Functions::ConstantFunction<dim>(1,1.),
constraints);
constraints.close ();
ConstraintMatrix constraints;
DoFTools::make_hanging_node_constraints (dof, constraints);
VectorTools::interpolate_boundary_values(dof, 0,
- ConstantFunction<dim>(1.,2),
+ Functions::ConstantFunction<dim>(1.,2),
constraints);
constraints.close ();
DoFHandler<dim> dof(tr);
dof.distribute_dofs(fe);
- ConstantFunction<dim> constant_function(1.,dim);
+ Functions::ConstantFunction<dim> constant_function(1.,dim);
typename FunctionMap<dim>::type function_map;
for (unsigned int j=0; j<GeometryInfo<dim>::faces_per_cell; ++j)
function_map[j] = &constant_function;
DoFHandler<dim> dof(tr);
dof.distribute_dofs(fe);
- ConstantFunction<dim> constant_function(1.,dim);
+ Functions::ConstantFunction<dim> constant_function(1.,dim);
typename FunctionMap<dim>::type function_map;
for (unsigned int j=0; j<GeometryInfo<dim>::faces_per_cell; ++j)
function_map[j] = &constant_function;
VectorTools::
interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (dim),
+ Functions::ZeroFunction<dim> (dim),
boundary_values);
VectorTools::
interpolate_boundary_values (dof_handler,
VectorTools::
interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim> (dim),
+ Functions::ZeroFunction<dim> (dim),
boundary_values);
VectorTools::
interpolate_boundary_values (dof_handler,
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(x_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(x_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(y_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(y_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(z_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(z_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(x_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(x_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(y_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(y_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(z_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(z_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(x_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(x_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(y_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(y_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(z_displacement));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
fe.component_mask(z_displacement));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)
|
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
}
if (apply_dirichlet_bc == true)
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
else
VectorTools::interpolate_boundary_values(dof_handler_ref,
boundary_id,
- ZeroFunction<dim>(n_components),
+ Functions::ZeroFunction<dim>(n_components),
constraints,
(fe.component_mask(x_displacement)));
}
system_matrix);
VectorTools::create_right_hand_side (mapping, dof_handler,
QGauss<dim>(gauss_degree),
- ConstantFunction<dim>(-2),
+ Functions::ConstantFunction<dim>(-2),
system_rhs);
Vector<double> tmp (system_rhs.size());
VectorTools::create_boundary_right_hand_side (mapping, dof_handler,
QGauss<dim-1>(gauss_degree),
- ConstantFunction<dim>(1),
+ Functions::ConstantFunction<dim>(1),
tmp);
system_rhs += tmp;
Vector<float> norm_per_cell (triangulation.n_active_cells());
VectorTools::integrate_difference (mapping, dof_handler,
solution,
- ZeroFunction<dim>(),
+ Functions::ZeroFunction<dim>(),
norm_per_cell,
QGauss<dim>(gauss_degree+1),
VectorTools::H1_seminorm);
dealii::DoFTools::make_hanging_node_constraints (dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values (dof_handler,
0,
- dealii::ZeroFunction<dim> (),
+ dealii::Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
dealii::DoFTools::make_hanging_node_constraints (dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values (dof_handler,
0,
- dealii::ZeroFunction<dim> (),
+ dealii::Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
dealii::DoFTools::make_hanging_node_constraints (dof_handler, constraints);
dealii::VectorTools::interpolate_boundary_values (dof_handler,
0,
- dealii::ZeroFunction<dim> (),
+ dealii::Functions::ZeroFunction<dim> (),
constraints);
constraints.close ();
DoFTools::make_hanging_node_constraints(dof_handler, constraints);
VectorTools::interpolate_boundary_values(dof_handler,
0,
- ZeroFunction<2>(),
+ Functions::ZeroFunction<2>(),
constraints);
constraints.close();
std::map<types::global_dof_index,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
- ZeroFunction<dim>(size.size()),
+ Functions::ZeroFunction<dim>(size.size()),
boundary_values);
MatrixTools::apply_boundary_values (boundary_values, Bb, bx, bb);
MatrixTools::apply_boundary_values (boundary_values, B, x, b);
Vector<double> cellwise_errors (tria.n_active_cells());
VectorTools::integrate_difference (dofh,
solution,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
cellwise_errors,
QGauss<dim>(5),
norm);
const dealii::Function<dim,double> *w = nullptr;
VectorTools::integrate_difference (dofh,
solution,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
cellwise_errors,
quadrature,
norm,
const dealii::Function<dim,double> *w = nullptr;
VectorTools::integrate_difference (dofh,
solution,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
cellwise_errors,
quadrature,
norm,
const dealii::Function<dim,double> *w = nullptr;
VectorTools::integrate_difference (dofh,
solution,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
cellwise_errors,
quadrature,
norm,
const dealii::Function<dim,double> *w = nullptr;
VectorTools::integrate_difference (dofh,
solution,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
cellwise_errors,
quadrature,
norm,
const dealii::Function<dim,double> *w = nullptr;
VectorTools::integrate_difference (dofh,
solution,
- ZeroFunction<dim>(dim),
+ Functions::ZeroFunction<dim>(dim),
cellwise_errors,
quadrature,
norm,