boost::python::object &pull_back)
{
return new FunctionManifold<dim, spacedim>(
- std_cxx14::make_unique<FunctionWrapper<dim>>(push_forward, spacedim),
- std_cxx14::make_unique<FunctionWrapper<spacedim>>(pull_back, dim));
+ std::make_unique<FunctionWrapper<dim>>(push_forward, spacedim),
+ std::make_unique<FunctionWrapper<spacedim>>(pull_back, dim));
}
// having to delete the pointer after use. For initializing, we want to use
// the C++14 function std::make_unique. Since deal.II only requires C++11 up
// to now, we define this function in a separate namespace called
- // `std_cxx14`. In case the compiler supports C++14, this just calls
+ // `std`. In case the compiler supports C++14, this just calls
// std::make_unique.
std::unique_ptr<LaplaceSolver::Base<dim>> solver;
if (solver_name == "global")
- solver = std_cxx14::make_unique<LaplaceSolver::RefinementGlobal<dim>>(
+ solver = std::make_unique<LaplaceSolver::RefinementGlobal<dim>>(
triangulation, fe, quadrature, rhs_function, boundary_values);
else if (solver_name == "kelly")
- solver = std_cxx14::make_unique<LaplaceSolver::RefinementKelly<dim>>(
+ solver = std::make_unique<LaplaceSolver::RefinementKelly<dim>>(
triangulation, fe, quadrature, rhs_function, boundary_values);
else
AssertThrow(false, ExcNotImplemented());
{
case ProblemDescription::dual_weighted_error_estimator:
{
- solver =
- std_cxx14::make_unique<LaplaceSolver::WeightedResidual<dim>>(
- triangulation,
- primal_fe,
- dual_fe,
- quadrature,
- face_quadrature,
- descriptor.data->get_right_hand_side(),
- descriptor.data->get_boundary_values(),
- *descriptor.dual_functional);
+ solver = std::make_unique<LaplaceSolver::WeightedResidual<dim>>(
+ triangulation,
+ primal_fe,
+ dual_fe,
+ quadrature,
+ face_quadrature,
+ descriptor.data->get_right_hand_side(),
+ descriptor.data->get_boundary_values(),
+ *descriptor.dual_functional);
break;
}
case ProblemDescription::global_refinement:
{
- solver =
- std_cxx14::make_unique<LaplaceSolver::RefinementGlobal<dim>>(
- triangulation,
- primal_fe,
- quadrature,
- face_quadrature,
- descriptor.data->get_right_hand_side(),
- descriptor.data->get_boundary_values());
+ solver = std::make_unique<LaplaceSolver::RefinementGlobal<dim>>(
+ triangulation,
+ primal_fe,
+ quadrature,
+ face_quadrature,
+ descriptor.data->get_right_hand_side(),
+ descriptor.data->get_boundary_values());
break;
}
case ProblemDescription::kelly_indicator:
+ {
+ solver = std::make_unique<LaplaceSolver::RefinementKelly<dim>>(
+ triangulation,
+ primal_fe,
+ quadrature,
+ face_quadrature,
+ descriptor.data->get_right_hand_side(),
+ descriptor.data->get_boundary_values());
+ break;
+ }
+
+ case ProblemDescription::weighted_kelly_indicator:
{
solver =
- std_cxx14::make_unique<LaplaceSolver::RefinementKelly<dim>>(
+ std::make_unique<LaplaceSolver::RefinementWeightedKelly<dim>>(
triangulation,
primal_fe,
quadrature,
face_quadrature,
descriptor.data->get_right_hand_side(),
- descriptor.data->get_boundary_values());
- break;
- }
-
- case ProblemDescription::weighted_kelly_indicator:
- {
- solver = std_cxx14::make_unique<
- LaplaceSolver::RefinementWeightedKelly<dim>>(
- triangulation,
- primal_fe,
- quadrature,
- face_quadrature,
- descriptor.data->get_right_hand_side(),
- descriptor.data->get_boundary_values(),
- *descriptor.kelly_weight);
+ descriptor.data->get_boundary_values(),
+ *descriptor.kelly_weight);
break;
}
// take here the description of <code>Exercise_2_3</code>, but you can
// also use <code>CurvedRidges@<dim@></code>:
descriptor.data =
- std_cxx14::make_unique<Data::SetUp<Data::Exercise_2_3<dim>, dim>>();
+ std::make_unique<Data::SetUp<Data::Exercise_2_3<dim>, dim>>();
// Next set first a dual functional, then a list of evaluation
// objects. We choose as default the evaluation of the value at an
// each step.
const Point<dim> evaluation_point(0.75, 0.75);
descriptor.dual_functional =
- std_cxx14::make_unique<DualFunctional::PointValueEvaluation<dim>>(
+ std::make_unique<DualFunctional::PointValueEvaluation<dim>>(
evaluation_point);
Evaluation::PointValueEvaluation<dim> postprocessor1(evaluation_point);
// Now we are ready to set-up the FESeries::Fourier object
const std::vector<unsigned int> n_coefficients_per_direction(
fe_collection.size(), N);
- fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
- n_coefficients_per_direction, fe_collection, fourier_q_collection);
+ fourier =
+ std::make_unique<FESeries::Fourier<dim>>(n_coefficients_per_direction,
+ fe_collection,
+ fourier_q_collection);
// We need to resize the matrix of fourier coefficients according to the
// number of modes N.
// of energy group objects and let them initialize their individual meshes
// with the coarse mesh generated above:
for (unsigned int group = 0; group < parameters.n_groups; ++group)
- energy_groups.emplace_back(std_cxx14::make_unique<EnergyGroup<dim>>(
+ energy_groups.emplace_back(std::make_unique<EnergyGroup<dim>>(
group, material_data, coarse_grid, fe));
convergence_table_stream.open("convergence_table");
convergence_table_stream.precision(12);
// unique pointer to its base class automatically:
std::unique_ptr<Manifold<3, 3>> AfricaGeometry::clone() const
{
- return std
_cxx14::make_unique<AfricaGeometry>();
+ return std::make_unique<AfricaGeometry>();
}
// @sect3{Set up}
//
// The function `DistributedLagrangeProblem::setup_grids_and_dofs()` is used
- // to set up the finite element spaces. Notice how `std_cxx14::make_unique` is
+ // to set up the finite element spaces. Notice how `std::make_unique` is
// used to create objects wrapped inside `std::unique_ptr` objects.
template <int dim, int spacedim>
void DistributedLagrangeProblem<dim, spacedim>::setup_grids_and_dofs()
// Initializing $\Omega$: constructing the Triangulation and wrapping it
// into a `std::unique_ptr` object
- space_grid = std_cxx14::make_unique<Triangulation<spacedim>>();
+ space_grid = std::make_unique<Triangulation<spacedim>>();
// Next, we actually create the triangulation using
// GridGenerator::hyper_cube(). The last argument is set to true: this
// GridTools::Cache with it.
space_grid->refine_global(parameters.initial_refinement);
space_grid_tools_cache =
- std_cxx14::make_unique<GridTools::Cache<spacedim, spacedim>>(*space_grid);
+ std::make_unique<GridTools::Cache<spacedim, spacedim>>(*space_grid);
// The same is done with the embedded grid. Since the embedded grid is
// deformed, we first need to setup the deformation mapping. We do so in the
// following few lines:
- embedded_grid = std_cxx14::make_unique<Triangulation<dim, spacedim>>();
+ embedded_grid = std::make_unique<Triangulation<dim, spacedim>>();
GridGenerator::hyper_cube(*embedded_grid);
embedded_grid->refine_global(parameters.initial_embedded_refinement);
- embedded_configuration_fe = std_cxx14::make_unique<FESystem<dim, spacedim>>(
+ embedded_configuration_fe = std::make_unique<FESystem<dim, spacedim>>(
FE_Q<dim, spacedim>(
parameters.embedded_configuration_finite_element_degree),
spacedim);
embedded_configuration_dh =
- std_cxx14::make_unique<DoFHandler<dim, spacedim>>(*embedded_grid);
+ std::make_unique<DoFHandler<dim, spacedim>>(*embedded_grid);
embedded_configuration_dh->distribute_dofs(*embedded_configuration_fe);
embedded_configuration.reinit(embedded_configuration_dh->n_dofs());
if (parameters.use_displacement == true)
embedded_mapping =
- std_cxx14::make_unique<MappingQEulerian<dim, Vector<double>, spacedim>>(
+ std::make_unique<MappingQEulerian<dim, Vector<double>, spacedim>>(
parameters.embedded_configuration_finite_element_degree,
*embedded_configuration_dh,
embedded_configuration);
else
embedded_mapping =
- std_cxx14::make_unique<MappingFEField<dim,
- spacedim,
- Vector<double>,
- DoFHandler<dim, spacedim>>>(
+ std::make_unique<MappingFEField<dim,
+ spacedim,
+ Vector<double>,
+ DoFHandler<dim, spacedim>>>(
*embedded_configuration_dh, embedded_configuration);
setup_embedded_dofs();
template <int dim, int spacedim>
void DistributedLagrangeProblem<dim, spacedim>::setup_embedding_dofs()
{
- space_dh = std_cxx14::make_unique<DoFHandler<spacedim>>(*space_grid);
- space_fe = std_cxx14::make_unique<FE_Q<spacedim>>(
+ space_dh = std::make_unique<DoFHandler<spacedim>>(*space_grid);
+ space_fe = std::make_unique<FE_Q<spacedim>>(
parameters.embedding_space_finite_element_degree);
space_dh->distribute_dofs(*space_fe);
template <int dim, int spacedim>
void DistributedLagrangeProblem<dim, spacedim>::setup_embedded_dofs()
{
- embedded_dh =
- std_cxx14::make_unique<DoFHandler<dim, spacedim>>(*embedded_grid);
- embedded_fe = std_cxx14::make_unique<FE_Q<dim, spacedim>>(
+ embedded_dh = std::make_unique<DoFHandler<dim, spacedim>>(*embedded_grid);
+ embedded_fe = std::make_unique<FE_Q<dim, spacedim>>(
parameters.embedded_space_finite_element_degree);
embedded_dh->distribute_dofs(*embedded_fe);
using Smoother = PreconditionSOR<SparseMatrix<double>>;
auto smoother =
- std_cxx14::make_unique<MGSmootherPrecondition<SparseMatrix<double>,
- Smoother,
- Vector<double>>>();
+ std::make_unique<MGSmootherPrecondition<SparseMatrix<double>,
+ Smoother,
+ Vector<double>>>();
smoother->initialize(mg_matrices,
Smoother::AdditionalData(fe.degree == 1 ? 1.0 :
0.62));
{
using Smoother = PreconditionJacobi<SparseMatrix<double>>;
auto smoother =
- std_cxx14::make_unique<MGSmootherPrecondition<SparseMatrix<double>,
- Smoother,
- Vector<double>>>();
+ std::make_unique<MGSmootherPrecondition<SparseMatrix<double>,
+ Smoother,
+ Vector<double>>>();
smoother->initialize(mg_matrices,
Smoother::AdditionalData(fe.degree == 1 ? 0.6667 :
0.47));
if (settings.smoother_type == "block SOR")
{
- auto smoother = std_cxx14::make_unique<MGSmootherPrecondition<
+ auto smoother = std::make_unique<MGSmootherPrecondition<
SparseMatrix<double>,
RelaxationBlockSOR<SparseMatrix<double>, double, Vector<double>>,
Vector<double>>>();
}
else if (settings.smoother_type == "block Jacobi")
{
- auto smoother = std_cxx14::make_unique<
+ auto smoother = std::make_unique<
MGSmootherPrecondition<SparseMatrix<double>,
RelaxationBlockJacobi<SparseMatrix<double>,
double,
triangulation.refine_global(2);
euler_operator.set_inflow_boundary(
- 0, std_cxx14::make_unique<ExactSolution<dim>>(0));
+ 0, std::make_unique<ExactSolution<dim>>(0));
break;
}
triangulation, 0.03, 1, 0, true);
euler_operator.set_inflow_boundary(
- 0, std_cxx14::make_unique<ExactSolution<dim>>(0));
+ 0, std::make_unique<ExactSolution<dim>>(0));
euler_operator.set_subsonic_outflow_boundary(
- 1, std_cxx14::make_unique<ExactSolution<dim>>(0));
+ 1, std::make_unique<ExactSolution<dim>>(0));
euler_operator.set_wall_boundary(2);
euler_operator.set_wall_boundary(3);
if (dim == 3)
euler_operator.set_body_force(
- std_cxx14::make_unique<Functions::ConstantFunction<dim>>(
+ std::make_unique<Functions::ConstantFunction<dim>>(
std::vector<double>({0., 0., -0.2})));
break;
{
TimerOutput::Scope t(computing_timer, "Initial setup");
- fluid_fe = std_cxx14::make_unique<FESystem<spacedim>>(
- FE_Q<spacedim>(par.velocity_degree),
- spacedim,
- FE_Q<spacedim>(par.velocity_degree - 1),
- 1);
+ fluid_fe =
+ std::make_unique<FESystem<spacedim>>(FE_Q<spacedim>(par.velocity_degree),
+ spacedim,
+ FE_Q<spacedim>(par.velocity_degree -
+ 1),
+ 1);
- solid_fe = std_cxx14::make_unique<FE_Nothing<dim, spacedim>>();
+ solid_fe = std::make_unique<FE_Nothing<dim, spacedim>>();
solid_dh.distribute_dofs(*solid_fe);
fluid_quadrature_formula =
- std_cxx14::make_unique<QGauss<spacedim>>(par.velocity_degree + 1);
+ std::make_unique<QGauss<spacedim>>(par.velocity_degree + 1);
solid_quadrature_formula =
- std_cxx14::make_unique<QGauss<dim>>(par.velocity_degree + 1);
+ std::make_unique<QGauss<dim>>(par.velocity_degree + 1);
}
AssertThrowMPI(ierr);
// allocate memory for answer message
- request_buffers.emplace_back(
- std_cxx14::make_unique<std::vector<T2>>());
- request_requests.emplace_back(
- std_cxx14::make_unique<MPI_Request>());
+ request_buffers.emplace_back(std::make_unique<std::vector<T2>>());
+ request_requests.emplace_back(std::make_unique<MPI_Request>());
// process request
auto &request_buffer = *request_buffers.back();
*
* void HelperClass::create_new (const unsigned int run_no)
* {
- * p = std
_cxx14::make_unique<Problem>());
+ * p = std::make_unique<Problem>());
* }
*
*
std::unique_ptr<Patterns::PatternBase>>::type
to_pattern()
{
- return std
_cxx14::make_unique<Patterns::Bool>();
+ return std::make_unique<Patterns::Bool>();
}
template <typename Dummy = T>
std::unique_ptr<Patterns::PatternBase>>::type
to_pattern()
{
- return std
_cxx14::make_unique<Patterns::Integer>(
+ return std::make_unique<Patterns::Integer>(
std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
}
std::unique_ptr<Patterns::PatternBase>>::type
to_pattern()
{
- return std
_cxx14::make_unique<Patterns::Double>(
+ return std::make_unique<Patterns::Double>(
std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
}
constexpr int
max_list_rank()
{
- return std_cxx14::max(RankInfo<T1>::list_rank,
- max_list_rank<T2, Types...>());
+ return std::max(RankInfo<T1>::list_rank, max_list_rank<T2, Types...>());
}
// Helper function for map_rank
constexpr int
max_map_rank()
{
- return std_cxx14::max(RankInfo<T1>::map_rank,
- max_map_rank<T2, Types...>());
+ return std::max(RankInfo<T1>::map_rank, max_map_rank<T2, Types...>());
}
// Rank of vector types
struct RankInfo<std::pair<Key, Value>>
{
static constexpr int list_rank =
- std_cxx14::max(RankInfo<Key>::list_rank, RankInfo<Value>::list_rank);
+ std::max(RankInfo<Key>::list_rank, RankInfo<Value>::list_rank);
static constexpr int map_rank =
- std_cxx14::max(RankInfo<Key>::map_rank, RankInfo<Value>::map_rank) +
- 1;
+ std::max(RankInfo<Key>::map_rank, RankInfo<Value>::map_rank) + 1;
};
{
static_assert(internal::RankInfo<T>::list_rank > 0,
"Cannot use this class for non List-compatible types.");
- return std
_cxx14::make_unique<Patterns::List>(
+ return std::make_unique<Patterns::List>(
*Convert<typename T::value_type>::to_pattern(),
0,
std::numeric_limits<unsigned int>::max(),
"Cannot use this class for non List-compatible types.");
static_assert(internal::RankInfo<T>::map_rank > 0,
"Cannot use this class for non Map-compatible types.");
- return std
_cxx14::make_unique<Patterns::Map>(
+ return std::make_unique<Patterns::Map>(
*Convert<typename T::key_type>::to_pattern(),
*Convert<typename T::mapped_type>::to_pattern(),
0,
{
static_assert(internal::RankInfo<T>::list_rank > 0,
"Cannot use this class for non List-compatible types.");
- return std
_cxx14::make_unique<Patterns::List>(
+ return std::make_unique<Patterns::List>(
*Convert<typename T::value_type>::to_pattern(),
dim,
dim,
static_assert(internal::RankInfo<T>::list_rank > 0,
"Cannot use this class for non List-compatible types.");
- return std
_cxx14::make_unique<Patterns::List>(
+ return std::make_unique<Patterns::List>(
Patterns::Anything(),
1,
Patterns::List::max_int_value,
const auto expressions =
Utilities::split_string_list(s, p->get_separator());
- T t = std_cxx14::make_unique<FunctionParser<dim>>(expressions.size());
+ T t = std::make_unique<FunctionParser<dim>>(expressions.size());
const std::string var =
FunctionParser<dim>::default_variable_names() + ",t";
const typename FunctionParser<dim>::ConstMap constants;
{
static_assert(internal::RankInfo<T>::list_rank > 0,
"Cannot use this class for non List-compatible types.");
- return std
_cxx14::make_unique<Patterns::List>(
+ return std::make_unique<Patterns::List>(
*Convert<typename T::value_type>::to_pattern(),
2,
2,
static std::unique_ptr<Patterns::PatternBase>
to_pattern()
{
- return std
_cxx14::make_unique<Patterns::Anything>();
+ return std::make_unique<Patterns::Anything>();
}
static std::string
{
static_assert(internal::RankInfo<T>::map_rank > 0,
"Cannot use this class for non Map-compatible types.");
- return std
_cxx14::make_unique<Patterns::Tuple>(
+ return std::make_unique<Patterns::Tuple>(
internal::default_map_separator[internal::RankInfo<T>::map_rank - 1],
*Convert<Key>::to_pattern(),
*Convert<Value>::to_pattern());
{
static_assert(internal::RankInfo<T>::map_rank > 0,
"Cannot use this class for non tuple-compatible types.");
- return std
_cxx14::make_unique<Patterns::Tuple>(
+ return std::make_unique<Patterns::Tuple>(
internal::default_map_separator[internal::RankInfo<T>::map_rank - 1],
*Convert<Args>::to_pattern()...);
}
static std::array<std::string, std::tuple_size<T>::value>
to_string_internal_1(const T & t,
const Patterns::Tuple &pattern,
- std_cxx14::index_sequence<U...>)
+ std::index_sequence<U...>)
{
std::array<std::string, std::tuple_size<T>::value> a = {
{Convert<typename std::tuple_element<U, T>::type>::to_string(
to_string_internal_2(const T &t, const Patterns::Tuple &pattern)
{
return Convert<T>::to_string_internal_1(
- t,
- pattern,
- std_cxx14::make_index_sequence<std::tuple_size<T>::value>{});
+ t, pattern, std::make_index_sequence<std::tuple_size<T>::value>{});
}
template <std::size_t... U>
static T
to_value_internal_1(const std::vector<std::string> &s,
const Patterns::Tuple & pattern,
- std_cxx14::index_sequence<U...>)
+ std::index_sequence<U...>)
{
return std::make_tuple(
Convert<typename std::tuple_element<U, T>::type>::to_value(
const Patterns::Tuple & pattern)
{
return Convert<T>::to_value_internal_1(
- s,
- pattern,
- std_cxx14::make_index_sequence<std::tuple_size<T>::value>{});
+ s, pattern, std::make_index_sequence<std::tuple_size<T>::value>{});
}
};
std::unique_ptr<ScalarPolynomialsBase<dim>>
clone() const override
{
- return std
_cxx14::make_unique<PolynomialsP<dim>>(*this);
+ return std::make_unique<PolynomialsP<dim>>(*this);
}
private:
#ifndef __cpp_lib_apply
template <typename F, typename Tuple, size_t... S>
auto
- apply_impl(F &&fn, Tuple &&t, std_cxx14::index_sequence<S...>)
+ apply_impl(F &&fn, Tuple &&t, std::index_sequence<S...>)
-> decltype(std::forward<F>(fn)(std::get<S>(std::forward<Tuple>(t))...))
{
return std::forward<F>(fn)(std::get<S>(std::forward<Tuple>(t))...);
apply(F &&fn, Tuple &&t) -> decltype(apply_impl(
std::forward<F>(fn),
std::forward<Tuple>(t),
- std_cxx14::make_index_sequence<
+ std::make_index_sequence<
std::tuple_size<typename std::remove_reference<Tuple>::type>::value>()))
{
std::size_t constexpr tSize =
std::tuple_size<typename std::remove_reference<Tuple>::type>::value;
return apply_impl(std::forward<F>(fn),
std::forward<Tuple>(t),
- std_cxx14::make_index_sequence<tSize>());
+ std::make_index_sequence<tSize>());
}
#else
using std::apply;
*/
template <typename ArrayLike, std::size_t... Indices>
constexpr DEAL_II_CUDA_HOST_DEV
- Tensor(const ArrayLike &initializer, std_cxx14::index_sequence<Indices...>);
+ Tensor(const ArrayLike &initializer, std::index_sequence<Indices...>);
// Allow an arbitrary Tensor to access the underlying values.
template <int, int, typename>
template <typename ArrayLike, std::size_t... indices>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
Tensor<rank_, dim, Number>::Tensor(const ArrayLike &initializer,
- std_cxx14::index_sequence<indices...>)
+ std::index_sequence<indices...>)
: values{Tensor<rank_ - 1, dim, Number>(initializer[indices])...}
{
static_assert(sizeof...(indices) == dim,
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
Tensor<rank_, dim, Number>::Tensor(const array_type &initializer)
- : Tensor(initializer, std_cxx14::make_index_sequence<dim>{})
+ : Tensor(initializer, std::make_index_sequence<dim>{})
{}
constexpr DEAL_II_ALWAYS_INLINE DEAL_II_CUDA_HOST_DEV
Tensor<rank_, dim, Number>::Tensor(
const Tensor<rank_, dim, OtherNumber> &initializer)
- : Tensor(initializer, std_cxx14::make_index_sequence<dim>{})
+ : Tensor(initializer, std::make_index_sequence<dim>{})
{}
constexpr DEAL_II_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor(
const Tensor<1, dim, Tensor<rank_ - 1, dim, OtherNumber>> &initializer)
- : Tensor(initializer, std_cxx14::make_index_sequence<dim>{})
+ : Tensor(initializer, std::make_index_sequence<dim>{})
{}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_DGVector<PolynomialType, dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_DGVector<PolynomialType, dim, spacedim>>(
- *this);
+ return std::make_unique<FE_DGVector<PolynomialType, dim, spacedim>>(*this);
}
spacedim>
& /*output_data*/) const override
{
- return std_cxx14::make_unique<
+ return std::make_unique<
typename FiniteElement<1, spacedim>::InternalDataBase>();
}
& /*output_data*/) const override
{
// generate a new data object and initialize some fields
- auto data_ptr = std_cxx14::make_unique<
- typename FiniteElement<1, spacedim>::InternalDataBase>();
+ auto data_ptr =
+ std::make_unique<typename FiniteElement<1, spacedim>::InternalDataBase>();
data_ptr->update_each = requires_update_flags(update_flags);
const unsigned int n_q_points = quadrature.size();
// generate a new data object and
// initialize some fields
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
- data_ptr = std_cxx14::make_unique<InternalData>();
+ data_ptr = std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.update_each = requires_update_flags(update_flags);
spacedim>
& /*output_data*/) const override
{
- return std_cxx14::make_unique<InternalData>();
+ return std::make_unique<InternalData>();
}
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
// generate a new data object and
// initialize some fields
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
- data_ptr = std_cxx14::make_unique<InternalData>();
+ data_ptr = std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.update_each = requires_update_flags(update_flags);
// generate a new data object and
// initialize some fields
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
- data_ptr = std_cxx14::make_unique<InternalData>();
+ data_ptr = std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.update_each = requires_update_flags(update_flags);
std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
FEFactory<FE>::get(const unsigned int degree) const
{
- return std_cxx14::make_unique<FE>(degree);
+ return std::make_unique<FE>(degree);
}
namespace Compositing
std::unique_ptr<FiniteElement<1, 1>>
FEFactory<FE_Q<1, 1>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_Q<1>>(quad);
+ return std::make_unique<FE_Q<1>>(quad);
}
template <>
std::unique_ptr<FiniteElement<2, 2>>
FEFactory<FE_Q<2, 2>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_Q<2>>(quad);
+ return std::make_unique<FE_Q<2>>(quad);
}
template <>
std::unique_ptr<FiniteElement<3, 3>>
FEFactory<FE_Q<3, 3>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_Q<3>>(quad);
+ return std::make_unique<FE_Q<3>>(quad);
}
// Specializations for FE_Q_DG0.
std::unique_ptr<FiniteElement<1, 1>>
FEFactory<FE_Q_DG0<1, 1>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_Q_DG0<1>>(quad);
+ return std::make_unique<FE_Q_DG0<1>>(quad);
}
template <>
std::unique_ptr<FiniteElement<2, 2>>
FEFactory<FE_Q_DG0<2, 2>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_Q_DG0<2>>(quad);
+ return std::make_unique<FE_Q_DG0<2>>(quad);
}
template <>
std::unique_ptr<FiniteElement<3, 3>>
FEFactory<FE_Q_DG0<3, 3>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_Q_DG0<3>>(quad);
+ return std::make_unique<FE_Q_DG0<3>>(quad);
}
// Specializations for FE_Q_Bubbles.
std::unique_ptr<FiniteElement<1, 1>>
FEFactory<FE_Q_Bubbles<1, 1>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_Q_Bubbles<1>>(quad);
+ return std::make_unique<FE_Q_Bubbles<1>>(quad);
}
template <>
std::unique_ptr<FiniteElement<2, 2>>
FEFactory<FE_Q_Bubbles<2, 2>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_Q_Bubbles<2>>(quad);
+ return std::make_unique<FE_Q_Bubbles<2>>(quad);
}
template <>
std::unique_ptr<FiniteElement<3, 3>>
FEFactory<FE_Q_Bubbles<3, 3>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_Q_Bubbles<3>>(quad);
+ return std::make_unique<FE_Q_Bubbles<3>>(quad);
}
// Specializations for FE_DGQArbitraryNodes.
std::unique_ptr<FiniteElement<1, 1>>
FEFactory<FE_DGQ<1>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_DGQArbitraryNodes<1>>(quad);
+ return std::make_unique<FE_DGQArbitraryNodes<1>>(quad);
}
template <>
std::unique_ptr<FiniteElement<1, 2>>
FEFactory<FE_DGQ<1, 2>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_DGQArbitraryNodes<1, 2>>(quad);
+ return std::make_unique<FE_DGQArbitraryNodes<1, 2>>(quad);
}
template <>
std::unique_ptr<FiniteElement<1, 3>>
FEFactory<FE_DGQ<1, 3>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_DGQArbitraryNodes<1, 3>>(quad);
+ return std::make_unique<FE_DGQArbitraryNodes<1, 3>>(quad);
}
template <>
std::unique_ptr<FiniteElement<2, 2>>
FEFactory<FE_DGQ<2>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_DGQArbitraryNodes<2>>(quad);
+ return std::make_unique<FE_DGQArbitraryNodes<2>>(quad);
}
template <>
std::unique_ptr<FiniteElement<2, 3>>
FEFactory<FE_DGQ<2, 3>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_DGQArbitraryNodes<2, 3>>(quad);
+ return std::make_unique<FE_DGQArbitraryNodes<2, 3>>(quad);
}
template <>
std::unique_ptr<FiniteElement<3, 3>>
FEFactory<FE_DGQ<3>>::get(const Quadrature<1> &quad) const
{
- return std_cxx14::make_unique<FE_DGQArbitraryNodes<3>>(quad);
+ return std::make_unique<FE_DGQArbitraryNodes<3>>(quad);
}
std::map<std::string, std::unique_ptr<const Subscriptor>> &result)
{
result["FE_Q_Hierarchical"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Q_Hierarchical<dim>>>();
- result["FE_ABF"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_ABF<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_Q_Hierarchical<dim>>>();
+ result["FE_ABF"] = std::make_unique<FETools::FEFactory<FE_ABF<dim>>>();
result["FE_Bernstein"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Bernstein<dim>>>();
- result["FE_BDM"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_BDM<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_Bernstein<dim>>>();
+ result["FE_BDM"] = std::make_unique<FETools::FEFactory<FE_BDM<dim>>>();
result["FE_DGBDM"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGBDM<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGBDM<dim>>>();
result["FE_DGNedelec"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGNedelec<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGNedelec<dim>>>();
result["FE_DGRaviartThomas"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGRaviartThomas<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGRaviartThomas<dim>>>();
result["FE_RaviartThomas"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_RaviartThomas<dim>>>();
- result["FE_RaviartThomasNodal"] = std_cxx14::make_unique<
- FETools::FEFactory<FE_RaviartThomasNodal<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_RaviartThomas<dim>>>();
+ result["FE_RaviartThomasNodal"] =
+ std::make_unique<FETools::FEFactory<FE_RaviartThomasNodal<dim>>>();
result["FE_RT_Bubbles"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_RT_Bubbles<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_RT_Bubbles<dim>>>();
result["FE_Nedelec"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Nedelec<dim>>>();
- result["FE_DGPNonparametric"] = std_cxx14::make_unique<
- FETools::FEFactory<FE_DGPNonparametric<dim>>>();
- result["FE_DGP"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGP<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_Nedelec<dim>>>();
+ result["FE_DGPNonparametric"] =
+ std::make_unique<FETools::FEFactory<FE_DGPNonparametric<dim>>>();
+ result["FE_DGP"] = std::make_unique<FETools::FEFactory<FE_DGP<dim>>>();
result["FE_DGPMonomial"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGPMonomial<dim>>>();
- result["FE_DGQ"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGQ<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGPMonomial<dim>>>();
+ result["FE_DGQ"] = std::make_unique<FETools::FEFactory<FE_DGQ<dim>>>();
result["FE_DGQArbitraryNodes"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGQ<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGQ<dim>>>();
result["FE_DGQLegendre"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGQLegendre<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGQLegendre<dim>>>();
result["FE_DGQHermite"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGQHermite<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGQHermite<dim>>>();
result["FE_FaceQ"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_FaceQ<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_FaceQ<dim>>>();
result["FE_FaceP"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_FaceP<dim>>>();
- result["FE_Q"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Q<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_FaceP<dim>>>();
+ result["FE_Q"] = std::make_unique<FETools::FEFactory<FE_Q<dim>>>();
result["FE_Q_DG0"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Q_DG0<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_Q_DG0<dim>>>();
result["FE_Q_Bubbles"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Q_Bubbles<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_Q_Bubbles<dim>>>();
result["FE_Q_iso_Q1"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Q_iso_Q1<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_Q_iso_Q1<dim>>>();
result["FE_Nothing"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Nothing<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_Nothing<dim>>>();
result["FE_RannacherTurek"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_RannacherTurek<dim>>>();
+ std::make_unique<FETools::FEFactory<FE_RannacherTurek<dim>>>();
}
fill_codim_fe_names(
std::map<std::string, std::unique_ptr<const Subscriptor>> &result)
{
- result["FE_Bernstein"] = std_cxx14::make_unique<
- FETools::FEFactory<FE_Bernstein<dim, spacedim>>>();
+ result["FE_Bernstein"] =
+ std::make_unique<FETools::FEFactory<FE_Bernstein<dim, spacedim>>>();
result["FE_DGP"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGP<dim, spacedim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGP<dim, spacedim>>>();
result["FE_DGQ"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGQ<dim, spacedim>>>();
- result["FE_Nothing"] = std_cxx14::make_unique<
- FETools::FEFactory<FE_Nothing<dim, spacedim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGQ<dim, spacedim>>>();
+ result["FE_Nothing"] =
+ std::make_unique<FETools::FEFactory<FE_Nothing<dim, spacedim>>>();
result["FE_DGQArbitraryNodes"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_DGQ<dim, spacedim>>>();
- result["FE_DGQLegendre"] = std_cxx14::make_unique<
- FETools::FEFactory<FE_DGQLegendre<dim, spacedim>>>();
- result["FE_DGQHermite"] = std_cxx14::make_unique<
- FETools::FEFactory<FE_DGQHermite<dim, spacedim>>>();
- result["FE_Q_Bubbles"] = std_cxx14::make_unique<
- FETools::FEFactory<FE_Q_Bubbles<dim, spacedim>>>();
+ std::make_unique<FETools::FEFactory<FE_DGQ<dim, spacedim>>>();
+ result["FE_DGQLegendre"] =
+ std::make_unique<FETools::FEFactory<FE_DGQLegendre<dim, spacedim>>>();
+ result["FE_DGQHermite"] =
+ std::make_unique<FETools::FEFactory<FE_DGQHermite<dim, spacedim>>>();
+ result["FE_Q_Bubbles"] =
+ std::make_unique<FETools::FEFactory<FE_Q_Bubbles<dim, spacedim>>>();
result["FE_Q_DG0"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Q_DG0<dim, spacedim>>>();
- result["FE_Q_iso_Q1"] = std_cxx14::make_unique<
- FETools::FEFactory<FE_Q_iso_Q1<dim, spacedim>>>();
+ std::make_unique<FETools::FEFactory<FE_Q_DG0<dim, spacedim>>>();
+ result["FE_Q_iso_Q1"] =
+ std::make_unique<FETools::FEFactory<FE_Q_iso_Q1<dim, spacedim>>>();
result["FE_Q"] =
- std_cxx14::make_unique<FETools::FEFactory<FE_Q<dim, spacedim>>>();
- result["FE_Bernstein"] = std_cxx14::make_unique<
- FETools::FEFactory<FE_Bernstein<dim, spacedim>>>();
+ std::make_unique<FETools::FEFactory<FE_Q<dim, spacedim>>>();
+ result["FE_Bernstein"] =
+ std::make_unique<FETools::FEFactory<FE_Bernstein<dim, spacedim>>>();
}
// The function filling the vector fe_name_map below. It iterates
// ok, apparently everything went ok. so generate the composed
// element. and return it.
- return std_cxx14::make_unique<FESystem<dim, spacedim>>(
+ return std::make_unique<FESystem<dim, spacedim>>(
raw_base_fes, base_multiplicities);
}
else if (name_part == "FE_Nothing")
.get() == nullptr)
{
auto interpolation_matrix =
- std_cxx14::make_unique<FullMatrix<double>>(dofs_per_cell2,
- dofs_per_cell1);
+ std::make_unique<FullMatrix<double>>(dofs_per_cell2,
+ dofs_per_cell1);
get_interpolation_matrix(cell1->get_fe(),
cell2->get_fe(),
if (interpolation_matrices[&cell->get_fe()] == nullptr)
{
interpolation_matrices[&cell->get_fe()] =
- std_cxx14::make_unique<FullMatrix<double>>(dofs_per_cell1,
- dofs_per_cell1);
+ std::make_unique<FullMatrix<double>>(dofs_per_cell1,
+ dofs_per_cell1);
get_back_interpolation_matrix(
cell->get_fe(), fe2, *interpolation_matrices[&cell->get_fe()]);
}
CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>::
clone() const
{
- return std_cxx14::make_unique<
+ return std::make_unique<
CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>>(
*F, *G);
}
std::unique_ptr<typename FilteredIterator<BaseIterator>::PredicateBase>
FilteredIterator<BaseIterator>::PredicateTemplate<Predicate>::clone() const
{
- return std
_cxx14::make_unique<PredicateTemplate>(predicate);
+ return std::make_unique<PredicateTemplate>(predicate);
}
* This constructor is useful because it allows creating function objects at
* the place of calling the constructor without having to name and later
* delete these objects. This allows the following idiom:
- * FunctionManifold<dim> manifold(std_cxx14::make_unique<MyPushForward>(...),
- * std_cxx14::make_unique<MyPullBack>(...));
+ * FunctionManifold<dim> manifold(std::make_unique<MyPushForward>(...),
+ * std::make_unique<MyPullBack>(...));
*/
FunctionManifold(
std::unique_ptr<Function<chartdim>> push_forward,
spacedim_B,
chartdim_B>::clone() const
{
- return std_cxx14::make_unique<TensorProductManifold<dim,
- dim_A,
- spacedim_A,
- chartdim_A,
- dim_B,
- spacedim_B,
- chartdim_B>>(*manifold_A,
- *manifold_B);
+ return std::make_unique<TensorProductManifold<dim,
+ dim_A,
+ spacedim_A,
+ chartdim_A,
+ dim_B,
+ spacedim_B,
+ chartdim_B>>(*manifold_A,
+ *manifold_B);
}
template <int dim,
cols->sparsity_pattern.n_nonzero_elements() * chunk_size * chunk_size;
if (N > max_len || max_len == 0)
{
- val = std_cxx14::make_unique<number[]>(N);
+ val = std::make_unique<number[]>(N);
max_len = N;
}
AssertThrow(c == '[', ExcIO());
// reallocate space
- val = std_cxx14::make_unique<number[]>(max_len);
+ val = std::make_unique<number[]>(max_len);
// then read data
in.read(reinterpret_cast<char *>(val.get()),
if (this->current_size == 0)
{
this->R.grow_or_shrink(this->current_size + 1);
- this->columns.push_back(std_cxx14::make_unique<VectorType>(column));
+ this->columns.push_back(std::make_unique<VectorType>(column));
this->R(0, 0) = column.l2_norm();
++this->current_size;
}
// at this point we update is successful and we can enlarge R
// and store the column:
- this->columns.push_back(std_cxx14::make_unique<VectorType>(column));
+ this->columns.push_back(std::make_unique<VectorType>(column));
this->R.grow_or_shrink(this->current_size + 1);
this->R(this->current_size, this->current_size) = std::sqrt(rho2);
for (unsigned int i = 0; i < this->current_size; ++i)
{
// resize R:
this->R.grow_or_shrink(this->current_size + 1);
- this->columns.push_back(std_cxx14::make_unique<VectorType>(column));
+ this->columns.push_back(std::make_unique<VectorType>(column));
// now a Gram-Schmidt part: orthonormalize the new column
// against everything we have so far:
r->reinit(x);
x_->reinit(x);
- gamma_ = std_cxx14::make_unique<dealii::Vector<double>>(gamma.size());
+ gamma_ = std::make_unique<dealii::Vector<double>>(gamma.size());
}
bool re_orthogonalize = additional_data.force_re_orthogonalization;
const std::size_t N = cols->n_nonzero_elements();
if (N > max_len || max_len == 0)
{
- val = std_cxx14::make_unique<number[]>(N);
+ val = std::make_unique<number[]>(N);
max_len = N;
}
AssertThrow(c == '[', ExcIO());
// reallocate space
- val = std_cxx14::make_unique<number[]>(max_len);
+ val = std::make_unique<number[]>(max_len);
// then read data
in.read(reinterpret_cast<char *>(val.get()),
ar &max_dim &rows &cols &max_vec_len &max_row_length &compressed;
- rowstart = std_cxx14::make_unique<std::size_t[]>(max_dim + 1);
- colnums = std_cxx14::make_unique<size_type[]>(max_vec_len);
+ rowstart = std::make_unique<std::size_t[]>(max_dim + 1);
+ colnums = std::make_unique<size_type[]>(max_vec_len);
ar &boost::serialization::make_array(rowstart.get(), max_dim + 1);
ar &boost::serialization::make_array(colnums.get(), max_vec_len);
Tpetra::Map<int, types::global_dof_index> input_map =
parallel_partitioner.make_tpetra_map(communicator, false);
if (vector->getMap()->isSameAs(input_map) == false)
- vector = std_cxx14::make_unique<
+ vector = std::make_unique<
Tpetra::Vector<Number, int, types::global_dof_index>>(Teuchos::rcp(
new Tpetra::Map<int, types::global_dof_index>(input_map)));
else if (omit_zeroing_entries == false)
Tpetra::REPLACE);
}
else
- vector = std_cxx14::make_unique<
+ vector = std::make_unique<
Tpetra::Vector<Number, int, types::global_dof_index>>(
V.trilinos_vector());
}
++i)
{
i->first = false;
- i->second = std_cxx14::make_unique<VectorType>();
+ i->second = std::make_unique<VectorType>();
}
}
}
}
// no free vector found, so let's just allocate a new one
- get_pool().data->emplace_back(true, std_cxx14::make_unique<VectorType>());
+ get_pool().data->emplace_back(true, std::make_unique<VectorType>());
return get_pool().data->back().second.get();
}
dof_handler.get_triangulation().n_active_cells()));
- auto new_entry = std_cxx14::make_unique<
+ auto new_entry = std::make_unique<
internal::DataOutImplementation::DataEntry<DoFHandlerType, VectorType>>(
&dof_handler, &vec, &data_postprocessor);
dof_data.emplace_back(std::move(new_entry));
DataComponentInterpretation::component_is_scalar));
// finally, add the data vector:
- auto new_entry = std_cxx14::make_unique<
+ auto new_entry = std::make_unique<
internal::DataOutImplementation::DataEntry<DoFHandlerType, VectorType>>(
dof_handler, &data_vector, deduced_names, data_component_interpretation);
ExcMessage(
"Invalid number of entries in data_component_interpretation."));
- auto new_entry = std_cxx14::make_unique<
+ auto new_entry = std::make_unique<
internal::DataOutImplementation::MGDataEntry<DoFHandlerType, VectorType>>(
&dof_handler, &data, deduced_names, data_component_interpretation);
dof_data.emplace_back(std::move(new_entry));
if (cache.size() == 0)
// nothing is cached, just copy a given element
{
- new_el = std_cxx14::make_unique<T>(element);
+ new_el = std::make_unique<T>(element);
}
else
// something is cached, take one element and copy
static std::unique_ptr<Patterns::PatternBase>
to_pattern()
{
- return std
_cxx14::make_unique<Patterns::Selection>(
+ return std::make_unique<Patterns::Selection>(
"mean|L1_norm|L2_norm|Lp_norm|"
"Linfty_norm|H1_seminorm|Hdiv_seminorm|"
"H1_norm|W1p_seminorm|W1p_norm|"
{
auto constants_map = Patterns::Tools::Convert<ConstMap>::to_value(
constants,
- std
_cxx14::make_unique<Patterns::Map>(Patterns::Anything(),
- Patterns::Double(),
- 0,
- Patterns::Map::max_int_value,
- ",",
- "="));
+ std::make_unique<Patterns::Map>(Patterns::Anything(),
+ Patterns::Double(),
+ 0,
+ Patterns::Map::max_int_value,
+ ",",
+ "="));
initialize(variable_names,
expression,
constants_map,
void
ParameterHandler::clear()
{
- entries = std_cxx14::make_unique<boost::property_tree::ptree>();
+ entries = std::make_unique<boost::property_tree::ptree>();
entries_set_status.clear();
}
is.ignore(strlen(description_init) + strlen(" range "));
if (!(is >> lower_bound))
- return std_cxx14::make_unique<Integer>();
+ return std::make_unique<Integer>();
is.ignore(strlen("..."));
if (!(is >> upper_bound))
- return std_cxx14::make_unique<Integer>();
+ return std::make_unique<Integer>();
- return std_cxx14::make_unique<Integer>(lower_bound, upper_bound);
+ return std::make_unique<Integer>(lower_bound, upper_bound);
}
else
- return std_cxx14::make_unique<Integer>();
+ return std::make_unique<Integer>();
}
else
return std::unique_ptr<Integer>();
std::string temp = description.substr(description_init_str.size());
if (temp == "]")
- return std_cxx14::make_unique<Double>(1.0,
- -1.0); // return an invalid range
+ return std::make_unique<Double>(1.0,
+ -1.0); // return an invalid range
if (temp.find("...") != std::string::npos)
temp.replace(temp.find("..."), 3, " ");
if (is.fail())
upper_bound = max_double_value;
- return std_cxx14::make_unique<Double>(lower_bound, upper_bound);
+ return std::make_unique<Double>(lower_bound, upper_bound);
}
sequence.erase(0, std::strlen(description_init) + 1);
sequence.erase(sequence.length() - 2, 2);
- return std_cxx14::make_unique<Selection>(sequence);
+ return std::make_unique<Selection>(sequence);
}
else
return std::unique_ptr<Selection>();
is.ignore(strlen(" of length "));
if (!(is >> min_elements))
- return std_cxx14::make_unique<List>(*base_pattern);
+ return std::make_unique<List>(*base_pattern);
is.ignore(strlen("..."));
if (!(is >> max_elements))
- return std_cxx14::make_unique<List>(*base_pattern, min_elements);
+ return std::make_unique<List>(*base_pattern, min_elements);
is.ignore(strlen(" (inclusive) separated by <"));
std::string separator;
else
separator = ",";
- return std_cxx14::make_unique<List>(*base_pattern,
- min_elements,
- max_elements,
- separator);
+ return std::make_unique<List>(*base_pattern,
+ min_elements,
+ max_elements,
+ separator);
}
else
return std::unique_ptr<List>();
is.ignore(strlen(" of length "));
if (!(is >> min_elements))
- return std_cxx14::make_unique<Map>(*key_pattern, *value_pattern);
+ return std::make_unique<Map>(*key_pattern, *value_pattern);
is.ignore(strlen("..."));
if (!(is >> max_elements))
- return std_cxx14::make_unique<Map>(*key_pattern,
- *value_pattern,
- min_elements);
+ return std::make_unique<Map>(*key_pattern,
+ *value_pattern,
+ min_elements);
is.ignore(strlen(" (inclusive) separated by <"));
std::string separator;
else
separator = ",";
- return std_cxx14::make_unique<Map>(*key_pattern,
- *value_pattern,
- min_elements,
- max_elements,
- separator,
- key_value_separator);
+ return std::make_unique<Map>(*key_pattern,
+ *value_pattern,
+ min_elements,
+ max_elements,
+ separator,
+ key_value_separator);
}
else
return std::unique_ptr<Map>();
else
separator = ":";
- return std_cxx14::make_unique<Tuple>(patterns, separator);
+ return std::make_unique<Tuple>(patterns, separator);
}
else
return std::unique_ptr<Tuple>();
sequence.erase(0, std::strlen(description_init) + 1);
sequence.erase(sequence.length() - 2, 2);
- return std_cxx14::make_unique<MultipleSelection>(sequence);
+ return std::make_unique<MultipleSelection>(sequence);
}
else
return std::unique_ptr<MultipleSelection>();
if (description.compare(0,
std::strlen(description_init),
description_init) == 0)
- return std_cxx14::make_unique<Bool>();
+ return std::make_unique<Bool>();
else
return std::unique_ptr<Bool>();
}
if (description.compare(0,
std::strlen(description_init),
description_init) == 0)
- return std
_cxx14::make_unique<Anything>();
+ return std::make_unique<Anything>();
else
return std::unique_ptr<Anything>();
}
else
type = output;
- return std_cxx14::make_unique<FileName>(type);
+ return std::make_unique<FileName>(type);
}
else
return std::unique_ptr<FileName>();
if (description.compare(0,
std::strlen(description_init),
description_init) == 0)
- return std_cxx14::make_unique<DirectoryName>();
+ return std::make_unique<DirectoryName>();
else
return std::unique_ptr<DirectoryName>();
}
const Polynomial<number> * q = nullptr;
if (p.in_lagrange_product_form == true)
{
- q_data = std
_cxx14::make_unique<Polynomial<number>>(p);
+ q_data = std::make_unique<Polynomial<number>>(p);
q_data->transform_into_standard_form();
q = q_data.get();
}
const Polynomial<number> * q = nullptr;
if (p.in_lagrange_product_form == true)
{
- q_data = std
_cxx14::make_unique<Polynomial<number>>(p);
+ q_data = std::make_unique<Polynomial<number>>(p);
q_data->transform_into_standard_form();
q = q_data.get();
}
const Polynomial<number> * q = nullptr;
if (p.in_lagrange_product_form == true)
{
- q_data = std
_cxx14::make_unique<Polynomial<number>>(p);
+ q_data = std::make_unique<Polynomial<number>>(p);
q_data->transform_into_standard_form();
q = q_data.get();
}
const Polynomial<number> * q = nullptr;
if (in_lagrange_product_form == true)
{
- q_data = std
_cxx14::make_unique<Polynomial<number>>(*this);
+ q_data = std::make_unique<Polynomial<number>>(*this);
q_data->transform_into_standard_form();
q = q_data.get();
}
const Polynomial<number> * q = nullptr;
if (in_lagrange_product_form == true)
{
- q_data = std
_cxx14::make_unique<Polynomial<number>>(*this);
+ q_data = std::make_unique<Polynomial<number>>(*this);
q_data->transform_into_standard_form();
q = q_data.get();
}
// now make these arrays
// const
recursive_coefficients[0] =
- std_cxx14::make_unique<const std::vector<double>>(std::move(c0));
+ std::make_unique<const std::vector<double>>(std::move(c0));
recursive_coefficients[1] =
- std_cxx14::make_unique<const std::vector<double>>(std::move(c1));
+ std::make_unique<const std::vector<double>>(std::move(c1));
}
else if (k == 2)
{
c2[2] = 4. * a;
recursive_coefficients[2] =
- std_cxx14::make_unique<const std::vector<double>>(std::move(c2));
+ std::make_unique<const std::vector<double>>(std::move(c2));
}
else
{
// const pointer in the
// coefficients array
recursive_coefficients[k] =
- std_cxx14::make_unique<const std::vector<double>>(std::move(ck));
+ std::make_unique<const std::vector<double>>(std::move(ck));
}
}
}
std::unique_ptr<ScalarPolynomialsBase<dim>>
PolynomialSpace<dim>::clone() const
{
- return std
_cxx14::make_unique<PolynomialSpace<dim>>(*this);
+ return std::make_unique<PolynomialSpace<dim>>(*this);
}
std::unique_ptr<TensorPolynomialsBase<dim>>
PolynomialsABF<dim>::clone() const
{
- return std
_cxx14::make_unique<PolynomialsABF<dim>>(*this);
+ return std::make_unique<PolynomialsABF<dim>>(*this);
}
std::unique_ptr<ScalarPolynomialsBase<dim>>
PolynomialsAdini<dim>::clone() const
{
- return std
_cxx14::make_unique<PolynomialsAdini<dim>>(*this);
+ return std::make_unique<PolynomialsAdini<dim>>(*this);
}
std::unique_ptr<TensorPolynomialsBase<dim>>
PolynomialsBDM<dim>::clone() const
{
- return std
_cxx14::make_unique<PolynomialsBDM<dim>>(*this);
+ return std::make_unique<PolynomialsBDM<dim>>(*this);
}
std::unique_ptr<TensorPolynomialsBase<dim>>
PolynomialsBernardiRaugel<dim>::clone() const
{
- return std
_cxx14::make_unique<PolynomialsBernardiRaugel<dim>>(*this);
+ return std::make_unique<PolynomialsBernardiRaugel<dim>>(*this);
}
template class PolynomialsBernardiRaugel<1>; // to prevent errors
std::unique_ptr<TensorPolynomialsBase<dim>>
PolynomialsNedelec<dim>::clone() const
{
- return std
_cxx14::make_unique<PolynomialsNedelec<dim>>(*this);
+ return std::make_unique<PolynomialsNedelec<dim>>(*this);
}
std::unique_ptr<ScalarPolynomialsBase<dim>>
PolynomialsRannacherTurek<dim>::clone() const
{
- return std
_cxx14::make_unique<PolynomialsRannacherTurek<dim>>(*this);
+ return std::make_unique<PolynomialsRannacherTurek<dim>>(*this);
}
std::unique_ptr<TensorPolynomialsBase<dim>>
PolynomialsRaviartThomas<dim>::clone() const
{
- return std
_cxx14::make_unique<PolynomialsRaviartThomas<dim>>(*this);
+ return std::make_unique<PolynomialsRaviartThomas<dim>>(*this);
}
std::unique_ptr<TensorPolynomialsBase<dim>>
PolynomialsRT_Bubbles<dim>::clone() const
{
- return std
_cxx14::make_unique<PolynomialsRT_Bubbles<dim>>(*this);
+ return std::make_unique<PolynomialsRT_Bubbles<dim>>(*this);
}
if (is_tensor_product_flag)
{
- tensor_basis = std_cxx14::make_unique<std::array<Quadrature<1>, dim>>();
+ tensor_basis = std::make_unique<std::array<Quadrature<1>, dim>>();
for (unsigned int i = 0; i < dim - 1; ++i)
(*tensor_basis)[i] = q1.get_tensor_basis()[i];
(*tensor_basis)[dim - 1] = q2;
++k;
}
- tensor_basis = std_cxx14::make_unique<std::array<Quadrature<1>, dim>>();
+ tensor_basis = std::make_unique<std::array<Quadrature<1>, dim>>();
for (unsigned int i = 0; i < dim; ++i)
(*tensor_basis)[i] = q;
}
{
if (dim > 1 && is_tensor_product_flag)
tensor_basis =
- std_cxx14::make_unique<std::array<Quadrature<1>, dim>>(*q.tensor_basis);
+ std::make_unique<std::array<Quadrature<1>, dim>>(*q.tensor_basis);
}
if (dim > 1 && is_tensor_product_flag)
{
if (tensor_basis == nullptr)
- tensor_basis = std_cxx14::make_unique<std::array<Quadrature<1>, dim>>(
- *q.tensor_basis);
+ tensor_basis =
+ std::make_unique<std::array<Quadrature<1>, dim>>(*q.tensor_basis);
else
*tensor_basis = *q.tensor_basis;
}
Assert(k == this->size(), ExcInternalError());
this->is_tensor_product_flag = true;
const std::array<Quadrature<1>, 2> q_array{{qx, qy}};
- this->tensor_basis =
- std_cxx14::make_unique<std::array<Quadrature<1>, 2>>(q_array);
+ this->tensor_basis = std::make_unique<std::array<Quadrature<1>, 2>>(q_array);
}
Assert(k == this->size(), ExcInternalError());
this->is_tensor_product_flag = true;
const std::array<Quadrature<1>, 3> q_array{{qx, qy, qz}};
- this->tensor_basis =
- std_cxx14::make_unique<std::array<Quadrature<1>, 3>>(q_array);
+ this->tensor_basis = std::make_unique<std::array<Quadrature<1>, 3>>(q_array);
}
{
auto constants_map = Patterns::Tools::Convert<ConstMap>::to_value(
constants,
- std
_cxx14::make_unique<Patterns::Map>(Patterns::Anything(),
- Patterns::Double(),
- 0,
- Patterns::Map::max_int_value,
- ",",
- "="));
+ std::make_unique<Patterns::Map>(Patterns::Anything(),
+ Patterns::Double(),
+ 0,
+ Patterns::Map::max_int_value,
+ ",",
+ "="));
initialize(variable_names,
expression,
constants_map,
std::unique_ptr<ScalarPolynomialsBase<dim>>
TensorProductPolynomials<dim, PolynomialType>::clone() const
{
- return std_cxx14::make_unique<TensorProductPolynomials<dim, PolynomialType>>(
- *this);
+ return std::make_unique<TensorProductPolynomials<dim, PolynomialType>>(*this);
}
std::unique_ptr<ScalarPolynomialsBase<dim>>
AnisotropicPolynomials<dim>::clone() const
{
- return std
_cxx14::make_unique<AnisotropicPolynomials<dim>>(*this);
+ return std::make_unique<AnisotropicPolynomials<dim>>(*this);
}
std::unique_ptr<ScalarPolynomialsBase<dim>>
TensorProductPolynomialsBubbles<dim>::clone() const
{
- return std_cxx14::make_unique<TensorProductPolynomialsBubbles<dim>>(*this);
+ return std::make_unique<TensorProductPolynomialsBubbles<dim>>(*this);
}
std::unique_ptr<ScalarPolynomialsBase<dim>>
TensorProductPolynomialsConst<dim>::clone() const
{
- return std_cxx14::make_unique<TensorProductPolynomialsConst<dim>>(*this);
+ return std::make_unique<TensorProductPolynomialsConst<dim>>(*this);
}
*>(&other_tria) == nullptr)
{
serial_tria =
- std_cxx14::make_unique<dealii::Triangulation<dim, spacedim>>();
+ std::make_unique<dealii::Triangulation<dim, spacedim>>();
// actually copy the serial triangulation
serial_tria->copy_triangulation(other_tria);
numbers::invalid_dof_index);
}
- dof_handler.faces = std_cxx14::make_unique<
- internal::DoFHandlerImplementation::DoFFaces<2>>();
+ dof_handler.faces =
+ std::make_unique<internal::DoFHandlerImplementation::DoFFaces<2>>();
// avoid access to n_raw_lines when there are no cells
if (dof_handler.tria->n_cells() > 0)
{
dof_handler.get_fe().dofs_per_cell,
numbers::invalid_dof_index);
}
- dof_handler.faces = std_cxx14::make_unique<
- internal::DoFHandlerImplementation::DoFFaces<3>>();
+ dof_handler.faces =
+ std::make_unique<internal::DoFHandlerImplementation::DoFFaces<3>>();
// avoid access to n_raw_lines when there are no cells
if (dof_handler.tria->n_cells() > 0)
for (unsigned int i = 0; i < n_levels; ++i)
{
dof_handler.mg_levels.emplace_back(
- std_cxx14::make_unique<
+ std::make_unique<
internal::DoFHandlerImplementation::DoFLevel<2>>());
dof_handler.mg_levels.back()->dof_object.dofs =
std::vector<types::global_dof_index>(tria.n_raw_quads(i) *
numbers::invalid_dof_index);
}
- dof_handler.mg_faces = std_cxx14::make_unique<
- internal::DoFHandlerImplementation::DoFFaces<2>>();
+ dof_handler.mg_faces =
+ std::make_unique<internal::DoFHandlerImplementation::DoFFaces<2>>();
dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index>(
tria.n_raw_lines() * fe.dofs_per_line, numbers::invalid_dof_index);
for (unsigned int i = 0; i < n_levels; ++i)
{
dof_handler.mg_levels.emplace_back(
- std_cxx14::make_unique<
+ std::make_unique<
internal::DoFHandlerImplementation::DoFLevel<3>>());
dof_handler.mg_levels.back()->dof_object.dofs =
std::vector<types::global_dof_index>(tria.n_raw_hexs(i) *
numbers::invalid_dof_index);
}
- dof_handler.mg_faces = std_cxx14::make_unique<
- internal::DoFHandlerImplementation::DoFFaces<3>>();
+ dof_handler.mg_faces =
+ std::make_unique<internal::DoFHandlerImplementation::DoFFaces<3>>();
dof_handler.mg_faces->lines.dofs = std::vector<types::global_dof_index>(
tria.n_raw_lines() * fe.dofs_per_line, numbers::invalid_dof_index);
dof_handler.mg_faces->quads.dofs = std::vector<types::global_dof_index>(
if (dynamic_cast<const parallel::shared::Triangulation<dim, spacedim> *>(
&tria) != nullptr)
policy =
- std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
- ParallelShared<DoFHandler<dim, spacedim>>>(
- *this);
+ std::make_unique<internal::DoFHandlerImplementation::Policy::
+ ParallelShared<DoFHandler<dim, spacedim>>>(*this);
else if (dynamic_cast<
const parallel::DistributedTriangulationBase<dim, spacedim> *>(
&tria) == nullptr)
policy =
- std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
- Sequential<DoFHandler<dim, spacedim>>>(*this);
+ std::make_unique<internal::DoFHandlerImplementation::Policy::Sequential<
+ DoFHandler<dim, spacedim>>>(*this);
else
policy =
- std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
- ParallelDistributed<DoFHandler<dim, spacedim>>>(
- *this);
+ std::make_unique<internal::DoFHandlerImplementation::Policy::
+ ParallelDistributed<DoFHandler<dim, spacedim>>>(*this);
}
if (dynamic_cast<const parallel::shared::Triangulation<dim, spacedim> *>(
&t) != nullptr)
policy =
- std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
- ParallelShared<DoFHandler<dim, spacedim>>>(
- *this);
+ std::make_unique<internal::DoFHandlerImplementation::Policy::
+ ParallelShared<DoFHandler<dim, spacedim>>>(*this);
else if (dynamic_cast<
const parallel::DistributedTriangulationBase<dim, spacedim> *>(
&t) != nullptr)
policy =
- std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
- ParallelDistributed<DoFHandler<dim, spacedim>>>(
- *this);
+ std::make_unique<internal::DoFHandlerImplementation::Policy::
+ ParallelDistributed<DoFHandler<dim, spacedim>>>(*this);
else
policy =
- std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
- Sequential<DoFHandler<dim, spacedim>>>(*this);
+ std::make_unique<internal::DoFHandlerImplementation::Policy::Sequential<
+ DoFHandler<dim, spacedim>>>(*this);
distribute_dofs(fe);
}
const unsigned int n_levels = finest_level - coarsest_level + 1;
const unsigned int n_indices = n_levels * dofs_per_vertex;
- indices = std_cxx14::make_unique<types::global_dof_index[]>(n_indices);
+ indices = std::make_unique<types::global_dof_index[]>(n_indices);
std::fill(indices.get(),
indices.get() + n_indices,
numbers::invalid_dof_index);
{
case 0:
{
- identities = std_cxx14::make_unique<DoFIdentities>(
+ identities = std::make_unique<DoFIdentities>(
fe1.hp_vertex_dof_identities(fe2));
break;
}
case 1:
{
- identities = std_cxx14::make_unique<DoFIdentities>(
+ identities = std::make_unique<DoFIdentities>(
fe1.hp_line_dof_identities(fe2));
break;
}
case 2:
{
- identities = std_cxx14::make_unique<DoFIdentities>(
+ identities = std::make_unique<DoFIdentities>(
fe1.hp_quad_dof_identities(fe2));
break;
}
if (master_dof_mask == nullptr)
{
master_dof_mask =
- std_cxx14::make_unique<std::vector<bool>>(fe1.dofs_per_face);
+ std::make_unique<std::vector<bool>>(fe1.dofs_per_face);
select_master_dofs_for_face_restriction(fe1,
fe2,
face_interpolation_matrix,
{
if (matrix == nullptr)
{
- matrix =
- std_cxx14::make_unique<FullMatrix<double>>(fe2.dofs_per_face,
- fe1.dofs_per_face);
+ matrix = std::make_unique<FullMatrix<double>>(fe2.dofs_per_face,
+ fe1.dofs_per_face);
fe1.get_face_interpolation_matrix(fe2, *matrix);
}
}
{
if (matrix == nullptr)
{
- matrix =
- std_cxx14::make_unique<FullMatrix<double>>(fe2.dofs_per_face,
- fe1.dofs_per_face);
+ matrix = std::make_unique<FullMatrix<double>>(fe2.dofs_per_face,
+ fe1.dofs_per_face);
fe1.get_subface_interpolation_matrix(fe2, subface, *matrix);
}
}
if (split_matrix == nullptr)
{
- split_matrix = std_cxx14::make_unique<
+ split_matrix = std::make_unique<
std::pair<FullMatrix<double>, FullMatrix<double>>>();
const unsigned int n_master_dofs = face_interpolation_matrix.n();
std::unique_ptr<FiniteElement<dim, dim>>
FE_ABF<dim>::clone() const
{
- return std_cxx14::make_unique<FE_ABF<dim>>(rt_order);
+ return std::make_unique<FE_ABF<dim>>(rt_order);
}
std::unique_ptr<FiniteElement<dim, dim>>
FE_BDM<dim>::clone() const
{
- return std_cxx14::make_unique<FE_BDM<dim>>(*this);
+ return std::make_unique<FE_BDM<dim>>(*this);
}
std::unique_ptr<FiniteElement<dim, dim>>
FE_BernardiRaugel<dim>::clone() const
{
- return std_cxx14::make_unique<FE_BernardiRaugel<dim>>(*this);
+ return std::make_unique<FE_BernardiRaugel<dim>>(*this);
}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_Bernstein<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_Bernstein<dim, spacedim>>(*this);
+ return std::make_unique<FE_Bernstein<dim, spacedim>>(*this);
}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_DGP<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_DGP<dim, spacedim>>(*this);
+ return std::make_unique<FE_DGP<dim, spacedim>>(*this);
}
std::unique_ptr<FiniteElement<dim, dim>>
FE_DGPMonomial<dim>::clone() const
{
- return std_cxx14::make_unique<FE_DGPMonomial<dim>>(*this);
+ return std::make_unique<FE_DGPMonomial<dim>>(*this);
}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_DGPNonparametric<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_DGPNonparametric<dim, spacedim>>(*this);
+ return std::make_unique<FE_DGPNonparametric<dim, spacedim>>(*this);
}
& /*output_data*/) const
{
// generate a new data object
- auto data_ptr = std_cxx14::make_unique<
- typename FiniteElement<dim, spacedim>::InternalDataBase>();
+ auto data_ptr =
+ std::make_unique<typename FiniteElement<dim, spacedim>::InternalDataBase>();
data_ptr->update_each = requires_update_flags(update_flags);
// other than that, there is nothing we can add here as discussed
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_DGQ<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_DGQ<dim, spacedim>>(*this);
+ return std::make_unique<FE_DGQ<dim, spacedim>>(*this);
}
qpoints[i] = Point<1>(this->unit_support_points[lexicographic[i]][0]);
Quadrature<1> pquadrature(qpoints);
- return std_cxx14::make_unique<FE_DGQArbitraryNodes<dim, spacedim>>(
- pquadrature);
+ return std::make_unique<FE_DGQArbitraryNodes<dim, spacedim>>(pquadrature);
}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_DGQLegendre<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_DGQLegendre<dim, spacedim>>(this->degree);
+ return std::make_unique<FE_DGQLegendre<dim, spacedim>>(this->degree);
}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_DGQHermite<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_DGQHermite<dim, spacedim>>(this->degree);
+ return std::make_unique<FE_DGQHermite<dim, spacedim>>(this->degree);
}
false))
, enrichments(functions)
, is_enriched(internal::FE_Enriched::check_if_enriched(fes))
- , fe_system(
- std_cxx14::make_unique<FESystem<dim, spacedim>>(fes, multiplicities))
+ , fe_system(std::make_unique<FESystem<dim, spacedim>>(fes, multiplicities))
{
// descriptive error are thrown within the function.
Assert(internal::FE_Enriched::consistency_check(fes,
// that fes_data points to, to the new InternalData object.
auto update_each_flags = fes_data->update_each;
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
- data_ptr = std_cxx14::make_unique<InternalData>(std::move(fes_data));
+ data_ptr = std::make_unique<InternalData>(std::move(fes_data));
auto &data = dynamic_cast<InternalData &>(*data_ptr);
// copy update_each from FESystem data:
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_FaceQ<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_FaceQ<dim, spacedim>>(this->degree);
+ return std::make_unique<FE_FaceQ<dim, spacedim>>(this->degree);
}
std::unique_ptr<FiniteElement<1, spacedim>>
FE_FaceQ<1, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_FaceQ<1, spacedim>>(this->degree);
+ return std::make_unique<FE_FaceQ<1, spacedim>>(this->degree);
}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_FaceP<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_FaceP<dim, spacedim>>(this->degree);
+ return std::make_unique<FE_FaceP<dim, spacedim>>(this->degree);
}
std::unique_ptr<FiniteElement<dim, dim>>
FE_Nedelec<dim>::clone() const
{
- return std_cxx14::make_unique<FE_Nedelec<dim>>(*this);
+ return std::make_unique<FE_Nedelec<dim>>(*this);
}
//---------------------------------------------------------------------------
{
std::unique_ptr<
typename dealii::FiniteElement<dim, spacedim>::InternalDataBase>
- data_ptr = std_cxx14::make_unique<InternalData>();
+ data_ptr = std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.update_each = requires_update_flags(update_flags);
std::unique_ptr<FiniteElement<dim, dim>>
FE_NedelecSZ<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_NedelecSZ<dim, spacedim>>(*this);
+ return std::make_unique<FE_NedelecSZ<dim, spacedim>>(*this);
}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_Nothing<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_Nothing<dim, spacedim>>(*this);
+ return std::make_unique<FE_Nothing<dim, spacedim>>(*this);
}
// Create a default data object. Normally we would then
// need to resize things to hold the appropriate numbers
// of dofs, but in this case all data fields are empty.
- return std_cxx14::make_unique<
+ return std::make_unique<
typename FiniteElement<dim, spacedim>::InternalDataBase>();
}
std::unique_ptr<FiniteElement<2, 2>>
FE_P1NC::clone() const
{
- return std_cxx14::make_unique<FE_P1NC>(*this);
+ return std::make_unique<FE_P1NC>(*this);
}
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2, 2>
&output_data) const
{
- auto data_ptr =
- std_cxx14::make_unique<FiniteElement<2, 2>::InternalDataBase>();
+ auto data_ptr = std::make_unique<FiniteElement<2, 2>::InternalDataBase>();
data_ptr->update_each = requires_update_flags(update_flags);
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2, 2>
&output_data) const
{
- auto data_ptr =
- std_cxx14::make_unique<FiniteElement<2, 2>::InternalDataBase>();
+ auto data_ptr = std::make_unique<FiniteElement<2, 2>::InternalDataBase>();
data_ptr->update_each = requires_update_flags(update_flags);
dealii::internal::FEValuesImplementation::FiniteElementRelatedData<2, 2>
&output_data) const
{
- auto data_ptr =
- std_cxx14::make_unique<FiniteElement<2, 2>::InternalDataBase>();
+ auto data_ptr = std::make_unique<FiniteElement<2, 2>::InternalDataBase>();
data_ptr->update_each = requires_update_flags(update_flags);
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_Q<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_Q<dim, spacedim>>(*this);
+ return std::make_unique<FE_Q<dim, spacedim>>(*this);
}
{
case 1:
if (spacedim == 1)
- q_fine = std_cxx14::make_unique<QGauss<dim>>(degree + 1);
+ q_fine = std::make_unique<QGauss<dim>>(degree + 1);
else if (spacedim == 2)
- q_fine = std_cxx14::make_unique<QAnisotropic<dim>>(
- QGauss<1>(degree + 1), q_dummy);
+ q_fine =
+ std::make_unique<QAnisotropic<dim>>(QGauss<1>(degree + 1),
+ q_dummy);
else
- q_fine = std_cxx14::make_unique<QAnisotropic<dim>>(
- QGauss<1>(degree + 1), q_dummy, q_dummy);
+ q_fine =
+ std::make_unique<QAnisotropic<dim>>(QGauss<1>(degree + 1),
+ q_dummy,
+ q_dummy);
break;
case 2:
if (spacedim == 2)
- q_fine = std_cxx14::make_unique<QGauss<dim>>(degree + 1);
+ q_fine = std::make_unique<QGauss<dim>>(degree + 1);
else
- q_fine = std_cxx14::make_unique<QAnisotropic<dim>>(
- QGauss<1>(degree + 1), QGauss<1>(degree + 1), q_dummy);
+ q_fine =
+ std::make_unique<QAnisotropic<dim>>(QGauss<1>(degree + 1),
+ QGauss<1>(degree + 1),
+ q_dummy);
break;
case 3:
- q_fine = std_cxx14::make_unique<QGauss<dim>>(degree + 1);
+ q_fine = std::make_unique<QGauss<dim>>(degree + 1);
break;
default:
Assert(false, ExcInternalError());
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_Q_Bubbles<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_Q_Bubbles<dim, spacedim>>(*this);
+ return std::make_unique<FE_Q_Bubbles<dim, spacedim>>(*this);
}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_Q_DG0<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_Q_DG0<dim, spacedim>>(*this);
+ return std::make_unique<FE_Q_DG0<dim, spacedim>>(*this);
}
std::unique_ptr<FiniteElement<dim, dim>>
FE_Q_Hierarchical<dim>::clone() const
{
- return std_cxx14::make_unique<FE_Q_Hierarchical<dim>>(*this);
+ return std::make_unique<FE_Q_Hierarchical<dim>>(*this);
}
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_Q_iso_Q1<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_Q_iso_Q1<dim, spacedim>>(*this);
+ return std::make_unique<FE_Q_iso_Q1<dim, spacedim>>(*this);
}
std::unique_ptr<FiniteElement<dim, dim>>
FE_RannacherTurek<dim>::clone() const
{
- return std_cxx14::make_unique<FE_RannacherTurek<dim>>(
- this->order, this->n_face_support_points);
+ return std::make_unique<FE_RannacherTurek<dim>>(this->order,
+ this->n_face_support_points);
}
std::unique_ptr<FiniteElement<dim, dim>>
FE_RaviartThomas<dim>::clone() const
{
- return std_cxx14::make_unique<FE_RaviartThomas<dim>>(*this);
+ return std::make_unique<FE_RaviartThomas<dim>>(*this);
}
poly[d] = Polynomials::Legendre::generate_complete_basis(deg);
poly[dd] = Polynomials::Legendre::generate_complete_basis(deg - 1);
- polynomials[dd] =
- std_cxx14::make_unique<AnisotropicPolynomials<dim>>(poly);
+ polynomials[dd] = std::make_unique<AnisotropicPolynomials<dim>>(poly);
}
interior_weights.reinit(
poly[dd] =
Polynomials::Legendre::generate_complete_basis(this->degree - 2);
- polynomials[dd] =
- std_cxx14::make_unique<AnisotropicPolynomials<dim>>(poly);
+ polynomials[dd] = std::make_unique<AnisotropicPolynomials<dim>>(poly);
}
QGauss<dim> q_cell(this->degree);
std::unique_ptr<FiniteElement<dim, dim>>
FE_RaviartThomasNodal<dim>::clone() const
{
- return std_cxx14::make_unique<FE_RaviartThomasNodal<dim>>(*this);
+ return std::make_unique<FE_RaviartThomasNodal<dim>>(*this);
}
switch (dim)
{
case 1:
- quadrature = std_cxx14::make_unique<QAnisotropic<dim>>(high);
+ quadrature = std::make_unique<QAnisotropic<dim>>(high);
break;
case 2:
- quadrature = std_cxx14::make_unique<QAnisotropic<dim>>(
- ((d == 0) ? low : high), ((d == 1) ? low : high));
+ quadrature =
+ std::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
+ ((d == 1) ? low : high));
break;
case 3:
quadrature =
- std_cxx14::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
- ((d == 1) ? low : high),
- ((d == 2) ? low :
- high));
+ std::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
+ ((d == 1) ? low : high),
+ ((d == 2) ? low : high));
break;
default:
Assert(false, ExcNotImplemented());
std::unique_ptr<FiniteElement<dim, dim>>
FE_RT_Bubbles<dim>::clone() const
{
- return std_cxx14::make_unique<FE_RT_Bubbles<dim>>(*this);
+ return std::make_unique<FE_RT_Bubbles<dim>>(*this);
}
switch (dim)
{
case 1:
- quadrature = std_cxx14::make_unique<QAnisotropic<dim>>(high);
+ quadrature = std::make_unique<QAnisotropic<dim>>(high);
break;
case 2:
- quadrature = std_cxx14::make_unique<QAnisotropic<dim>>(
- ((d == 0) ? low : high), ((d == 1) ? low : high));
+ quadrature =
+ std::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
+ ((d == 1) ? low : high));
break;
case 3:
quadrature =
- std_cxx14::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
- ((d == 1) ? low : high),
- ((d == 2) ? low :
- high));
+ std::make_unique<QAnisotropic<dim>>(((d == 0) ? low : high),
+ ((d == 1) ? low : high),
+ ((d == 2) ? low : high));
break;
default:
Assert(false, ExcNotImplemented());
fes.push_back(&base_element(i));
multiplicities.push_back(this->element_multiplicity(i));
}
- return std_cxx14::make_unique<FESystem<dim, spacedim>>(fes, multiplicities);
+ return std::make_unique<FESystem<dim, spacedim>>(fes, multiplicities);
}
// correct in case the current FESystem is a base element for another,
// higher-level FESystem itself.
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
- data_ptr = std_cxx14::make_unique<InternalData>(this->n_base_elements());
- auto &data = dynamic_cast<InternalData &>(*data_ptr);
+ data_ptr = std::make_unique<InternalData>(this->n_base_elements());
+ auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.update_each = requires_update_flags(flags);
// get data objects from each of the base elements and store
// correct in case the current FESystem is a base element for another,
// higher-level FESystem itself.
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
- data_ptr = std_cxx14::make_unique<InternalData>(this->n_base_elements());
- auto &data = dynamic_cast<InternalData &>(*data_ptr);
+ data_ptr = std::make_unique<InternalData>(this->n_base_elements());
+ auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.update_each = requires_update_flags(flags);
// get data objects from each of the base elements and store
// correct in case the current FESystem is a base element for another,
// higher-level FESystem itself.
std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>
- data_ptr = std_cxx14::make_unique<InternalData>(this->n_base_elements());
+ data_ptr = std::make_unique<InternalData>(this->n_base_elements());
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.update_each = requires_update_flags(flags);
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_TraceQ<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FE_TraceQ<dim, spacedim>>(this->degree);
+ return std::make_unique<FE_TraceQ<dim, spacedim>>(this->degree);
}
if (flags & update_mapping)
this->mapping_data = std::move(mapping_get_data.return_value());
else
- this->mapping_data = std_cxx14::make_unique<
- typename Mapping<dim, spacedim>::InternalDataBase>();
+ this->mapping_data =
+ std::make_unique<typename Mapping<dim, spacedim>::InternalDataBase>();
}
}
else
// if the types don't match, there is nothing we can do here
- present_cell = std_cxx14::make_unique<Type>(new_cell);
+ present_cell = std::make_unique<Type>(new_cell);
}
} // namespace
if (flags & update_mapping)
this->mapping_data = std::move(mapping_get_data.return_value());
else
- this->mapping_data = std_cxx14::make_unique<
- typename Mapping<dim, spacedim>::InternalDataBase>();
+ this->mapping_data =
+ std::make_unique<typename Mapping<dim, spacedim>::InternalDataBase>();
}
if (flags & update_mapping)
this->mapping_data = std::move(mapping_get_data.return_value());
else
- this->mapping_data = std_cxx14::make_unique<
- typename Mapping<dim, spacedim>::InternalDataBase>();
+ this->mapping_data =
+ std::make_unique<typename Mapping<dim, spacedim>::InternalDataBase>();
}
std::unique_ptr<Mapping<dim, spacedim>>
MappingC1<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<MappingC1<dim, spacedim>>();
+ return std::make_unique<MappingC1<dim, spacedim>>();
}
const Quadrature<dim> &q) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>(q);
+ std::make_unique<InternalData>(q);
auto &data = dynamic_cast<InternalData &>(*data_ptr);
// store the flags in the internal data object so we can access them
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>(
+ std::make_unique<InternalData>(
QProjector<dim>::project_to_all_faces(quadrature));
auto &data = dynamic_cast<InternalData &>(*data_ptr);
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>(
+ std::make_unique<InternalData>(
QProjector<dim>::project_to_all_subfaces(quadrature));
auto &data = dynamic_cast<InternalData &>(*data_ptr);
std::unique_ptr<Mapping<dim, spacedim>>
MappingCartesian<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<MappingCartesian<dim, spacedim>>(*this);
+ return std::make_unique<MappingCartesian<dim, spacedim>>(*this);
}
const Quadrature<dim> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
+ std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
auto &data = dynamic_cast<InternalData &>(*data_ptr);
this->compute_data(update_flags, quadrature, quadrature.size(), data);
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
+ std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
auto & data = dynamic_cast<InternalData &>(*data_ptr);
const Quadrature<dim> q(QProjector<dim>::project_to_all_faces(quadrature));
this->compute_face_data(update_flags, q, quadrature.size(), data);
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
+ std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
auto & data = dynamic_cast<InternalData &>(*data_ptr);
const Quadrature<dim> q(QProjector<dim>::project_to_all_subfaces(quadrature));
this->compute_face_data(update_flags, q, quadrature.size(), data);
std::unique_ptr<Mapping<dim, spacedim>>
MappingFEField<dim, spacedim, VectorType, DoFHandlerType>::clone() const
{
- return std_cxx14::make_unique<
+ return std::make_unique<
MappingFEField<dim, spacedim, VectorType, DoFHandlerType>>(*this);
}
std::unique_ptr<Mapping<dim, spacedim>>
MappingManifold<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<MappingManifold<dim, spacedim>>(*this);
+ return std::make_unique<MappingManifold<dim, spacedim>>(*this);
}
const Quadrature<dim> &q) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>();
+ std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize(this->requires_update_flags(update_flags), q, q.size());
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>();
+ std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize_face(this->requires_update_flags(update_flags),
QProjector<dim>::project_to_all_faces(quadrature),
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>();
+ std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize_face(this->requires_update_flags(update_flags),
QProjector<dim>::project_to_all_subfaces(quadrature),
const Quadrature<dim> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>();
+ std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
// build the Q1 and Qp internal data objects in parallel
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>();
+ std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
// build the Q1 and Qp internal data objects in parallel
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>();
+ std::make_unique<InternalData>();
auto &data = dynamic_cast<InternalData &>(*data_ptr);
// build the Q1 and Qp internal data objects in parallel
std::unique_ptr<Mapping<dim, spacedim>>
MappingQ<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<MappingQ<dim, spacedim>>(
+ return std::make_unique<MappingQ<dim, spacedim>>(
this->polynomial_degree, this->use_mapping_q_on_all_cells);
}
std::unique_ptr<Mapping<dim, spacedim>>
MappingQ1<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<MappingQ1<dim, spacedim>>(*this);
+ return std::make_unique<MappingQ1<dim, spacedim>>(*this);
}
//---------------------------------------------------------------------------
std::unique_ptr<Mapping<dim, spacedim>>
MappingQ1Eulerian<dim, VectorType, spacedim>::clone() const
{
- return std_cxx14::make_unique<MappingQ1Eulerian<dim, VectorType, spacedim>>(
- *this);
+ return std::make_unique<MappingQ1Eulerian<dim, VectorType, spacedim>>(*this);
}
std::unique_ptr<Mapping<dim, spacedim>>
MappingQCache<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<MappingQCache<dim, spacedim>>(*this);
+ return std::make_unique<MappingQCache<dim, spacedim>>(*this);
}
std::unique_ptr<Mapping<dim, spacedim>>
MappingQEulerian<dim, VectorType, spacedim>::clone() const
{
- return std_cxx14::make_unique<MappingQEulerian<dim, VectorType, spacedim>>(
+ return std::make_unique<MappingQEulerian<dim, VectorType, spacedim>>(
this->get_degree(), *euler_dof_handler, *euler_vector);
}
std::unique_ptr<Mapping<dim, spacedim>>
MappingQGeneric<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<MappingQGeneric<dim, spacedim>>(*this);
+ return std::make_unique<MappingQGeneric<dim, spacedim>>(*this);
}
const Quadrature<dim> &q) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>(polynomial_degree);
+ std::make_unique<InternalData>(polynomial_degree);
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize(this->requires_update_flags(update_flags), q, q.size());
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>(polynomial_degree);
+ std::make_unique<InternalData>(polynomial_degree);
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize_face(this->requires_update_flags(update_flags),
QProjector<dim>::project_to_all_faces(quadrature),
const Quadrature<dim - 1> &quadrature) const
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std_cxx14::make_unique<InternalData>(polynomial_degree);
+ std::make_unique<InternalData>(polynomial_degree);
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize_face(this->requires_update_flags(update_flags),
QProjector<dim>::project_to_all_subfaces(quadrature),
std::unique_ptr<Manifold<dim, spacedim>>
FlatManifold<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<FlatManifold<dim, spacedim>>(periodicity,
- tolerance);
+ return std::make_unique<FlatManifold<dim, spacedim>>(periodicity, tolerance);
}
std::unique_ptr<Manifold<dim, spacedim>>
PolarManifold<dim, spacedim>::clone() const
{
- return std
_cxx14::make_unique<PolarManifold<dim, spacedim>>(center);
+ return std::make_unique<PolarManifold<dim, spacedim>>(center);
}
std::unique_ptr<Manifold<dim, spacedim>>
SphericalManifold<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<SphericalManifold<dim, spacedim>>(center);
+ return std::make_unique<SphericalManifold<dim, spacedim>>(center);
}
std::unique_ptr<Manifold<dim, spacedim>>
CylindricalManifold<dim, spacedim>::clone() const
{
- return std_cxx14::make_unique<CylindricalManifold<dim, spacedim>>(
- direction, point_on_axis, tolerance);
+ return std::make_unique<CylindricalManifold<dim, spacedim>>(direction,
+ point_on_axis,
+ tolerance);
}
EllipticalManifold<dim, spacedim>::clone() const
{
const double eccentricity = 1.0 / cosh_u;
- return std_cxx14::make_unique<EllipticalManifold<dim, spacedim>>(
- center, direction, eccentricity);
+ return std::make_unique<EllipticalManifold<dim, spacedim>>(center,
+ direction,
+ eccentricity);
}
// used to construct this class.
if (!(push_forward_expression.empty() && pull_back_expression.empty()))
{
- return std_cxx14::make_unique<FunctionManifold<dim, spacedim, chartdim>>(
+ return std::make_unique<FunctionManifold<dim, spacedim, chartdim>>(
push_forward_expression,
pull_back_expression,
this->get_periodicity(),
}
else
{
- return std_cxx14::make_unique<FunctionManifold<dim, spacedim, chartdim>>(
+ return std::make_unique<FunctionManifold<dim, spacedim, chartdim>>(
*push_forward_function,
*pull_back_function,
this->get_periodicity(),
std::unique_ptr<Manifold<dim, 3>>
TorusManifold<dim>::clone() const
{
- return std_cxx14::make_unique<TorusManifold<dim>>(R, r);
+ return std::make_unique<TorusManifold<dim>>(R, r);
}
// reserve enough space
triangulation.levels.push_back(
- std_cxx14::make_unique<
+ std::make_unique<
internal::TriangulationImplementation::TriaLevel<dim>>());
triangulation.levels[0]->reserve_space(cells.size(), dim, spacedim);
triangulation.levels[0]->cells.reserve_space(0, cells.size());
// reserve enough space
triangulation.levels.push_back(
- std_cxx14::make_unique<
+ std::make_unique<
internal::TriangulationImplementation::TriaLevel<dim>>());
- triangulation.faces = std_cxx14::make_unique<
+ triangulation.faces = std::make_unique<
internal::TriangulationImplementation::TriaFaces<dim>>();
triangulation.levels[0]->reserve_space(cells.size(), dim, spacedim);
triangulation.faces->lines.reserve_space(0, needed_lines.size());
// for the lines
// reserve enough space
triangulation.levels.push_back(
- std_cxx14::make_unique<
+ std::make_unique<
internal::TriangulationImplementation::TriaLevel<dim>>());
- triangulation.faces = std_cxx14::make_unique<
+ triangulation.faces = std::make_unique<
internal::TriangulationImplementation::TriaFaces<dim>>();
triangulation.levels[0]->reserve_space(cells.size(), dim, spacedim);
triangulation.faces->lines.reserve_space(0, needed_lines.size());
if (cell->refine_flag_set())
{
triangulation.levels.push_back(
- std_cxx14::make_unique<
+ std::make_unique<
internal::TriangulationImplementation::TriaLevel<dim>>());
break;
}
if (cell->refine_flag_set())
{
triangulation.levels.push_back(
- std_cxx14::make_unique<
+ std::make_unique<
internal::TriangulationImplementation::TriaLevel<dim>>());
break;
}
if (cell->refine_flag_set())
{
triangulation.levels.push_back(
- std_cxx14::make_unique<
+ std::make_unique<
internal::TriangulationImplementation::TriaLevel<dim>>());
break;
}
if (dim == 1)
{
vertex_to_boundary_id_map_1d =
- std_cxx14::make_unique<std::map<unsigned int, types::boundary_id>>();
+ std::make_unique<std::map<unsigned int, types::boundary_id>>();
vertex_to_manifold_id_map_1d =
- std_cxx14::make_unique<std::map<unsigned int, types::manifold_id>>();
+ std::make_unique<std::map<unsigned int, types::manifold_id>>();
}
// connect the any_change signal to the other top level signals
smooth_grid = other_tria.smooth_grid;
if (dim > 1)
- faces = std_cxx14::make_unique<
- internal::TriangulationImplementation::TriaFaces<dim>>(*other_tria.faces);
+ faces =
+ std::make_unique<internal::TriangulationImplementation::TriaFaces<dim>>(
+ *other_tria.faces);
auto bdry_iterator = other_tria.manifold.begin();
for (; bdry_iterator != other_tria.manifold.end(); ++bdry_iterator)
levels.reserve(other_tria.levels.size());
for (unsigned int level = 0; level < other_tria.levels.size(); ++level)
- levels.push_back(std_cxx14::make_unique<
- internal::TriangulationImplementation::TriaLevel<dim>>(
- *other_tria.levels[level]));
+ levels.push_back(
+ std::make_unique<internal::TriangulationImplementation::TriaLevel<dim>>(
+ *other_tria.levels[level]));
number_cache = other_tria.number_cache;
if (dim == 1)
{
vertex_to_boundary_id_map_1d =
- std_cxx14::make_unique<std::map<unsigned int, types::boundary_id>>(
+ std::make_unique<std::map<unsigned int, types::boundary_id>>(
*other_tria.vertex_to_boundary_id_map_1d);
vertex_to_manifold_id_map_1d =
- std_cxx14::make_unique<std::map<unsigned int, types::manifold_id>>(
+ std::make_unique<std::map<unsigned int, types::manifold_id>>(
*other_tria.vertex_to_manifold_id_map_1d);
}
if (dim > 1)
dof_handler.faces =
- std_cxx14::make_unique<internal::hp::DoFIndicesOnFaces<dim>>();
+ std::make_unique<internal::hp::DoFIndicesOnFaces<dim>>();
}
}
if (dynamic_cast<const parallel::DistributedTriangulationBase<dim, spacedim>
*>(&this->get_triangulation()))
{
- policy = std_cxx14::make_unique<
- internal::DoFHandlerImplementation::Policy::ParallelDistributed<
- DoFHandler<dim, spacedim>>>(*this);
+ policy =
+ std::make_unique<internal::DoFHandlerImplementation::Policy::
+ ParallelDistributed<DoFHandler<dim, spacedim>>>(
+ *this);
// repartitioning signals
tria_listeners.push_back(
*>(&this->get_triangulation()) != nullptr)
{
policy =
- std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
- ParallelShared<DoFHandler<dim, spacedim>>>(
- *this);
+ std::make_unique<internal::DoFHandlerImplementation::Policy::
+ ParallelShared<DoFHandler<dim, spacedim>>>(*this);
// partitioning signals
tria_listeners.push_back(
else
{
policy =
- std_cxx14::make_unique<internal::DoFHandlerImplementation::Policy::
- Sequential<DoFHandler<dim, spacedim>>>(
- *this);
+ std::make_unique<internal::DoFHandlerImplementation::Policy::
+ Sequential<DoFHandler<dim, spacedim>>>(*this);
// refinement signals
tria_listeners.push_back(this->tria->signals.pre_refinement.connect(
{
Assert(active_fe_index_transfer == nullptr, ExcInternalError());
- active_fe_index_transfer =
- std_cxx14::make_unique<ActiveFEIndexTransfer>();
+ active_fe_index_transfer = std::make_unique<ActiveFEIndexTransfer>();
dealii::internal::hp::DoFHandlerImplementation::Implementation::
collect_fe_indices_on_cells_to_be_refined(*this);
{
Assert(active_fe_index_transfer == nullptr, ExcInternalError());
- active_fe_index_transfer =
- std_cxx14::make_unique<ActiveFEIndexTransfer>();
+ active_fe_index_transfer = std::make_unique<ActiveFEIndexTransfer>();
// If we work on a p::d::Triangulation, we have to transfer all
// active_fe_indices since ownership of cells may change. We will
const parallel::distributed::Triangulation<dim, spacedim> *>(
&this->get_triangulation());
- active_fe_index_transfer->cell_data_transfer = std_cxx14::make_unique<
+ active_fe_index_transfer->cell_data_transfer = std::make_unique<
parallel::distributed::
CellDataTransfer<dim, spacedim, std::vector<unsigned int>>>(
*distributed_tria,
{
Assert(active_fe_index_transfer == nullptr, ExcInternalError());
- active_fe_index_transfer =
- std_cxx14::make_unique<ActiveFEIndexTransfer>();
+ active_fe_index_transfer = std::make_unique<ActiveFEIndexTransfer>();
// Create transfer object and attach to it.
const auto *distributed_tria = dynamic_cast<
const parallel::distributed::Triangulation<dim, spacedim> *>(
&this->get_triangulation());
- active_fe_index_transfer->cell_data_transfer = std_cxx14::make_unique<
+ active_fe_index_transfer->cell_data_transfer = std::make_unique<
parallel::distributed::
CellDataTransfer<dim, spacedim, std::vector<unsigned int>>>(
*distributed_tria,
{
Assert(active_fe_index_transfer == nullptr, ExcInternalError());
- active_fe_index_transfer =
- std_cxx14::make_unique<ActiveFEIndexTransfer>();
+ active_fe_index_transfer = std::make_unique<ActiveFEIndexTransfer>();
// Create transfer object and attach to it.
const auto *distributed_tria = dynamic_cast<
const parallel::distributed::Triangulation<dim, spacedim> *>(
&this->get_triangulation());
- active_fe_index_transfer->cell_data_transfer = std_cxx14::make_unique<
+ active_fe_index_transfer->cell_data_transfer = std::make_unique<
parallel::distributed::
CellDataTransfer<dim, spacedim, std::vector<unsigned int>>>(
*distributed_tria,
nullptr)
task_group += Threads::new_task([&, fe_index, m_index, q_index]() {
fe_values_table[fe_index][m_index][q_index] =
- std_cxx14::make_unique<FEValuesType>(
- (*mapping_collection)[m_index],
- (*fe_collection)[fe_index],
- q_collection[q_index],
- update_flags);
+ std::make_unique<FEValuesType>((*mapping_collection)[m_index],
+ (*fe_collection)[fe_index],
+ q_collection[q_index],
+ update_flags);
});
task_group.join_all();
// of indices
if (fe_values_table(present_fe_values_index).get() == nullptr)
fe_values_table(present_fe_values_index) =
- std_cxx14::make_unique<FEValuesType>(
- (*mapping_collection)[mapping_index],
- (*fe_collection)[fe_index],
- q_collection[q_index],
- update_flags);
+ std::make_unique<FEValuesType>((*mapping_collection)[mapping_index],
+ (*fe_collection)[fe_index],
+ q_collection[q_index],
+ update_flags);
// now there definitely is one!
return *fe_values_table(present_fe_values_index);
task_group +=
Threads::new_task([&, fe_index, mapping_index, q_index]() {
fe_values_table(TableIndices<3>(fe_index, mapping_index, q_index)) =
- std_cxx14::make_unique<FEValuesType>(
+ std::make_unique<FEValuesType>(
(*mapping_collection)[mapping_index],
(*fe_collection)[fe_index],
q_collection[q_index],
std::fill(wr.begin(), wr.end(), 0.);
ipiv.resize(8 * mm);
- svd_u = std_cxx14::make_unique<LAPACKFullMatrix<number>>(mm, mm);
- svd_vt = std_cxx14::make_unique<LAPACKFullMatrix<number>>(nn, nn);
+ svd_u = std::make_unique<LAPACKFullMatrix<number>>(mm, mm);
+ svd_vt = std::make_unique<LAPACKFullMatrix<number>>(nn, nn);
types::blas_int info = 0;
// First determine optimal workspace size
// is necessary
if (solver_data.get() == nullptr)
{
- solver_data = std_cxx14::make_unique<SolverData>();
+ solver_data = std::make_unique<SolverData>();
PetscErrorCode ierr = KSPCreate(mpi_communicator, &solver_data->ksp);
AssertThrow(ierr == 0, ExcPETScError(ierr));
{
PetscErrorCode ierr;
- solver_data = std_cxx14::make_unique<SolverData>();
+ solver_data = std::make_unique<SolverData>();
ierr = KSPCreate(mpi_communicator, &solver_data->ksp);
AssertThrow(ierr == 0, ExcPETScError(ierr));
*/
if (solver_data == nullptr)
{
- solver_data = std_cxx14::make_unique<SolverDataMUMPS>();
+ solver_data = std::make_unique<SolverDataMUMPS>();
/**
* creates the default KSP context and puts it in the location
// distributed matrix
std::unique_ptr<ScaLAPACKMatrix<NumberType>> eigenvectors =
compute_eigenvectors ?
- std_cxx14::make_unique<ScaLAPACKMatrix<NumberType>>(n_rows,
- grid,
- row_block_size) :
- std_cxx14::make_unique<ScaLAPACKMatrix<NumberType>>(
+ std::make_unique<ScaLAPACKMatrix<NumberType>>(n_rows,
+ grid,
+ row_block_size) :
+ std::make_unique<ScaLAPACKMatrix<NumberType>>(
grid->n_process_rows, grid->n_process_columns, grid, 1, 1);
eigenvectors->property = property;
// distributed matrix.
std::unique_ptr<ScaLAPACKMatrix<NumberType>> eigenvectors =
compute_eigenvectors ?
- std_cxx14::make_unique<ScaLAPACKMatrix<NumberType>>(n_rows,
- grid,
- row_block_size) :
- std_cxx14::make_unique<ScaLAPACKMatrix<NumberType>>(
+ std::make_unique<ScaLAPACKMatrix<NumberType>>(n_rows,
+ grid,
+ row_block_size) :
+ std::make_unique<ScaLAPACKMatrix<NumberType>>(
grid->n_process_rows, grid->n_process_columns, grid, 1, 1);
eigenvectors->property = property;
{
vec_len = 1;
max_vec_len = vec_len;
- colnums = std_cxx14::make_unique<size_type[]>(max_vec_len);
+ colnums = std::make_unique<size_type[]>(max_vec_len);
}
max_row_length =
if (rows > max_dim)
{
max_dim = rows;
- rowstart = std_cxx14::make_unique<std::size_t[]>(max_dim + 1);
+ rowstart = std::make_unique<std::size_t[]>(max_dim + 1);
}
// allocate memory for the column numbers if necessary
if (vec_len > max_vec_len)
{
max_vec_len = vec_len;
- colnums = std_cxx14::make_unique<size_type[]>(max_vec_len);
+ colnums = std::make_unique<size_type[]>(max_vec_len);
}
// set the rowstart array
AssertThrow(c == '[', ExcIO());
// reallocate space
- rowstart = std_cxx14::make_unique<std::size_t[]>(max_dim + 1);
- colnums = std_cxx14::make_unique<size_type[]>(max_vec_len);
+ rowstart = std::make_unique<std::size_t[]>(max_dim + 1);
+ colnums = std::make_unique<size_type[]>(max_vec_len);
// then read data
in.read(reinterpret_cast<char *>(rowstart.get()),
(void)cell_weights;
// MPI environment must have been initialized by this point.
- std::unique_ptr<Zoltan> zz =
- std_cxx14::make_unique<Zoltan>(MPI_COMM_SELF);
+ std::unique_ptr<Zoltan> zz = std::make_unique<Zoltan>(MPI_COMM_SELF);
// General parameters
// DEBUG_LEVEL call must precede the call to LB_METHOD
return 0;
#else
// coloring algorithm is run in serial by each processor.
- std::unique_ptr<Zoltan> zz = std_cxx14::make_unique<Zoltan>(MPI_COMM_SELF);
+ std::unique_ptr<Zoltan> zz = std::make_unique<Zoltan>(MPI_COMM_SELF);
// Coloring parameters
// DEBUG_LEVEL must precede all other calls
// Target map is read_write_vector_map
// Source map is vector_space_vector_map. This map must have uniquely
// owned GID.
- import = std_cxx14::make_unique<Epetra_Import>(read_write_vector_map,
- vector_space_vector_map);
+ import = std::make_unique<Epetra_Import>(read_write_vector_map,
+ vector_space_vector_map);
}
Epetra_Map input_map =
parallel_partitioner.make_trilinos_map(communicator, false);
if (vector->Map().SameAs(input_map) == false)
- vector = std_cxx14::make_unique<Epetra_FEVector>(input_map);
+ vector = std::make_unique<Epetra_FEVector>(input_map);
else if (omit_zeroing_entries == false)
{
const int ierr = vector->PutScalar(0.);
(void)ierr;
}
else
- vector =
- std_cxx14::make_unique<Epetra_FEVector>(V.trilinos_vector());
+ vector = std::make_unique<Epetra_FEVector>(V.trilinos_vector());
}
return *this;
const Epetra_Map &domain_map = matrix.OperatorDomainMap();
const size_type constant_modes_dimension = constant_modes.size();
- ptr_distributed_constant_modes = std_cxx14::make_unique<Epetra_MultiVector>(
+ ptr_distributed_constant_modes = std::make_unique<Epetra_MultiVector>(
domain_map, constant_modes_dimension > 0 ? constant_modes_dimension : 1);
Assert(ptr_distributed_constant_modes, ExcNotInitialized());
Epetra_MultiVector &distributed_constant_modes =
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+ linear_problem = std::make_unique<Epetra_LinearProblem>(
const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()),
&x.trilinos_vector(),
const_cast<Epetra_MultiVector *>(&b.trilinos_vector()));
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
- const_cast<Epetra_Operator *>(&A),
- &x.trilinos_vector(),
- const_cast<Epetra_MultiVector *>(&b.trilinos_vector()));
+ linear_problem =
+ std::make_unique<Epetra_LinearProblem>(const_cast<Epetra_Operator *>(&A),
+ &x.trilinos_vector(),
+ const_cast<Epetra_MultiVector *>(
+ &b.trilinos_vector()));
do_solve(preconditioner);
}
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
- const_cast<Epetra_Operator *>(&A),
- &x.trilinos_vector(),
- const_cast<Epetra_MultiVector *>(&b.trilinos_vector()));
+ linear_problem =
+ std::make_unique<Epetra_LinearProblem>(const_cast<Epetra_Operator *>(&A),
+ &x.trilinos_vector(),
+ const_cast<Epetra_MultiVector *>(
+ &b.trilinos_vector()));
do_solve(preconditioner);
}
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
- const_cast<Epetra_Operator *>(&A),
- &x,
- const_cast<Epetra_MultiVector *>(&b));
+ linear_problem =
+ std::make_unique<Epetra_LinearProblem>(const_cast<Epetra_Operator *>(&A),
+ &x,
+ const_cast<Epetra_MultiVector *>(
+ &b));
do_solve(preconditioner);
}
{
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
- const_cast<Epetra_Operator *>(&A),
- &x,
- const_cast<Epetra_MultiVector *>(&b));
+ linear_problem =
+ std::make_unique<Epetra_LinearProblem>(const_cast<Epetra_Operator *>(&A),
+ &x,
+ const_cast<Epetra_MultiVector *>(
+ &b));
do_solve(preconditioner);
}
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+ linear_problem = std::make_unique<Epetra_LinearProblem>(
const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()), &ep_x, &ep_b);
do_solve(preconditioner);
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
- linear_problem =
- std_cxx14::make_unique<Epetra_LinearProblem>(&A, &ep_x, &ep_b);
+ linear_problem = std::make_unique<Epetra_LinearProblem>(&A, &ep_x, &ep_b);
do_solve(preconditioner);
}
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+ linear_problem = std::make_unique<Epetra_LinearProblem>(
const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()), &ep_x, &ep_b);
do_solve(preconditioner);
// We need an Epetra_LinearProblem object to let the AztecOO solver know
// about the matrix and vectors.
- linear_problem =
- std_cxx14::make_unique<Epetra_LinearProblem>(&A, &ep_x, &ep_b);
+ linear_problem = std::make_unique<Epetra_LinearProblem>(&A, &ep_x, &ep_b);
do_solve(preconditioner);
}
, current_residual(std::numeric_limits<double>::max())
// Consider linear problem converged if any of the collection of
// criterion are met
- , status_test_collection(
- std_cxx14::make_unique<AztecOO_StatusTestCombo>(
- AztecOO_StatusTestCombo::OR))
+ , status_test_collection(std::make_unique<AztecOO_StatusTestCombo>(
+ AztecOO_StatusTestCombo::OR))
{
// Maximum number of iterations
Assert(max_steps >= 0, ExcInternalError());
status_test_max_steps =
- std
_cxx14::make_unique<AztecOO_StatusTestMaxIters>(max_steps);
+ std::make_unique<AztecOO_StatusTestMaxIters>(max_steps);
status_test_collection->AddStatusTest(*status_test_max_steps);
Assert(linear_problem.GetRHS()->NumVectors() == 1,
ExcMessage("RHS multivector holds more than one vector"));
// Residual norm is below some absolute value
- status_test_abs_tol = std
_cxx14::make_unique<AztecOO_StatusTestResNorm>(
+ status_test_abs_tol = std::make_unique<AztecOO_StatusTestResNorm>(
*linear_problem.GetOperator(),
*(linear_problem.GetLHS()->operator()(0)),
*(linear_problem.GetRHS()->operator()(0)),
status_test_collection->AddStatusTest(*status_test_abs_tol);
// Residual norm, scaled by some initial value, is below some threshold
- status_test_rel_tol = std
_cxx14::make_unique<AztecOO_StatusTestResNorm>(
+ status_test_rel_tol = std::make_unique<AztecOO_StatusTestResNorm>(
*linear_problem.GetOperator(),
*(linear_problem.GetLHS()->operator()(0)),
*(linear_problem.GetRHS()->operator()(0)),
if (const ReductionControl *const reduction_control =
dynamic_cast<const ReductionControl *const>(&solver_control))
{
- status_test =
- std_cxx14::make_unique<internal::TrilinosReductionControl>(
- reduction_control->max_steps(),
- reduction_control->tolerance(),
- reduction_control->reduction(),
- *linear_problem);
+ status_test = std::make_unique<internal::TrilinosReductionControl>(
+ reduction_control->max_steps(),
+ reduction_control->tolerance(),
+ reduction_control->reduction(),
+ *linear_problem);
solver.SetStatusTest(status_test.get());
}
}
{
// We need an Epetra_LinearProblem object to let the Amesos solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>();
+ linear_problem = std::make_unique<Epetra_LinearProblem>();
// Assign the matrix operator to the Epetra_LinearProblem object
linear_problem->SetOperator(
{
// We need an Epetra_LinearProblem object to let the Amesos solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+ linear_problem = std::make_unique<Epetra_LinearProblem>(
const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()),
&x.trilinos_vector(),
const_cast<Epetra_MultiVector *>(&b.trilinos_vector()));
// We need an Epetra_LinearProblem object to let the Amesos solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+ linear_problem = std::make_unique<Epetra_LinearProblem>(
const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()), &ep_x, &ep_b);
do_solve();
// We need an Epetra_LinearProblem object to let the Amesos solver know
// about the matrix and vectors.
- linear_problem = std_cxx14::make_unique<Epetra_LinearProblem>(
+ linear_problem = std::make_unique<Epetra_LinearProblem>(
const_cast<Epetra_CrsMatrix *>(&A.trilinos_matrix()), &ep_x, &ep_b);
do_solve();
if (needs_deep_copy)
{
column_space_map =
- std_cxx14::make_unique<Epetra_Map>(rhs.trilinos_matrix().DomainMap());
+ std::make_unique<Epetra_Map>(rhs.trilinos_matrix().DomainMap());
// release memory before reallocation
- matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(*rhs.matrix);
+ matrix = std::make_unique<Epetra_FECrsMatrix>(*rhs.matrix);
matrix->FillComplete(*column_space_map, matrix->RowMap());
}
if (rhs.nonlocal_matrix.get() != nullptr)
nonlocal_matrix =
- std_cxx14::make_unique<Epetra_CrsMatrix>(Copy,
- rhs.nonlocal_matrix->Graph());
+ std::make_unique<Epetra_CrsMatrix>(Copy, rhs.nonlocal_matrix->Graph());
}
nonlocal_matrix.reset();
nonlocal_matrix_exporter.reset();
- column_space_map = std_cxx14::make_unique<Epetra_Map>(
+ column_space_map = std::make_unique<Epetra_Map>(
column_parallel_partitioning.make_trilinos_map(communicator, false));
if (column_space_map->Comm().MyPID() == 0)
sparsity_pattern,
communicator,
exchange_data);
- matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(
+ matrix = std::make_unique<Epetra_FECrsMatrix>(
Copy, trilinos_sparsity.trilinos_sparsity_pattern(), false);
return;
// columns as well. Compare this with bug # 4123 in the Sandia Bugzilla.
std::unique_ptr<Epetra_CrsGraph> graph;
if (row_space_map.Comm().NumProc() > 1)
- graph = std_cxx14::make_unique<Epetra_CrsGraph>(
- Copy, row_space_map, n_entries_per_row.data(), true);
+ graph = std::make_unique<Epetra_CrsGraph>(Copy,
+ row_space_map,
+ n_entries_per_row.data(),
+ true);
else
- graph =
- std_cxx14::make_unique<Epetra_CrsGraph>(Copy,
+ graph = std::make_unique<Epetra_CrsGraph>(Copy,
row_space_map,
*column_space_map,
n_entries_per_row.data(),
(void)n_global_cols;
// And now finally generate the matrix.
- matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
+ matrix = std::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
}
nonlocal_matrix.reset();
nonlocal_matrix_exporter.reset();
- column_space_map = std_cxx14::make_unique<Epetra_Map>(
+ column_space_map = std::make_unique<Epetra_Map>(
column_parallel_partitioning.make_trilinos_map(communicator, false));
AssertDimension(sparsity_pattern.n_rows(),
std::unique_ptr<Epetra_CrsGraphMod> nonlocal_graph;
if (row_space_map.Comm().NumProc() > 1)
{
- graph = std_cxx14::make_unique<Epetra_CrsGraph>(
- Copy,
- row_space_map,
- (n_entries_per_row.size() > 0) ? (n_entries_per_row.data()) :
- nullptr,
- exchange_data ? false : true);
+ graph =
+ std::make_unique<Epetra_CrsGraph>(Copy,
+ row_space_map,
+ (n_entries_per_row.size() > 0) ?
+ (n_entries_per_row.data()) :
+ nullptr,
+ exchange_data ? false : true);
if (have_ghost_rows == true)
- nonlocal_graph = std_cxx14::make_unique<Epetra_CrsGraphMod>(
+ nonlocal_graph = std::make_unique<Epetra_CrsGraphMod>(
off_processor_map, n_entries_per_ghost_row.data());
}
else
- graph = std_cxx14::make_unique<Epetra_CrsGraph>(
- Copy,
- row_space_map,
- *column_space_map,
- (n_entries_per_row.size() > 0) ? (n_entries_per_row.data()) : nullptr,
- true);
+ graph =
+ std::make_unique<Epetra_CrsGraph>(Copy,
+ row_space_map,
+ *column_space_map,
+ (n_entries_per_row.size() > 0) ?
+ (n_entries_per_row.data()) :
+ nullptr,
+ true);
// now insert the indices, select between the right matrix
std::vector<TrilinosWrappers::types::int_type> row_indices;
}
nonlocal_matrix =
- std_cxx14::make_unique<Epetra_CrsMatrix>(Copy, *nonlocal_graph);
+ std::make_unique<Epetra_CrsMatrix>(Copy, *nonlocal_graph);
}
graph->FillComplete(*column_space_map, row_space_map);
AssertDimension(sparsity_pattern.n_cols(),
TrilinosWrappers::n_global_cols(*graph));
- matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
+ matrix = std::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
}
} // namespace
// reinit with a (parallel) Trilinos sparsity pattern.
column_space_map =
- std_cxx14::make_unique<Epetra_Map>(sparsity_pattern.domain_partitioner());
- matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(
+ std::make_unique<Epetra_Map>(sparsity_pattern.domain_partitioner());
+ matrix = std::make_unique<Epetra_FECrsMatrix>(
Copy, sparsity_pattern.trilinos_sparsity_pattern(), false);
if (sparsity_pattern.nonlocal_graph.get() != nullptr)
- nonlocal_matrix = std_cxx14::make_unique<Epetra_CrsMatrix>(
- Copy, *sparsity_pattern.nonlocal_graph);
+ nonlocal_matrix =
+ std::make_unique<Epetra_CrsMatrix>(Copy,
+ *sparsity_pattern.nonlocal_graph);
else
nonlocal_matrix.reset();
if (this == &sparse_matrix)
return;
- column_space_map = std_cxx14::make_unique<Epetra_Map>(
- sparse_matrix.trilinos_matrix().DomainMap());
+ column_space_map =
+ std::make_unique<Epetra_Map>(sparse_matrix.trilinos_matrix().DomainMap());
matrix.reset();
nonlocal_matrix_exporter.reset();
- matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(
+ matrix = std::make_unique<Epetra_FECrsMatrix>(
Copy, sparse_matrix.trilinos_sparsity_pattern(), false);
if (sparse_matrix.nonlocal_matrix != nullptr)
- nonlocal_matrix = std_cxx14::make_unique<Epetra_CrsMatrix>(
+ nonlocal_matrix = std::make_unique<Epetra_CrsMatrix>(
Copy, sparse_matrix.nonlocal_matrix->Graph());
else
nonlocal_matrix.reset();
Assert(input_matrix.Filled() == true,
ExcMessage("Input CrsMatrix has not called FillComplete()!"));
- column_space_map =
- std_cxx14::make_unique<Epetra_Map>(input_matrix.DomainMap());
+ column_space_map = std::make_unique<Epetra_Map>(input_matrix.DomainMap());
const Epetra_CrsGraph *graph = &input_matrix.Graph();
nonlocal_matrix.reset();
nonlocal_matrix_exporter.reset();
matrix.reset();
- matrix = std_cxx14::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
+ matrix = std::make_unique<Epetra_FECrsMatrix>(Copy, *graph, false);
matrix->FillComplete(*column_space_map, input_matrix.RangeMap(), true);
nonlocal_matrix->FillComplete(*column_space_map, matrix->RowMap());
if (nonlocal_matrix_exporter.get() == nullptr)
nonlocal_matrix_exporter =
- std_cxx14::make_unique<Epetra_Export>(nonlocal_matrix->RowMap(),
- matrix->RowMap());
+ std::make_unique<Epetra_Export>(nonlocal_matrix->RowMap(),
+ matrix->RowMap());
ierr =
matrix->Export(*nonlocal_matrix, *nonlocal_matrix_exporter, mode);
AssertThrow(ierr == 0, ExcTrilinosError(ierr));
// the pointer and generate an
// empty matrix.
column_space_map =
- std_cxx14::make_unique<Epetra_Map>(0,
- 0,
- Utilities::Trilinos::comm_self());
- matrix =
- std_cxx14::make_unique<Epetra_FECrsMatrix>(View, *column_space_map, 0);
+ std::make_unique<Epetra_Map>(0, 0, Utilities::Trilinos::comm_self());
+ matrix = std::make_unique<Epetra_FECrsMatrix>(View, *column_space_map, 0);
nonlocal_matrix.reset();
nonlocal_matrix_exporter.reset();
SparsityPattern::SparsityPattern()
{
column_space_map =
- std_cxx14::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
- TrilinosWrappers::types::int_type(0),
- Utilities::Trilinos::comm_self());
- graph = std_cxx14::make_unique<Epetra_FECrsGraph>(View,
- *column_space_map,
- *column_space_map,
- 0);
+ std::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
+ TrilinosWrappers::types::int_type(0),
+ Utilities::Trilinos::comm_self());
+ graph = std::make_unique<Epetra_FECrsGraph>(View,
+ *column_space_map,
+ *column_space_map,
+ 0);
graph->FillComplete();
}
nonlocal_graph.reset();
graph.reset();
- column_space_map = std_cxx14::make_unique<Epetra_Map>(col_map);
+ column_space_map = std::make_unique<Epetra_Map>(col_map);
// for more than one processor, need to specify only row map first and
// let the matrix entries decide about the column map (which says which
// require building a non-local graph which gives us thread-safe
// initialization.
if (row_map.Comm().NumProc() > 1)
- graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+ graph = std::make_unique<Epetra_FECrsGraph>(
Copy, row_map, n_entries_per_row, false
// TODO: Check which new Trilinos version supports this...
// Remember to change tests/trilinos/assemble_matrix_parallel_07, too.
//#endif
);
else
- graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+ graph = std::make_unique<Epetra_FECrsGraph>(
Copy, row_map, col_map, n_entries_per_row, false);
}
AssertDimension(n_entries_per_row.size(),
TrilinosWrappers::n_global_elements(row_map));
- column_space_map = std_cxx14::make_unique<Epetra_Map>(col_map);
+ column_space_map = std::make_unique<Epetra_Map>(col_map);
std::vector<int> local_entries_per_row(
TrilinosWrappers::max_my_gid(row_map) -
TrilinosWrappers::min_my_gid(row_map));
n_entries_per_row[TrilinosWrappers::min_my_gid(row_map) + i];
if (row_map.Comm().NumProc() > 1)
- graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+ graph = std::make_unique<Epetra_FECrsGraph>(
Copy, row_map, local_entries_per_row.data(), false
// TODO: Check which new Trilinos version supports this...
// Remember to change tests/trilinos/assemble_matrix_parallel_07, too.
//#endif
);
else
- graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+ graph = std::make_unique<Epetra_FECrsGraph>(
Copy, row_map, col_map, local_entries_per_row.data(), false);
}
AssertDimension(sp.n_cols(),
TrilinosWrappers::n_global_elements(col_map));
- column_space_map = std_cxx14::make_unique<Epetra_Map>(col_map);
+ column_space_map = std::make_unique<Epetra_Map>(col_map);
Assert(row_map.LinearMap() == true,
ExcMessage(
static_cast<int>(sp.row_length(row));
if (row_map.Comm().NumProc() > 1)
- graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
- Copy, row_map, n_entries_per_row.data(), false);
+ graph = std::make_unique<Epetra_FECrsGraph>(Copy,
+ row_map,
+ n_entries_per_row.data(),
+ false);
else
- graph = std_cxx14::make_unique<Epetra_FECrsGraph>(
+ graph = std::make_unique<Epetra_FECrsGraph>(
Copy, row_map, col_map, n_entries_per_row.data(), false);
AssertDimension(sp.n_rows(), n_global_rows(*graph));
Epetra_Map nonlocal_map =
nonlocal_partitioner.make_trilinos_map(communicator, true);
nonlocal_graph =
- std_cxx14::make_unique<Epetra_CrsGraph>(Copy, nonlocal_map, 0);
+ std::make_unique<Epetra_CrsGraph>(Copy, nonlocal_map, 0);
}
else
Assert(nonlocal_partitioner.n_elements() == 0, ExcInternalError());
void
SparsityPattern::copy_from(const SparsityPattern &sp)
{
- column_space_map = std_cxx14::make_unique<Epetra_Map>(*sp.column_space_map);
- graph = std_cxx14::make_unique<Epetra_FECrsGraph>(*sp.graph);
+ column_space_map = std::make_unique<Epetra_Map>(*sp.column_space_map);
+ graph = std::make_unique<Epetra_FECrsGraph>(*sp.graph);
if (sp.nonlocal_graph.get() != nullptr)
- nonlocal_graph =
- std_cxx14::make_unique<Epetra_CrsGraph>(*sp.nonlocal_graph);
+ nonlocal_graph = std::make_unique<Epetra_CrsGraph>(*sp.nonlocal_graph);
else
nonlocal_graph.reset();
}
// the pointer and generate an
// empty sparsity pattern.
column_space_map =
- std_cxx14::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
- TrilinosWrappers::types::int_type(0),
- Utilities::Trilinos::comm_self());
- graph = std_cxx14::make_unique<Epetra_FECrsGraph>(View,
- *column_space_map,
- *column_space_map,
- 0);
+ std::make_unique<Epetra_Map>(TrilinosWrappers::types::int_type(0),
+ TrilinosWrappers::types::int_type(0),
+ Utilities::Trilinos::comm_self());
+ graph = std::make_unique<Epetra_FECrsGraph>(View,
+ *column_space_map,
+ *column_space_map,
+ 0);
graph->FillComplete();
nonlocal_graph.reset();
// Source map is vector_space_vector_map. This map must have uniquely
// owned GID.
tpetra_import =
- std_cxx14::make_unique<Tpetra::Import<int, types::global_dof_index>>(
+ std::make_unique<Tpetra::Import<int, types::global_dof_index>>(
read_write_vector_map, vector_space_vector_map);
tpetra_export =
- std_cxx14::make_unique<Tpetra::Export<int, types::global_dof_index>>(
+ std::make_unique<Tpetra::Export<int, types::global_dof_index>>(
read_write_vector_map, vector_space_vector_map);
}
: Vector()
{
has_ghosts = v.has_ghosts;
- vector = std_cxx14::make_unique<Epetra_FEVector>(*v.vector);
+ vector = std::make_unique<Epetra_FEVector>(*v.vector);
owned_elements = v.owned_elements;
}
TrilinosWrappers::n_global_elements(
v.vector->Map())));
- vector = std_cxx14::make_unique<Epetra_FEVector>(
+ vector = std::make_unique<Epetra_FEVector>(
parallel_partitioner.make_trilinos_map(communicator, true));
reinit(v, false, true);
}
# endif
has_ghosts = false;
- vector = std_cxx14::make_unique<Epetra_FEVector>(map);
+ vector = std::make_unique<Epetra_FEVector>(map);
last_action = Zero;
}
Epetra_Map map =
parallel_partitioner.make_trilinos_map(communicator, overlapping);
- vector = std_cxx14::make_unique<Epetra_FEVector>(map);
+ vector = std::make_unique<Epetra_FEVector>(map);
has_ghosts = vector->Map().UniqueGIDs() == false;
if (!same_communicators ||
vector->Map().SameAs(v.vector->Map()) == false)
{
- vector = std_cxx14::make_unique<Epetra_FEVector>(v.vector->Map());
- has_ghosts = v.has_ghosts;
- last_action = Zero;
+ vector = std::make_unique<Epetra_FEVector>(v.vector->Map());
+ has_ghosts = v.has_ghosts;
+ last_action = Zero;
owned_elements = v.owned_elements;
}
else if (omit_zeroing_entries == false)
0,
v.block(0).trilinos_partitioner().Comm());
- auto actual_vec = std_cxx14::make_unique<Epetra_FEVector>(new_map);
+ auto actual_vec = std::make_unique<Epetra_FEVector>(new_map);
TrilinosScalar *entries = (*actual_vec)[0];
for (size_type block = 0; block < v.n_blocks(); ++block)
parallel_partitioner.add_indices(ghost_entries);
Epetra_Map map =
parallel_partitioner.make_trilinos_map(communicator, true);
- vector = std_cxx14::make_unique<Epetra_FEVector>(map);
+ vector = std::make_unique<Epetra_FEVector>(map);
}
else
{
"its parallel partitioning"));
if (vector->Map().SameAs(map) == false)
- vector = std_cxx14::make_unique<Epetra_FEVector>(map);
+ vector = std::make_unique<Epetra_FEVector>(map);
else
{
const int ierr = vector->PutScalar(0.);
Epetra_Map nonlocal_map =
nonlocal_entries.make_trilinos_map(communicator, true);
nonlocal_vector =
- std_cxx14::make_unique<Epetra_MultiVector>(nonlocal_map, 1);
+ std::make_unique<Epetra_MultiVector>(nonlocal_map, 1);
}
}
{
*vector = *v.vector;
if (v.nonlocal_vector.get() != nullptr)
- nonlocal_vector = std_cxx14::make_unique<Epetra_MultiVector>(
- v.nonlocal_vector->Map(), 1);
+ nonlocal_vector =
+ std::make_unique<Epetra_MultiVector>(v.nonlocal_vector->Map(), 1);
last_action = Zero;
}
// Second case: vectors have the same global
// size.
else
{
- vector = std_cxx14::make_unique<Epetra_FEVector>(*v.vector);
+ vector = std::make_unique<Epetra_FEVector>(*v.vector);
last_action = Zero;
has_ghosts = v.has_ghosts;
owned_elements = v.owned_elements;
if (v.nonlocal_vector.get() != nullptr)
nonlocal_vector =
- std_cxx14::make_unique<Epetra_MultiVector>(v.nonlocal_vector->Map(),
- 1);
+ std::make_unique<Epetra_MultiVector>(v.nonlocal_vector->Map(), 1);
return *this;
}
if (vector->Map().SameAs(m.trilinos_matrix().ColMap()) == false)
vector =
- std_cxx14::make_unique<Epetra_FEVector>(m.trilinos_matrix().ColMap());
+ std::make_unique<Epetra_FEVector>(m.trilinos_matrix().ColMap());
Epetra_Import data_exchange(vector->Map(), v.vector->Map());
const int ierr = vector->Import(*v.vector, data_exchange, Insert);
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell)
{
if (!fe_values)
- fe_values = std_cxx14::make_unique<FEValues<dim, spacedim>>(
- *mapping, *fe, cell_quadrature, cell_update_flags);
+ fe_values = std::make_unique<FEValues<dim, spacedim>>(*mapping,
+ *fe,
+ cell_quadrature,
+ cell_update_flags);
fe_values->reinit(cell);
cell->get_dof_indices(local_dof_indices);
const unsigned int face_no)
{
if (!fe_face_values)
- fe_face_values = std_cxx14::make_unique<FEFaceValues<dim, spacedim>>(
+ fe_face_values = std::make_unique<FEFaceValues<dim, spacedim>>(
*mapping, *fe, face_quadrature, face_update_flags);
fe_face_values->reinit(cell, face_no);
if (subface_no != numbers::invalid_unsigned_int)
{
if (!fe_subface_values)
- fe_subface_values =
- std_cxx14::make_unique<FESubfaceValues<dim, spacedim>>(
- *mapping, *fe, face_quadrature, face_update_flags);
+ fe_subface_values = std::make_unique<FESubfaceValues<dim, spacedim>>(
+ *mapping, *fe, face_quadrature, face_update_flags);
fe_subface_values->reinit(cell, face_no, subface_no);
cell->get_dof_indices(local_dof_indices);
const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell)
{
if (!neighbor_fe_values)
- neighbor_fe_values = std_cxx14::make_unique<FEValues<dim, spacedim>>(
+ neighbor_fe_values = std::make_unique<FEValues<dim, spacedim>>(
*mapping, *fe, cell_quadrature, neighbor_cell_update_flags);
neighbor_fe_values->reinit(cell);
const unsigned int face_no)
{
if (!neighbor_fe_face_values)
- neighbor_fe_face_values =
- std_cxx14::make_unique<FEFaceValues<dim, spacedim>>(
- *mapping, *fe, face_quadrature, neighbor_face_update_flags);
+ neighbor_fe_face_values = std::make_unique<FEFaceValues<dim, spacedim>>(
+ *mapping, *fe, face_quadrature, neighbor_face_update_flags);
neighbor_fe_face_values->reinit(cell, face_no);
cell->get_dof_indices(neighbor_dof_indices);
current_neighbor_fe_values = neighbor_fe_face_values.get();
{
if (!neighbor_fe_subface_values)
neighbor_fe_subface_values =
- std_cxx14::make_unique<FESubfaceValues<dim, spacedim>>(
+ std::make_unique<FESubfaceValues<dim, spacedim>>(
*mapping, *fe, face_quadrature, neighbor_face_update_flags);
neighbor_fe_subface_values->reinit(cell, face_no, subface_no);
cell->get_dof_indices(neighbor_dof_indices);
KDTree<dim>::set_points(const std::vector<Point<dim>> &pts)
{
Assert(pts.size() > 0, ExcMessage("Expecting a non zero set of points."));
- adaptor = std
_cxx14::make_unique<PointCloudAdaptor>(pts);
- kdtree = std_cxx14::make_unique<NanoFlannKDTree>(
+ adaptor = std::make_unique<PointCloudAdaptor>(pts);
+ kdtree = std::make_unique<NanoFlannKDTree>(
dim, *adaptor, nanoflann::KDTreeSingleIndexAdaptorParams(max_leaf_size));
kdtree->buildIndex();
}
, handle(numbers::invalid_unsigned_int)
{
triangulation_cache =
- std_cxx14::make_unique<GridTools::Cache<dim, spacedim>>(triangulation,
- mapping);
+ std::make_unique<GridTools::Cache<dim, spacedim>>(triangulation, mapping);
}
mapping = &new_mapping;
// Create the memory pool that will store all particle properties
- property_pool = std
_cxx14::make_unique<PropertyPool>(n_properties);
+ property_pool = std::make_unique<PropertyPool>(n_properties);
// Create the grid cache to cache the information about the triangulation
// that is used to locate the particles into subdomains and cells
triangulation_cache =
- std_cxx14::make_unique<GridTools::Cache<dim, spacedim>>(new_triangulation,
- new_mapping);
+ std::make_unique<GridTools::Cache<dim, spacedim>>(new_triangulation,
+ new_mapping);
}
test()
{
// Create a pointer to D
- std::unique_ptr<D> d = std_cxx14::make_unique<D>();
+ std::unique_ptr<D> d = std::make_unique<D>();
// See that we can successfully downcast to B
std::unique_ptr<B> b = Utilities::dynamic_unique_cast<B>(std::move(d));
invalid_test()
{
// Create a pointer to B
- std::unique_ptr<B> b = std_cxx14::make_unique<B>();
+ std::unique_ptr<B> b = std::make_unique<B>();
// Check that we can indeed not upcast to D:
try
{
initlog();
- constexpr int max_1 = std_cxx14::max(0, 1);
+ constexpr int max_1 = std::max(0, 1);
deallog << max_1 << std::endl;
- constexpr int max_2 = std_cxx14::max(3, 2, comp);
+ constexpr int max_2 = std::max(3, 2, comp);
deallog << max_2 << std::endl;
- constexpr int min_1 = std_cxx14::min(1, 2);
+ constexpr int min_1 = std::min(1, 2);
deallog << min_1 << std::endl;
- constexpr int min_2 = std_cxx14::min(1, 2, comp);
+ constexpr int min_2 = std::min(1, 2, comp);
deallog << min_2 << std::endl;
deallog << "OK" << std::endl;
// after the FECollection has been generated, create a corresponding legendre
// series expansion object
- legendre = std_cxx14::make_unique<FESeries::Legendre<dim>>(
+ legendre = std::make_unique<FESeries::Legendre<dim>>(
SmoothnessEstimator::Legendre::default_fe_series(Laplace<dim>::fe));
}
const std::vector<unsigned int> n_coefficients_per_direction(
fe_collection.size(), max_degree);
- fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
- n_coefficients_per_direction, fe_collection, fourier_q_collection);
+ fourier =
+ std::make_unique<FESeries::Fourier<dim>>(n_coefficients_per_direction,
+ fe_collection,
+ fourier_q_collection);
}
std::unique_ptr<Manifold<dim, spacedim>>
clone() const override
{
- return std_cxx14::make_unique<MyManifold<dim, spacedim>>();
+ return std::make_unique<MyManifold<dim, spacedim>>();
}
};
virtual std::unique_ptr<Manifold<dim, spacedim>>
clone() const override
{
- return std_cxx14::make_unique<InnerTorusManifold>();
+ return std::make_unique<InnerTorusManifold>();
}
virtual Point<chartdim>
std::unique_ptr<Manifold<dim>>
Geometry<dim>::clone() const
{
- return std_cxx14::make_unique<Geometry<dim>>();
+ return std::make_unique<Geometry<dim>>();
}
std::unique_ptr<Manifold<dim>>
Geometry<dim>::clone() const
{
- return std_cxx14::make_unique<Geometry<dim>>();
+ return std::make_unique<Geometry<dim>>();
}
template <int dim>
virtual std::unique_ptr<Manifold<dim, dim>>
clone() const
{
- return std_cxx14::make_unique<DeformedManifold<dim>>();
+ return std::make_unique<DeformedManifold<dim>>();
}
virtual Point<dim>
virtual std::unique_ptr<Manifold<dim>>
clone() const override
{
- return std
_cxx14::make_unique<PeriodicHillManifold<dim>>();
+ return std::make_unique<PeriodicHillManifold<dim>>();
}
virtual Point<dim>
constraints_ptrs[i] = &constraints[i];
}
QGauss<1> quad(n_q_points_1d);
- constexpr int max_degree = std_cxx14::max(fe_degree_1, fe_degree_2);
+ constexpr int max_degree = std::max(fe_degree_1, fe_degree_2);
MappingQ<dim> mapping(max_degree);
typename MatrixFree<dim, number>::AdditionalData fine_level_additional_data;
parallel::distributed::Triangulation<dim>::construct_multigrid_hierarchy);
GridGenerator::hyper_cube(tria);
tria.refine_global(6 - dim);
- constexpr int max_degree = std_cxx14::max(fe_degree_1, fe_degree_2);
+ constexpr int max_degree = std::max(fe_degree_1, fe_degree_2);
const unsigned int n_runs = max_degree == 1 ? 6 - dim : 5 - dim;
for (unsigned int i = 0; i < n_runs; ++i)
{
std::vector<const DoFHandler<dim, dim> *> dh_ptrs{&dof_1, &dof_2};
- constexpr int n_q_points_1d =
- std_cxx14::max(fe_degree_1, fe_degree_2) + 1;
+ constexpr int n_q_points_1d = std::max(fe_degree_1, fe_degree_2) + 1;
do_test<dim, fe_degree_1, fe_degree_2, n_q_points_1d, double>(dh_ptrs);
}
}
const std::vector<unsigned int> n_coefficients_per_direction(
fe_collection.size(), max_degree);
- fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
- n_coefficients_per_direction, fe_collection, fourier_q_collection);
+ fourier =
+ std::make_unique<FESeries::Fourier<dim>>(n_coefficients_per_direction,
+ fe_collection,
+ fourier_q_collection);
}
const std::vector<unsigned int> n_coefficients_per_direction(
fe_collection.size(), max_degree);
- fourier = std_cxx14::make_unique<FESeries::Fourier<dim>>(
- n_coefficients_per_direction, fe_collection, fourier_q_collection);
+ fourier =
+ std::make_unique<FESeries::Fourier<dim>>(n_coefficients_per_direction,
+ fe_collection,
+ fourier_q_collection);
}
tr.execute_coarsening_and_refinement();
*/
- auto fe_scalar = std_cxx14::make_unique<dealii::FE_Q<dim>>(1);
- auto fe = std_cxx14::make_unique<dealii::FESystem<dim>>(*fe_scalar, 1);
+ auto fe_scalar = std::make_unique<dealii::FE_Q<dim>>(1);
+ auto fe = std::make_unique<dealii::FESystem<dim>>(*fe_scalar, 1);
dealii::DoFHandler<dim> dofhandler(tria);
dofhandler.distribute_dofs(*fe);
tr.execute_coarsening_and_refinement();
*/
- auto fe_scalar = std_cxx14::make_unique<dealii::FE_Q<dim>>(1);
- auto fe = std_cxx14::make_unique<dealii::FESystem<dim>>(*fe_scalar, dim);
+ auto fe_scalar = std::make_unique<dealii::FE_Q<dim>>(1);
+ auto fe = std::make_unique<dealii::FESystem<dim>>(*fe_scalar, dim);
dealii::DoFHandler<dim> dofhandler(tria);
dofhandler.distribute_dofs(*fe);
// create a pattern and let it
// output its description
std::vector<std::unique_ptr<Patterns::PatternBase>> ps;
- ps.push_back(std
_cxx14::make_unique<Patterns::Integer>());
- ps.push_back(std
_cxx14::make_unique<Patterns::Double>());
- ps.push_back(std
_cxx14::make_unique<Patterns::Anything>());
+ ps.push_back(std::make_unique<Patterns::Integer>());
+ ps.push_back(std::make_unique<Patterns::Double>());
+ ps.push_back(std::make_unique<Patterns::Anything>());
Patterns::Tuple pattern(ps, ";");
const std::string desc = pattern.description();
// create a pattern and match a string
std::vector<std::unique_ptr<Patterns::PatternBase>> ps;
- ps.push_back(std
_cxx14::make_unique<Patterns::Integer>());
- ps.push_back(std
_cxx14::make_unique<Patterns::Double>());
- ps.push_back(std
_cxx14::make_unique<Patterns::Anything>());
+ ps.push_back(std::make_unique<Patterns::Integer>());
+ ps.push_back(std::make_unique<Patterns::Double>());
+ ps.push_back(std::make_unique<Patterns::Anything>());
Patterns::Tuple pattern(ps, ";");
const std::string desc = pattern.description();
{
vec_len = 1;
max_vec_len = vec_len;
- colnums = std_cxx14::make_unique<size_type[]>(max_vec_len);
+ colnums = std::make_unique<size_type[]>(max_vec_len);
}
max_row_length =
if (rows > max_dim)
{
max_dim = rows;
- rowstart = std_cxx14::make_unique<std::size_t[]>(max_dim + 1);
+ rowstart = std::make_unique<std::size_t[]>(max_dim + 1);
}
// allocate memory for the column numbers if necessary
if (vec_len > max_vec_len)
{
max_vec_len = vec_len;
- colnums = std_cxx14::make_unique<size_type[]>(max_vec_len);
+ colnums = std::make_unique<size_type[]>(max_vec_len);
}
// set the rowstart array
projects / dealii.git / commitdiff