G2.add (wave_speed, tmp);
system_rhs_p = G1;
- system_rhs_p.add(time_step * theta , G2);
+ system_rhs_p.add(time_step * theta, G2);
solve_p ();
mpi_communicator (MPI_COMM_WORLD),
triangulation (mpi_communicator),
fe (FE_Q<dim>(degree+1), dim,
- FE_Q<dim>(degree) , 1),
+ FE_Q<dim>(degree), 1),
dof_handler (triangulation),
pcout (std::cout,
Utilities::MPI::this_mpi_process(mpi_communicator) == 0),
bool interface_intersects_cell (const typename Triangulation<dim>::cell_iterator &cell) const;
std::pair<unsigned int, Quadrature<dim> > compute_quadrature(const Quadrature<dim> &plain_quadrature, const typename hp::DoFHandler<dim>::active_cell_iterator &cell, const std::vector<double> &level_set_values);
void append_quadrature(const Quadrature<dim> &plain_quadrature,
- const std::vector<Point<dim> > &v ,
+ const std::vector<Point<dim> > &v,
std::vector<Point<dim> > &xfem_points,
std::vector<double> &xfem_weights);
template <int rank_1, int rank_2, int dim, typename Number>
inline
void contract (Tensor<rank_1 + rank_2 - 2, dim, Number> &dest,
- const Tensor<rank_1 ,dim, Number> &src1,
- const Tensor<rank_2 ,dim, Number> &src2) DEAL_II_DEPRECATED;
+ const Tensor<rank_1, dim, Number> &src1,
+ const Tensor<rank_2, dim, Number> &src2) DEAL_II_DEPRECATED;
/**
* Contract a tensor of rank 1 with a tensor of rank 1 and return the result.
template <int rank_1, int rank_2, int dim, typename Number>
inline
void contract (Tensor<rank_1 + rank_2 - 2, dim, Number> &dest,
- const Tensor<rank_1 ,dim, Number> &src1,
- const Tensor<rank_2 ,dim, Number> &src2)
+ const Tensor<rank_1, dim, Number> &src1,
+ const Tensor<rank_2, dim, Number> &src2)
{
TensorAccessors::internal::ReorderedIndexView<0, rank_2, const Tensor<rank_2, dim, Number> >
reordered = TensorAccessors::reordered_index_view<0, rank_2>(src2);
static
unsigned int
n_active_fe_indices (const dealii::hp::DoFHandler<2,spacedim> &dof_handler,
- const unsigned int ,
+ const unsigned int,
const unsigned int obj_index,
const dealii::internal::int2type<1> &)
{
static
unsigned int
n_active_fe_indices (const dealii::hp::DoFHandler<3,spacedim> &dof_handler,
- const unsigned int ,
+ const unsigned int,
const unsigned int obj_index,
const dealii::internal::int2type<2> &)
{
inline
DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::
DoFAccessor (const Triangulation<1,spacedim> *,
- const int ,
- const int ,
+ const int,
+ const int,
const DoFHandlerType<1,spacedim> *)
:
dof_handler(nullptr)
void
FE_PolyFace<PolynomialType,dim,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
- const CellSimilarity::Similarity ,
+ const CellSimilarity::Similarity,
const Quadrature<dim> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
* Collection of manifold objects. We store only objects, which are not of
* type FlatManifold.
*/
- std::map<types::manifold_id, SmartPointer<const Manifold<dim,spacedim> , Triangulation<dim, spacedim> > > manifold;
+ std::map<types::manifold_id, SmartPointer<const Manifold<dim,spacedim>, Triangulation<dim, spacedim> > > manifold;
/**
template <int structdim, int dim, int spacedim>
InvalidAccessor<structdim, dim, spacedim>::
InvalidAccessor (const Triangulation<dim,spacedim> *,
- const int ,
- const int ,
+ const int,
+ const int,
const AccessorData *)
{
Assert (false,
{
const size_type col = *it;
- const std::pair<size_type , size_type>
+ const std::pair<size_type, size_type>
col_index = this->column_indices.global_to_local(col);
const size_type local_index = counter_within_block[col_index.first]++;
// where we should start reading out
// data. Now let's write the data into
// the individual blocks!
- const std::pair<size_type , size_type>
+ const std::pair<size_type, size_type>
row_index = this->row_indices.global_to_local (row);
for (size_type block_col=0; block_col<n_block_cols(); ++block_col)
{
// if you get an error here, are
// you sure you called
// <tt>collect_sizes()</tt> before?
- const std::pair<size_type , size_type>
+ const std::pair<size_type, size_type>
row_index = row_indices.global_to_local (i),
col_index = column_indices.global_to_local (j);
return sub_objects[row_index.first][col_index.first]->exists (row_index.second,
BlockSparsityPatternBase<SparsityPatternType>::
row_length (const size_type row) const
{
- const std::pair<size_type , size_type>
+ const std::pair<size_type, size_type>
row_index = row_indices.global_to_local (row);
unsigned int c = 0;
const unsigned int index) const
{
// .first= ith block, .second = jth row in that block
- const std::pair<size_type ,size_type >
+ const std::pair<size_type,size_type >
row_index = row_indices.global_to_local (row);
Assert(index<row_length(row), ExcIndexRange(index, 0, row_length(row)));
const size_type n_cols,
const size_type *col_indices,
const number2 *values,
- const bool ,
+ const bool,
const bool )
{
for (size_type i=0; i<n_cols; ++i)
template <typename Number>
void Vector<Number>::import(const ReadWriteVector<Number> &,
- VectorOperation::values ,
+ VectorOperation::values,
std::shared_ptr<const CommunicationPatternBase>)
{
AssertThrow(false, ExcMessage("This function is not implemented."));
*/
static void
compute_eigs_and_cond(
- const FullMatrix<double> &H_orig ,
+ const FullMatrix<double> &H_orig,
const unsigned int dim,
const boost::signals2::signal<void (const std::vector<std::complex<double> > &)> &eigenvalues_signal,
const boost::signals2::signal<void (const FullMatrix<double> &)> &hessenberg_signal,
VectorizedArray<Number> *gradients_quad[][dim],
VectorizedArray<Number> *hessians_quad[][(dim*(dim+1))/2],
VectorizedArray<Number> *,
- const bool ,
+ const bool,
const bool evaluate_gradients,
const bool evaluate_hessians)
{
{};
tbb::task *execute ()
{
- tbb::empty_task *root = new( tbb::task::allocate_root() )
+ tbb::empty_task *root = new ( tbb::task::allocate_root() )
tbb::empty_task;
unsigned int evens = task_info.partition_evens[partition];
unsigned int odds = task_info.partition_odds[partition];
root->set_ref_count(evens+1);
for (unsigned int j=0; j<evens; j++)
{
- worker[j] = new(root->allocate_child())
+ worker[j] = new (root->allocate_child())
CellWork<Worker>(function, task_info.
partition_color_blocks_row_index[partition]+2*j,
task_info, false);
if (j>0)
{
worker[j]->set_ref_count(2);
- blocked_worker[j-1]->dummy = new(worker[j]->allocate_child())
+ blocked_worker[j-1]->dummy = new (worker[j]->allocate_child())
tbb::empty_task;
worker[j-1]->spawn(*blocked_worker[j-1]);
}
worker[j]->set_ref_count(1);
if (j<evens-1)
{
- blocked_worker[j] = new(worker[j]->allocate_child())
+ blocked_worker[j] = new (worker[j]->allocate_child())
CellWork<Worker>(function, task_info.
partition_color_blocks_row_index
[partition] + 2*j+1, task_info, true);
{
if (odds==evens)
{
- worker[evens] = new(worker[j]->allocate_child())
+ worker[evens] = new (worker[j]->allocate_child())
CellWork<Worker>(function, task_info.
partition_color_blocks_row_index[partition]+2*j+1,
task_info, false);
}
else
{
- tbb::empty_task *child = new(worker[j]->allocate_child())
+ tbb::empty_task *child = new (worker[j]->allocate_child())
tbb::empty_task();
worker[j]->spawn(*child);
}
if (task_info.use_partition_partition == true)
{
- tbb::empty_task *root = new( tbb::task::allocate_root() )
+ tbb::empty_task *root = new ( tbb::task::allocate_root() )
tbb::empty_task;
unsigned int evens = task_info.evens;
unsigned int odds = task_info.odds;
std::vector<internal::partition::PartitionWork<Worker>*>
blocked_worker(n_blocked_workers);
internal::MPIComCompress<OutVector> *worker_compr =
- new(root->allocate_child())
+ new (root->allocate_child())
internal::MPIComCompress<OutVector>(dst);
worker_compr->set_ref_count(1);
for (unsigned int j=0; j<evens; j++)
{
if (j>0)
{
- worker[j] = new(root->allocate_child())
+ worker[j] = new (root->allocate_child())
internal::partition::PartitionWork<Worker>
(func,2*j,task_info,false);
worker[j]->set_ref_count(2);
- blocked_worker[j-1]->dummy = new(worker[j]->allocate_child())
+ blocked_worker[j-1]->dummy = new (worker[j]->allocate_child())
tbb::empty_task;
if (j>1)
worker[j-1]->spawn(*blocked_worker[j-1]);
}
else
{
- worker[j] = new(worker_compr->allocate_child())
+ worker[j] = new (worker_compr->allocate_child())
internal::partition::PartitionWork<Worker>
(func,2*j,task_info,false);
worker[j]->set_ref_count(2);
}
if (j<evens-1)
{
- blocked_worker[j] = new(worker[j]->allocate_child())
+ blocked_worker[j] = new (worker[j]->allocate_child())
internal::partition::PartitionWork<Worker>
(func,2*j+1,task_info,true);
}
{
if (odds==evens)
{
- worker[evens] = new(worker[j]->allocate_child())
+ worker[evens] = new (worker[j]->allocate_child())
internal::partition::PartitionWork<Worker>
(func,2*j+1,task_info,false);
worker[j]->spawn(*worker[evens]);
}
else
{
- tbb::empty_task *child = new(worker[j]->allocate_child())
+ tbb::empty_task *child = new (worker[j]->allocate_child())
tbb::empty_task();
worker[j]->spawn(*child);
}
// tree of partitions
if (odds > 0)
{
- tbb::empty_task *root = new( tbb::task::allocate_root() ) tbb::empty_task;
+ tbb::empty_task *root = new ( tbb::task::allocate_root() ) tbb::empty_task;
root->set_ref_count(evens+1);
unsigned int n_blocked_workers = odds-(odds+evens+1)%2;
unsigned int n_workers = task_info.partition_color_blocks_data.size()-1-
unsigned int worker_index = 0, slice_index = 0;
unsigned int spawn_index = 0;
int spawn_index_child = -2;
- internal::MPIComCompress<OutVector> *worker_compr = new(root->allocate_child())
+ internal::MPIComCompress<OutVector> *worker_compr = new (root->allocate_child())
internal::MPIComCompress<OutVector>(dst);
worker_compr->set_ref_count(1);
for (unsigned int part=0;
{
const unsigned int spawn_index_new = worker_index;
if (part == 0)
- worker[worker_index] = new(worker_compr->allocate_child())
+ worker[worker_index] = new (worker_compr->allocate_child())
internal::color::PartitionWork<Worker>(func,slice_index,task_info,false);
else
- worker[worker_index] = new(root->allocate_child())
+ worker[worker_index] = new (root->allocate_child())
internal::color::PartitionWork<Worker>(func,slice_index,task_info,false);
slice_index++;
for (; slice_index<task_info.partition_color_blocks_row_index[part+1];
{
if (part<task_info.partition_color_blocks_row_index.size()-2)
{
- blocked_worker[part/2] = new(worker[worker_index-1]->allocate_child())
+ blocked_worker[part/2] = new (worker[worker_index-1]->allocate_child())
internal::color::PartitionWork<Worker>(func,slice_index,task_info,true);
slice_index++;
if (slice_index<
task_info.partition_color_blocks_row_index[part+1])
{
blocked_worker[part/2]->set_ref_count(1);
- worker[worker_index] = new(blocked_worker[part/2]->allocate_child())
+ worker[worker_index] = new (blocked_worker[part/2]->allocate_child())
internal::color::PartitionWork<Worker>(func,slice_index,task_info,false);
slice_index++;
}
- template <typename MatrixType ,typename number>
+ template <typename MatrixType,typename number>
template <class DOFINFO>
inline void
MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize_info
}
- template <typename MatrixType ,typename number>
+ template <typename MatrixType,typename number>
template <class DOFINFO>
inline void
MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize_info
bool real_part_bigger_than(const std::complex<number1> a,
const std::complex<number2> &b)
{
- Assert(std::abs(a.imag()) <= 1e-15*std::abs(a) , ExcInternalError());
- Assert(std::abs(b.imag()) <= 1e-15*std::abs(b) , ExcInternalError());
+ Assert(std::abs(a.imag()) <= 1e-15*std::abs(a), ExcInternalError());
+ Assert(std::abs(b.imag()) <= 1e-15*std::abs(b), ExcInternalError());
return a.real() > b.real();
}
fe_values.reinit (cell, face + cell->active_fe_index ()
* GeometryInfo<dim>::faces_per_cell);
- const std::vector<DerivativeForm<1,dim ,spacedim> > &
+ const std::vector<DerivativeForm<1,dim,spacedim> > &
jacobians = fe_values.get_present_fe_values ().get_jacobians ();
fe_face_values.reinit (cell, face);
{
const double rotation[2][2]
= {{
- std::cos(angle) , -std::sin(angle)
+ std::cos(angle), -std::sin(angle)
},
{
- std::sin(angle) , std::cos(angle)
+ std::sin(angle), std::cos(angle)
}
};
return Tensor<2,2> (rotation);
inline
void compute_tensor_index(const unsigned int n,
- const unsigned int ,
- const unsigned int ,
+ const unsigned int,
+ const unsigned int,
unsigned int (&indices)[1])
{
indices[0] = n;
inline
void compute_tensor_index(const unsigned int n,
const unsigned int n_pols_0,
- const unsigned int ,
+ const unsigned int,
unsigned int (&indices)[2])
{
indices[0] = n % n_pols_0;
template <>
double
-TensorProductPolynomialsBubbles<0>::compute_value (const unsigned int ,
+TensorProductPolynomialsBubbles<0>::compute_value (const unsigned int,
const Point<0> &) const
{
Assert (false, ExcNotImplemented());
template <>
double
-TensorProductPolynomialsConst<0>::compute_value (const unsigned int ,
+TensorProductPolynomialsConst<0>::compute_value (const unsigned int,
const Point<0> &) const
{
Assert (false, ExcNotImplemented());
void
DoFTools::make_zero_boundary_constraints
(const DoFHandler<deal_II_dimension> &,
- const types::boundary_id ,
+ const types::boundary_id,
ConstraintMatrix &,
const ComponentMask &);
void
DoFTools::make_zero_boundary_constraints
(const hp::DoFHandler<deal_II_dimension> &,
- const types::boundary_id ,
+ const types::boundary_id,
ConstraintMatrix &,
const ComponentMask &);
:
FiniteElementData<dim> (fe_data),
adjust_quad_dof_index_for_face_orientation_table (dim == 3 ?
- this->dofs_per_quad : 0 ,
+ this->dofs_per_quad : 0,
dim==3 ? 8 : 0),
adjust_line_dof_index_for_line_orientation_table (dim == 3 ?
this->dofs_per_line : 0),
void
FE_DGP<dim,spacedim>::
get_subface_interpolation_matrix (const FiniteElement<dim,spacedim> &x_source_fe,
- const unsigned int ,
+ const unsigned int,
FullMatrix<double> &interpolation_matrix) const
{
// this is only implemented, if the source FE is also a DGP element. in that
void
FE_DGPMonomial<dim>::
get_subface_interpolation_matrix (const FiniteElement<dim> &x_source_fe,
- const unsigned int ,
+ const unsigned int,
FullMatrix<double> &interpolation_matrix) const
{
// this is only implemented, if the source
void
FE_DGPNonparametric<dim,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
- const CellSimilarity::Similarity ,
+ const CellSimilarity::Similarity,
const Quadrature<dim> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
void
FE_DGPNonparametric<dim,spacedim>::
fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
- const unsigned int ,
+ const unsigned int,
const Quadrature<dim-1> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
void
FE_DGPNonparametric<dim,spacedim>::
fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
- const unsigned int ,
- const unsigned int ,
+ const unsigned int,
+ const unsigned int,
const Quadrature<dim-1> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
void
FE_DGPNonparametric<dim,spacedim>::
get_subface_interpolation_matrix (const FiniteElement<dim,spacedim> &x_source_fe,
- const unsigned int ,
+ const unsigned int,
FullMatrix<double> &interpolation_matrix) const
{
// this is only implemented, if the source
void
FE_DGQ<dim, spacedim>::
get_subface_interpolation_matrix (const FiniteElement<dim, spacedim> &x_source_fe,
- const unsigned int ,
+ const unsigned int,
FullMatrix<double> &interpolation_matrix) const
{
// this is only implemented, if the source
void
FE_FaceQ<1,spacedim>::
fill_fe_values(const typename Triangulation<1,spacedim>::cell_iterator &,
- const CellSimilarity::Similarity ,
+ const CellSimilarity::Similarity,
const Quadrature<1> &,
const Mapping<1,spacedim> &,
const typename Mapping<1,spacedim>::InternalDataBase &,
void
FE_FaceQ<1,spacedim>::
fill_fe_subface_values (const typename Triangulation<1,spacedim>::cell_iterator &,
- const unsigned int ,
- const unsigned int ,
+ const unsigned int,
+ const unsigned int,
const Quadrature<0> &,
const Mapping<1,spacedim> &,
const typename Mapping<1,spacedim>::InternalDataBase &,
subface);
for (unsigned int j = 0; j < source_fe->dofs_per_face; ++j)
- mass (k , j) = source_fe->poly_space.compute_value(j, p);
+ mass (k, j) = source_fe->poly_space.compute_value(j, p);
}
Householder<double> H(mass);
void
FE_Nothing<dim,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
- const CellSimilarity::Similarity ,
+ const CellSimilarity::Similarity,
const Quadrature<dim> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
void
FE_Nothing<dim,spacedim>::
fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
- const unsigned int ,
+ const unsigned int,
const Quadrature<dim-1> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
void
FE_Nothing<dim,spacedim>::
fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator &,
- const unsigned int ,
- const unsigned int ,
+ const unsigned int,
+ const unsigned int,
const Quadrature<dim-1> &,
const Mapping<dim,spacedim> &,
const typename Mapping<dim,spacedim>::InternalDataBase &,
void
FE_P1NC::fill_fe_values (const Triangulation<2,2>::cell_iterator &cell,
- const CellSimilarity::Similarity ,
+ const CellSimilarity::Similarity,
const Quadrature<2> &,
const Mapping<2,2> &,
const Mapping<2,2>::InternalDataBase &,
*/
void
get_face_sign_change_rt (const Triangulation<1>::cell_iterator &,
- const unsigned int ,
+ const unsigned int,
std::vector<double> &face_sign)
{
// nothing to do in 1d
const unsigned int q_dofs_per_cell = Utilities::fixed_power<dim>(q_degree+1);
Assert(q_dofs_per_cell == this->dofs_per_cell ||
q_dofs_per_cell+1 == this->dofs_per_cell ||
- q_dofs_per_cell+dim == this->dofs_per_cell , ExcInternalError());
+ q_dofs_per_cell+dim == this->dofs_per_cell, ExcInternalError());
{
std::vector<unsigned int> renumber(q_dofs_per_cell);
FETools::Compositing::compute_nonzero_components(&fe1, n1,
&fe2, n2,
&fe3, n3,
- &fe4 ,n4)),
+ &fe4, n4)),
base_elements((n1>0)+(n2>0)+(n3>0)+(n4>0))
{
std::vector<const FiniteElement<dim,spacedim>*> fes;
FETools::Compositing::compute_nonzero_components(&fe1, n1,
&fe2, n2,
&fe3, n3,
- &fe4 ,n4,
+ &fe4, n4,
&fe5, n5)),
base_elements((n1>0)+(n2>0)+(n3>0)+(n4>0)+(n5>0))
{
template
void compute_block_renumbering (
- const FiniteElement<deal_II_dimension,deal_II_space_dimension> & ,
+ const FiniteElement<deal_II_dimension,deal_II_space_dimension> &,
std::vector<types::global_dof_index> &, std::vector<types::global_dof_index> &, bool);
template
template
void compute_component_wise(
- const FiniteElement<deal_II_dimension> & ,
+ const FiniteElement<deal_II_dimension> &,
std::vector<unsigned int> &, std::vector<std::vector<unsigned int> > &);
template
compute_projection_from_face_quadrature_points_matrix (const FiniteElement<deal_II_dimension> &,
const Quadrature<deal_II_dimension-1> &,
const Quadrature<deal_II_dimension-1> &,
- const DoFHandler<deal_II_dimension>::active_cell_iterator & ,
+ const DoFHandler<deal_II_dimension>::active_cell_iterator &,
unsigned int,
FullMatrix<double> &);
#endif
static_cast<const Type *>(present_cell.get())->~Type();
// then construct a new object in-place
- new(const_cast<void *>(static_cast<const void *>(present_cell.get()))) Type(new_cell);
+ new (const_cast<void *>(static_cast<const void *>(present_cell.get()))) Type(new_cell);
}
else
// if the types don't match, there is nothing we can do here
template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
-transform (const ArrayView<const DerivativeForm<1, dim ,spacedim> > &input,
+transform (const ArrayView<const DerivativeForm<1, dim, spacedim> > &input,
const MappingType mapping_type,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2,spacedim> > &output) const
void
MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
transform (const ArrayView<const Tensor<2, dim> > &input,
- const MappingType ,
+ const MappingType,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2,spacedim> > &output) const
{
template<int dim, int spacedim>
void
MappingQ<dim,spacedim>::
-transform (const ArrayView<const DerivativeForm<1, dim ,spacedim> > &input,
+transform (const ArrayView<const DerivativeForm<1, dim, spacedim> > &input,
const MappingType mapping_type,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<2,spacedim> > &output) const
template<int dim, int spacedim>
void
MappingQ<dim,spacedim>::
-transform (const ArrayView<const DerivativeForm<2, dim ,spacedim> > &input,
+transform (const ArrayView<const DerivativeForm<2, dim,spacedim> > &input,
const MappingType mapping_type,
const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
const ArrayView<Tensor<3,spacedim> > &output) const
CellSimilarity::Similarity
MappingQ1Eulerian<dim,VectorType,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
- const CellSimilarity::Similarity ,
+ const CellSimilarity::Similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
CellSimilarity::Similarity
MappingQEulerian<dim,VectorType,spacedim>::
fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
- const CellSimilarity::Similarity ,
+ const CellSimilarity::Similarity,
const Quadrature<dim> &quadrature,
const typename Mapping<dim,spacedim>::InternalDataBase &internal_data,
internal::FEValues::MappingRelatedData<dim,spacedim> &output_data) const
const Point<1> &,
const double,
const double,
- const unsigned int ,
+ const unsigned int,
const bool)
{
Assert (false, ExcNotImplemented());
const double,
const double,
const double,
- const unsigned int ,
+ const unsigned int,
const unsigned int )
{
Assert (false, ExcNotImplemented());
const Point<1> &,
const double,
const double,
- const unsigned int ,
+ const unsigned int,
const bool)
{
Assert (false, ExcNotImplemented());
const Point<1> &,
const double,
const double,
- const unsigned int ,
+ const unsigned int,
const bool)
{
Assert (false, ExcNotImplemented());
const Point<3> vertices[20] =
{
- Point<3>(left, left , -len/2.),
- Point<3>(rl2, left , -len/2.),
- Point<3>(rl2, rl2 , -len/2.),
- Point<3>(left, rl2 , -len/2.),
- Point<3>(right,left , -len/2.),
- Point<3>(right,rl2 , -len/2.),
+ Point<3>(left, left, -len/2.),
+ Point<3>(rl2, left, -len/2.),
+ Point<3>(rl2, rl2, -len/2.),
+ Point<3>(left, rl2, -len/2.),
+ Point<3>(right,left, -len/2.),
+ Point<3>(right,rl2, -len/2.),
Point<3>(rl2, right, -len/2.),
Point<3>(left, right, -len/2.),
Point<3>(right,right, -len/2.),
- Point<3>(rl2, left , -len/2.),
- Point<3>(left, left , len/2.),
- Point<3>(rl2, left , len/2.),
- Point<3>(rl2, rl2 , len/2.),
- Point<3>(left, rl2 , len/2.),
- Point<3>(right,left , len/2.),
- Point<3>(right,rl2 , len/2.),
+ Point<3>(rl2, left, -len/2.),
+ Point<3>(left, left, len/2.),
+ Point<3>(rl2, left, len/2.),
+ Point<3>(rl2, rl2, len/2.),
+ Point<3>(left, rl2, len/2.),
+ Point<3>(right,left, len/2.),
+ Point<3>(right,rl2, len/2.),
Point<3>(rl2, right, len/2.),
Point<3>(left, right, len/2.),
Point<3>(right,right, len/2.),
- Point<3>(rl2, left , len/2.)
+ Point<3>(rl2, left, len/2.)
};
const int cell_vertices[4][8] = { { 0,1,3,2, 10, 11, 13, 12 },
{ 9,4,2,5, 19,14, 12, 15 },
21,20,22,
17,16,18,
25,24,26,
- 5 , 4, 6,
- 1 , 0, 2,
- 9 , 8,10,
+ 5, 4, 6,
+ 1, 0, 2,
+ 9, 8,10,
37,36,38,
33,32,34,
41,40,42
vertices.push_back (center+Point<3>( a, a, 0)); //1
vertices.push_back (center+Point<3>( b, b, 0)); //2
vertices.push_back (center+Point<3>( 0, outer_radius, 0)); //3
- vertices.push_back (center+Point<3>( 0, a , a)); //4
- vertices.push_back (center+Point<3>( c, c , h)); //5
- vertices.push_back (center+Point<3>( d, d , e)); //6
- vertices.push_back (center+Point<3>( 0, b , b)); //7
- vertices.push_back (center+Point<3>( inner_radius, 0 , 0)); //8
- vertices.push_back (center+Point<3>( outer_radius, 0 , 0)); //9
- vertices.push_back (center+Point<3>( a, 0 , a)); //10
- vertices.push_back (center+Point<3>( b, 0 , b)); //11
- vertices.push_back (center+Point<3>( 0, 0 , inner_radius)); //12
- vertices.push_back (center+Point<3>( 0, 0 , outer_radius)); //13
+ vertices.push_back (center+Point<3>( 0, a, a)); //4
+ vertices.push_back (center+Point<3>( c, c, h)); //5
+ vertices.push_back (center+Point<3>( d, d, e)); //6
+ vertices.push_back (center+Point<3>( 0, b, b)); //7
+ vertices.push_back (center+Point<3>( inner_radius, 0, 0)); //8
+ vertices.push_back (center+Point<3>( outer_radius, 0, 0)); //9
+ vertices.push_back (center+Point<3>( a, 0, a)); //10
+ vertices.push_back (center+Point<3>( b, 0, b)); //11
+ vertices.push_back (center+Point<3>( 0, 0, inner_radius)); //12
+ vertices.push_back (center+Point<3>( 0, 0, outer_radius)); //13
const int cell_vertices[3][8] =
{
{
template void
- hyper_sphere< 1 , 2 > (Triangulation< 1 , 2> &,
- const Point<2> ¢er,
- const double radius);
+ hyper_sphere< 1, 2 > (Triangulation< 1, 2> &,
+ const Point<2> ¢er,
+ const double radius);
template void
- hyper_sphere< 2 , 3 > (Triangulation< 2 , 3> &,
- const Point<3> ¢er,
- const double radius);
+ hyper_sphere< 2, 3 > (Triangulation< 2, 3> &,
+ const Point<3> ¢er,
+ const double radius);
}
#include "grid_generator.inst"
// property somewhat sloppy as "face_flip"
// (always: face_orientation = true, face_rotation = false)
- static const MATCH_T m_tff = {{ 0 , 1 }};
+ static const MATCH_T m_tff = {{ 0, 1 }};
if (matching == m_tff) return 1; // [true ,false,false]
- static const MATCH_T m_ttf = {{ 1 , 0 }};
+ static const MATCH_T m_ttf = {{ 1, 0 }};
if (matching == m_ttf) return 3; // [true ,true ,false]
Assert(false, ExcInternalError());
// what follows is dead code, but it avoids warnings about the lack
// as well as the actual implementation in source/grid/tria.cc
// for more details...
- static const MATCH_T m_tff = {{ 0 , 1 , 2 , 3 }};
+ static const MATCH_T m_tff = {{ 0, 1, 2, 3 }};
if (matching == m_tff) return 1; // [true ,false,false]
- static const MATCH_T m_tft = {{ 1 , 3 , 0 , 2 }};
+ static const MATCH_T m_tft = {{ 1, 3, 0, 2 }};
if (matching == m_tft) return 5; // [true ,false,true ]
- static const MATCH_T m_ttf = {{ 3 , 2 , 1 , 0 }};
+ static const MATCH_T m_ttf = {{ 3, 2, 1, 0 }};
if (matching == m_ttf) return 3; // [true ,true ,false]
- static const MATCH_T m_ttt = {{ 2 , 0 , 3 , 1 }};
+ static const MATCH_T m_ttt = {{ 2, 0, 3, 1 }};
if (matching == m_ttt) return 7; // [true ,true ,true ]
- static const MATCH_T m_fff = {{ 0 , 2 , 1 , 3 }};
+ static const MATCH_T m_fff = {{ 0, 2, 1, 3 }};
if (matching == m_fff) return 0; // [false,false,false]
- static const MATCH_T m_fft = {{ 2 , 3 , 0 , 1 }};
+ static const MATCH_T m_fft = {{ 2, 3, 0, 1 }};
if (matching == m_fft) return 4; // [false,false,true ]
- static const MATCH_T m_ftf = {{ 3 , 1 , 2 , 0 }};
+ static const MATCH_T m_ftf = {{ 3, 1, 2, 0 }};
if (matching == m_ftf) return 2; // [false,true ,false]
- static const MATCH_T m_ftt = {{ 1 , 0 , 3 , 2 }};
+ static const MATCH_T m_ftt = {{ 1, 0, 3, 2 }};
if (matching == m_ftt) return 6; // [false,true ,true ]
Assert(false, ExcInternalError());
// what follows is dead code, but it avoids warnings about the lack
template
void
rotate<deal_II_dimension> (const double,
- const unsigned int ,
+ const unsigned int,
Triangulation<deal_II_dimension, deal_II_space_dimension> &);
#endif
faces.reset (new internal::Triangulation::TriaFaces<dim>(*other_tria.faces));
typename std::map<types::manifold_id,
- SmartPointer<const Manifold<dim,spacedim> , Triangulation<dim, spacedim> > >::const_iterator
+ SmartPointer<const Manifold<dim,spacedim>, Triangulation<dim, spacedim> > >::const_iterator
bdry_iterator = other_tria.manifold.begin();
for (; bdry_iterator != other_tria.manifold.end() ; ++bdry_iterator)
manifold[bdry_iterator->first] = bdry_iterator->second;
}
case 2:
{
- bool values [][4]= {{false,true ,true , false},
- {true ,false,false, true },
- {true ,false,false, true },
- {false,true ,true , false}
+ bool values [][4]= {{false,true,true, false},
+ {true,false,false, true },
+ {true,false,false, true },
+ {false,true,true, false}
};
for (unsigned int i=0; i< GeometryInfo< dim >::faces_per_cell; ++i)
for (unsigned int j=0; j< GeometryInfo< dim >::faces_per_cell; ++j)
MATRIX_FUNCTIONS(PETScWrappers::MPI::SparseMatrix);
BLOCK_MATRIX_FUNCTIONS(PETScWrappers::MPI::BlockSparseMatrix);
MATRIX_VECTOR_FUNCTIONS(PETScWrappers::MPI::SparseMatrix, PETScWrappers::MPI::Vector);
-BLOCK_MATRIX_VECTOR_FUNCTIONS(PETScWrappers::MPI::BlockSparseMatrix ,PETScWrappers::MPI::BlockVector);
+BLOCK_MATRIX_VECTOR_FUNCTIONS(PETScWrappers::MPI::BlockSparseMatrix,PETScWrappers::MPI::BlockVector);
#endif
#ifdef DEAL_II_WITH_TRILINOS
SparseMatrix::do_reinit (const SparsityPattern &,
const std::vector<size_type> &,
const std::vector<size_type> &,
- const unsigned int ,
+ const unsigned int,
const bool);
template void
SparseMatrix::do_reinit (const DynamicSparsityPattern &,
const std::vector<size_type> &,
const std::vector<size_type> &,
- const unsigned int ,
+ const unsigned int,
const bool);
template void
AssertThrow (ierr == 0, ExcPETScError(ierr));
#if DEAL_II_PETSC_VERSION_LT(3, 5, 0)
- ierr = PCSetOperators(pc , matrix, matrix, SAME_PRECONDITIONER);
+ ierr = PCSetOperators(pc, matrix, matrix, SAME_PRECONDITIONER);
#else
- ierr = PCSetOperators(pc , matrix, matrix);
+ ierr = PCSetOperators(pc, matrix, matrix);
#endif
AssertThrow (ierr == 0, ExcPETScError(ierr));
}
template void SparsityPattern::copy_from<float> (const FullMatrix<float> &);
template void SparsityPattern::copy_from<double> (const FullMatrix<double> &);
-template void SparsityPattern::add_entries<const SparsityPattern::size_type *> (const size_type ,
+template void SparsityPattern::add_entries<const SparsityPattern::size_type *> (const size_type,
const size_type *,
const size_type *,
const bool);
else Btmp = B_;
// perform matrix-matrix product
- ML_matmat_mult(A_, Btmp , &Ctmp);
+ ML_matmat_mult(A_, Btmp, &Ctmp);
// release temporary structures we needed
// for multiplication
Vector<float> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id,
const KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::Strategy);
Vector<float> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id,
const KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::Strategy);
std::vector<Vector<float> *> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id,
const KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::Strategy);
std::vector<Vector<float> *> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id,
const KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::Strategy);
Vector<float> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id,
const KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::Strategy);
Vector<float> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id,
const KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::Strategy);
std::vector<Vector<float> *> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id,
const KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::Strategy);
std::vector<Vector<float> *> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id,
const KellyErrorEstimator<deal_II_dimension, deal_II_space_dimension>::Strategy);
Vector<float> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id);
Vector<float> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id);
std::vector<Vector<float> *> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id);
std::vector<Vector<float> *> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id);
Vector<float> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id);
Vector<float> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id);
std::vector<Vector<float> *> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id);
std::vector<Vector<float> *> &,
const ComponentMask &,
const Function<deal_II_space_dimension> *,
- const unsigned int ,
+ const unsigned int,
const types::subdomain_id,
const types::material_id);
gp_Pnt PIn(0.0,0.0,0.0);
gp_Pnt PFin(0.0,0.0,0.0);
gp_Pnt PMid(0.0,0.0,0.0);
- TopExp_Explorer edgeExplorer(edges , TopAbs_EDGE);
+ TopExp_Explorer edgeExplorer(edges, TopAbs_EDGE);
TopoDS_Edge edge;
while (edgeExplorer.More())
{
t[2] = 3.69258;
AssertThrow (7*t == 7.0 * t, ExcInternalError());
AssertThrow (t*7 == t * 7.0, ExcInternalError());
- AssertThrow (t*7 == 7*t , ExcInternalError());
+ AssertThrow (t*7 == 7*t, ExcInternalError());
AssertThrow ((t*7 - (t+t+t+t+t+t+t)).norm() < 1e-12, ExcInternalError());
}
t[1][1] = 3.35792;
AssertThrow (7*t == 7.0 * t, ExcInternalError());
AssertThrow (t*7 == t * 7.0, ExcInternalError());
- AssertThrow (t*7 == 7*t , ExcInternalError());
+ AssertThrow (t*7 == 7*t, ExcInternalError());
AssertThrow ((t*7 - (t+t+t+t+t+t+t)).norm() < 1e-12, ExcInternalError());
}
t[1][1] = 3.35792;
AssertThrow (7*t == 7.0 * t, ExcInternalError());
AssertThrow (t*7 == t * 7.0, ExcInternalError());
- AssertThrow (t*7 == 7*t , ExcInternalError());
+ AssertThrow (t*7 == 7*t, ExcInternalError());
AssertThrow ((t*7 - (t+t+t+t+t+t+t)).norm() < 1e-12, ExcInternalError());
}
{
FE_Q<dim> fe1(p);
FE_Q<dim> fe2(p+1);
- FESystem<dim> fe(fe1, 2, fe2 , 1);
+ FESystem<dim> fe(fe1, 2, fe2, 1);
DoFHandler<dim> dof_handler(triangulation);
dof_handler.distribute_dofs (fe);
{
FE_Q<dim> fe1(p);
FE_Q<dim> fe2(p+1);
- FESystem<dim> fe(fe1, 2, fe2 , 1);
+ FESystem<dim> fe(fe1, 2, fe2, 1);
DoFHandler<dim> dof_handler(triangulation);
dof_handler.distribute_dofs (fe);
// product rule:
const double v_s = v_s0 + v_s1 * v_f;
const Tensor<1,dim> g_s = g_s0 + g_s1 * v_f + v_s1 * g_f;
- Tensor<2,dim> op = outer_product(g_s1 , g_f );
+ Tensor<2,dim> op = outer_product(g_s1, g_f );
const SymmetricTensor<2,dim> sp = symmetrize (op) * 2.0; // symmetrize does [s+s^T]/2
// Hessians should be symmetric, but due to round off errors and the fact
const Tensor<1,dim> g_s = g_s0 + g_s1 * v_f1 + v_s1 * g_f1
+ g_s2 * v_f2 + v_s2 * g_f2
+ g_s3 * v_f3 + v_s3 * g_f3;
- Tensor<2,dim> op1 = outer_product(g_s1 , g_f1 ),
- op2 = outer_product(g_s2 , g_f2 ),
- op3 = outer_product(g_s3 , g_f3 );
+ Tensor<2,dim> op1 = outer_product(g_s1, g_f1 ),
+ op2 = outer_product(g_s2, g_f2 ),
+ op3 = outer_product(g_s3, g_f3 );
const SymmetricTensor<2,dim> sp1 = symmetrize (op1) * 2.0; // symmetrize does [s+s^T]/2
const SymmetricTensor<2,dim> sp2 = symmetrize (op2) * 2.0; // symmetrize does [s+s^T]/2
-const double entries2[4] = { 0.814723686393179 , 0.516389376684563,
+const double entries2[4] = { 0.814723686393179, 0.516389376684563,
0.516389376684563, 0.913375856139019
};
ConstraintMatrix cm;
cm.add_line(1);
- cm.add_entry(1 ,2, 3.0);
+ cm.add_entry(1,2, 3.0);
cm.close();
if (myid==0)
= GridTools::get_patch_around_cell<Triangulation<dim> > (cell);
Triangulation<dim> local_triangulation(Triangulation<dim>::limit_level_difference_at_vertices);
- std::map<typename Triangulation<dim>::active_cell_iterator ,
+ std::map<typename Triangulation<dim>::active_cell_iterator,
typename Triangulation<dim>::active_cell_iterator> patch_to_global_tria_map;
GridTools::build_triangulation_from_patch <Triangulation<dim> >
= GridTools::get_patch_around_cell<Triangulation<dim> > (cell);
Triangulation<dim> local_triangulation(Triangulation<dim>::limit_level_difference_at_vertices);
- std::map<typename Triangulation<dim>::active_cell_iterator , typename Triangulation<dim>::active_cell_iterator> patch_to_global_tria_map;
+ std::map<typename Triangulation<dim>::active_cell_iterator, typename Triangulation<dim>::active_cell_iterator> patch_to_global_tria_map;
GridTools::build_triangulation_from_patch <Triangulation<dim> >
(patch_cells,local_triangulation,patch_to_global_tria_map);
= GridTools::get_patch_around_cell<Triangulation<dim> > (cell);
Triangulation<dim> local_triangulation(Triangulation<dim>::limit_level_difference_at_vertices);
- std::map<typename Triangulation<dim>::active_cell_iterator ,
+ std::map<typename Triangulation<dim>::active_cell_iterator,
typename Triangulation<dim>::active_cell_iterator> patch_to_global_tria_map;
GridTools::build_triangulation_from_patch <Triangulation<dim> >
= GridTools::get_patch_around_cell<Triangulation<dim> > (cell);
Triangulation<dim> local_triangulation(Triangulation<dim>::limit_level_difference_at_vertices);
- std::map<typename Triangulation<dim>::active_cell_iterator , typename Triangulation<dim>::active_cell_iterator> patch_to_global_tria_map;
+ std::map<typename Triangulation<dim>::active_cell_iterator, typename Triangulation<dim>::active_cell_iterator> patch_to_global_tria_map;
GridTools::build_triangulation_from_patch <Triangulation<dim> >
(patch_cells,local_triangulation,patch_to_global_tria_map);
std::sort(coarse_cells.begin(), coarse_cells.end());
for (unsigned int i=0; i<patch_cells.size(); ++i)
- Assert (patch_cells[i]==coarse_cells[i] ,ExcInternalError());
+ Assert (patch_cells[i]==coarse_cells[i],ExcInternalError());
deallog << "coarse_ cells " << cell << ": ";
for (unsigned int i=0; i<coarse_cells.size(); ++i)
void test (const int test_case)
{
char testname[100];
- sprintf(testname, "Test%d.dim%d", test_case , dim);
+ sprintf(testname, "Test%d.dim%d", test_case, dim);
deallog.push(testname);
deallog << "Start" << std::endl;
BlockDynamicSparsityPattern dynamic_sparsity_pattern(n_blocks,
n_blocks);
- dynamic_sparsity_pattern.block(u_block ,u_block ).reinit(dofs_per_block[u_block] ,dofs_per_block[u_block]);
- dynamic_sparsity_pattern.block(u_block ,lambda_block).reinit(dofs_per_block[u_block] ,dofs_per_block[lambda_block]);
+ dynamic_sparsity_pattern.block(u_block,u_block ).reinit(dofs_per_block[u_block],dofs_per_block[u_block]);
+ dynamic_sparsity_pattern.block(u_block,lambda_block).reinit(dofs_per_block[u_block],dofs_per_block[lambda_block]);
dynamic_sparsity_pattern.block(lambda_block,u_block ).reinit(dofs_per_block[lambda_block],dofs_per_block[u_block]);
dynamic_sparsity_pattern.block(lambda_block,lambda_block).reinit(dofs_per_block[lambda_block],dofs_per_block[lambda_block]);
const unsigned int n = fev.dofs_per_cell;
unsigned int d=fev.get_fe().n_components();
FullMatrix<double> M(n,n);
- std::vector<std::vector<double> > vel(dim ,std::vector<double>(1));
+ std::vector<std::vector<double> > vel(dim,std::vector<double>(1));
vel[0][0]=1.;
vel[1][0]=1.;
if (dim > 2)
FullMatrix<double> M12(n1,n2);
FullMatrix<double> M21(n2,n1);
FullMatrix<double> M22(n2,n2);
- std::vector<std::vector<double> > vel(dim ,std::vector<double>(1));
+ std::vector<std::vector<double> > vel(dim,std::vector<double>(1));
vel[0][0]=1.;
vel[1][0]=1.;
if (dim > 2)
Point<3>(1,1,2),
Point<3>(0,1,2)
};
- const int cell_vertices[2][8] = { { 0,1,2,3,4,5,6,7 }, { 3, 2, 8, 9 , 7, 6, 10, 11} };
+ const int cell_vertices[2][8] = { { 0,1,2,3,4,5,6,7 }, { 3, 2, 8, 9, 7, 6, 10, 11} };
std::vector<CellData<3> > cells (2, CellData<3>());
for (unsigned int cell=0; cell<2; ++cell)
for (unsigned int j=0; j<8; ++j)
triangulation (mpi_communicator/*,
Triangulation<dim>::maximum_smoothing*/),
fe (FE_Q<dim>(degree+1), dim,
- FE_Q<dim>(degree) , 1),
+ FE_Q<dim>(degree), 1),
dof_handler (triangulation),
pcout (Utilities::MPI::this_mpi_process(mpi_communicator)
== 0
// 1. cube cell
points[0] = Point<dim> (0, 0);
points[1] = Point<dim> (0, 1);
- points[2] = Point<dim> (1 ,0);
- points[3] = Point<dim> (1 ,1);
+ points[2] = Point<dim> (1,0);
+ points[3] = Point<dim> (1,1);
// 2. rectangular cell
points[4] = Point<dim> (3., 0);
{
typedef VectorizedArray<Number> vector_t;
FEEvaluation<dim,degree_p+1,degree_p+2,dim,Number> velocity (data, 0);
- FEEvaluation<dim,degree_p ,degree_p+2,1, Number> pressure (data, 1);
+ FEEvaluation<dim,degree_p,degree_p+2,1, Number> pressure (data, 1);
for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
{
{
typedef VectorizedArray<Number> vector_t;
FEEvaluation<dim,degree_p+1,degree_p+2,dim,Number> velocity (data, 0);
- FEEvaluation<dim,degree_p ,degree_p+2,1, Number> pressure (data, 1);
+ FEEvaluation<dim,degree_p,degree_p+2,1, Number> pressure (data, 1);
for (unsigned int cell=cell_range.first; cell<cell_range.second; ++cell)
{
triangulation (mpi_communicator/*,
Triangulation<dim>::maximum_smoothing*/),
fe (FE_Q<dim>(degree+1), dim,
- FE_Q<dim>(degree) , 1),
+ FE_Q<dim>(degree), 1),
dof_handler (triangulation),
pcout (Utilities::MPI::this_mpi_process(mpi_communicator)
== 0
{
try
{
- Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv ,1);
+ Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv,1);
MPILogInitAll log;
periodicity_tests<2> test_2D;
triangulation (mpi_communicator/*,
Triangulation<dim>::maximum_smoothing*/),
fe (FE_Q<dim>(degree+1), dim,
- FE_Q<dim>(degree) , 1),
+ FE_Q<dim>(degree), 1),
dof_handler (triangulation),
pcout (Utilities::MPI::this_mpi_process(mpi_communicator)
== 0
triangulation (mpi_communicator/*,
Triangulation<dim>::maximum_smoothing*/),
fe (FE_Q<dim>(degree+1), dim,
- FE_Q<dim>(degree) , 1),
+ FE_Q<dim>(degree), 1),
dof_handler (triangulation),
pcout (Utilities::MPI::this_mpi_process(mpi_communicator)
== 0
triangulation (mpi_communicator/*,
Triangulation<dim>::maximum_smoothing*/),
fe (FE_Q<dim>(degree+1), dim,
- FE_Q<dim>(degree) , 1),
+ FE_Q<dim>(degree), 1),
dof_handler (triangulation)
{}
projects / dealii.git / commitdiff