*/
/**
- * Return the indices of the dofs of this object in the standard
- * ordering: dofs on vertex 0, dofs on vertex 1, etc, dofs on line
- * 0, dofs on line 1, etc, dofs on quad 0, etc.
+ * Return the <i>global</i> indices of the degrees of freedom located on
+ * this object in the standard ordering defined by the finite element (i.e.,
+ * dofs on vertex 0, dofs on vertex 1, etc, dofs on line 0, dofs on line 1,
+ * etc, dofs on quad 0, etc.) This function is only available on
+ * <i>active</i> objects (see @ref GlossActive "this glossary entry").
*
- * @param[out] dof_indices The vector into which the indices will be
- * written. It has to have the right size (namely,
- * <code>fe.dofs_per_cell</code>, <code>fe.dofs_per_face</code>,
- * or <code>fe.dofs_per_line</code>, depending on which kind of
- * object this function is called) before being passed to this
- * function.
- * @param[in] fe_index The finite element index. For the
- * standard ::DoFHandler class, this value must be equal to its default
- * value since that class only supports the same finite element on all
- * cells anyway. However, for hp objects (i.e. the hp::DoFHandler
- * class), different finite element objects may be used on different
- * cells. On faces between two cells, as well as vertices, there may
- * therefore be two sets of degrees of freedom, one for each of the
- * finite elements used on the adjacent cells. In order to specify which
- * set of degrees of freedom to work on, the last argument is used to
- * disambiguate. Finally, if this function is called for a cell object,
- * there can only be a single set of degrees of freedom, and fe_index
- * has to match the result of active_fe_index(). (Consequently,
- * the derived DoFCellAccessor class has an overloaded version of this
- * function that calls the present function with
- * <code>cell-@>active_fe_index</code> as last argument.)
- *
- *
- * @note In many places in the tutorial and elsewhere in the library, the
- * first argument to this function is called
- * <code>local_dof_indices</code> by convention. The name is not meant to
- * indicate the <i>local</i> numbers of degrees of freedom (which are
- * always between zero and <code>fe.dofs_per_cell</code>, or similar faces
- * or edges) but instead that the returned values are the <i>global</i>
- * indices of those degrees of freedom that are located locally on the
- * current cell, face or edge.
+ * The cells needs to be an active cell (and not artificial in a
+ * parallel distributed computation).
+ *
+ * The vector has to have the right size before being passed to this
+ * function.
+ *
+ * The last argument denotes the finite element index. For the
+ * standard ::DoFHandler class, this value must be equal to its
+ * default value since that class only supports the same finite
+ * element on all cells anyway.
+ *
+ * However, for hp objects (i.e. the hp::DoFHandler class),
+ * different finite element objects may be used on different
+ * cells. On faces between two cells, as well as vertices, there may
+ * therefore be two sets of degrees of freedom, one for each of the
+ * finite elements used on the adjacent cells. In order to specify
+ * which set of degrees of freedom to work on, the last argument is
+ * used to disambiguate. Finally, if this function is called for a
+ * cell object, there can only be a single set of degrees of
+ * freedom, and fe_index has to match the result of
+ * active_fe_index().
+ *
+ * For cells, there is only a single possible finite element index
+ * (namely the one for that cell, returned by
+ * <code>cell-@>active_fe_index</code>. Consequently, the derived
+ * DoFCellAccessor class has an overloaded version of this function
+ * that calls the present function with
+ * <code>cell-@>active_fe_index</code> as last argument.
+ *
*/
- void get_dof_indices (std::vector<unsigned int> &dof_indices,
+ void get_dof_indices (std::vector<types::global_dof_index> &dof_indices,
const unsigned int fe_index = DH::default_fe_index) const;
/**
*/
/**
- * Return the indices of the dofs of this
- * object in the standard ordering: dofs
- * on vertex 0, dofs on vertex 1, etc,
- * dofs on line 0, dofs on line 1, etc,
- * dofs on quad 0, etc.
+ * Return the <i>global</i> indices of the degrees of freedom located on
+ * this object in the standard ordering defined by the finite element (i.e.,
+ * dofs on vertex 0, dofs on vertex 1, etc, dofs on line 0, dofs on line 1,
+ * etc, dofs on quad 0, etc.) This function is only available on
+ * <i>active</i> objects (see @ref GlossActive "this glossary entry").
*
- * @param[out] dof_indices The vector into which the indices will be
- * written. It has to have the right size (namely,
- * <code>fe.dofs_per_cell</code>, <code>fe.dofs_per_face</code>,
- * or <code>fe.dofs_per_line</code>, depending on which kind of
- * object this function is called) before being passed to this
- * function.
- * @param[in] fe_index The finite element index. For the
- * standard ::DoFHandler class, this value must be equal to its default
- * value since that class only supports the same finite element on all
- * cells anyway. However, for hp objects (i.e. the hp::DoFHandler
- * class), different finite element objects may be used on different
- * cells. On faces between two cells, as well as vertices, there may
- * therefore be two sets of degrees of freedom, one for each of the
- * finite elements used on the adjacent cells. In order to specify which
- * set of degrees of freedom to work on, the last argument is used to
- * disambiguate. Finally, if this function is called for a cell object,
- * there can only be a single set of degrees of freedom, and fe_index
- * has to match the result of active_fe_index(). (Consequently,
- * the derived DoFCellAccessor class has an overloaded version of this
- * function that calls the present function with
- * <code>cell-@>active_fe_index</code> as last argument.)
+ * The cells needs to be an active cell (and not artificial in a
+ * parallel distributed computation).
+ *
+ * The vector has to have the
+ * right size before being passed
+ * to this function.
+ *
+ * The last argument denotes the
+ * finite element index. For the
+ * standard ::DoFHandler class,
+ * this value must be equal to
+ * its default value since that
+ * class only supports the same
+ * finite element on all cells
+ * anyway.
+ *
+ * However, for hp objects
+ * (i.e. the hp::DoFHandler
+ * class), different finite
+ * element objects may be used on
+ * different cells. On faces
+ * between two cells, as well as
+ * vertices, there may therefore
+ * be two sets of degrees of
+ * freedom, one for each of the
+ * finite elements used on the
+ * adjacent cells. In order to
+ * specify which set of degrees
+ * of freedom to work on, the
+ * last argument is used to
+ * disambiguate. Finally, if this
+ * function is called for a cell
+ * object, there can only be a
+ * single set of degrees of
+ * freedom, and fe_index has to
+ * match the result of
+ * active_fe_index().
+ *
+ * For cells, there is only a
+ * single possible finite element
+ * index (namely the one for that
+ * cell, returned by
+ * <code>cell-@>active_fe_index</code>. Consequently,
+ * the derived DoFCellAccessor
+ * class has an overloaded
+ * version of this function that
+ * calls the present function
+ * with
+ * <code>cell-@>active_fe_index</code>
+ * as last argument.
*/
- void get_dof_indices (std::vector<unsigned int> &dof_indices,
+ void get_dof_indices (std::vector<types::global_dof_index> &dof_indices,
const unsigned int fe_index = AccessorData::default_fe_index) const;
/**
*
* Examples for this use are in the implementation of DoFRenumbering.
*/
- void get_active_or_mg_dof_indices (std::vector<unsigned int> &dof_indices) const;
+ void get_active_or_mg_dof_indices (std::vector<types::global_dof_index> &dof_indices) const;
/**
- * Return the indices of the dofs of this
- * quad in the standard ordering: dofs
- * on vertex 0, dofs on vertex 1, etc,
- * dofs on line 0, dofs on line 1, etc,
- * dofs on quad 0, etc.
+ * Return the <i>global</i> indices of the degrees of freedom located on
+ * this object in the standard ordering defined by the finite element (i.e.,
+ * dofs on vertex 0, dofs on vertex 1, etc, dofs on line 0, dofs on line 1,
+ * etc, dofs on quad 0, etc.) This function is only available on
+ * <i>active</i> objects (see @ref GlossActive "this glossary entry").
+ *
+ * @param[out] dof_indices The vector into which the indices will be
+ * written. It has to have the right size (namely,
+ * <code>fe.dofs_per_cell</code>, <code>fe.dofs_per_face</code>,
+ * or <code>fe.dofs_per_line</code>, depending on which kind of
+ * object this function is called) before being passed to this
+ * function.
*
- * It is assumed that the vector already
- * has the right size beforehand.
- *
- * This function reimplements the
- * same function in the base
- * class. The functions in the
- * base classes are available for
- * all geometric objects,
- * i.e. even in 3d they can be
- * used to access the dof indices
- * of edges, for example. On the
- * other hand, the most common
- * case is clearly the use on
- * cells, which is why we cache
- * the array for each cell, but
- * not edge. To retrieve the
- * cached values, rather than
- * collect the necessary
- * information every time, this
- * function overwrites the one in
- * the base class.
+ * This function reimplements the same function in the base class.
+ * In contrast to the function in the base class, we do not need the
+ * <code>fe_index</code> here because there is always a unique finite
+ * element index on cells.
*
+ * This is a function which requires that the cell is active.
+ *
* Also see get_active_or_mg_dof_indices().
+ *
+ * @note In many places in the tutorial and elsewhere in the library,
+ * the argument to this function is called <code>local_dof_indices</code>
+ * by convention. The name is not meant to indicate the <i>local</i>
+ * numbers of degrees of freedom (which are always between zero and
+ * <code>fe.dofs_per_cell</code>) but instead that the returned values
+ * are the <i>global</i> indices of those degrees of freedom that
+ * are located locally on the current cell.
+ *
+ * @deprecated Currently, this function can also be called for non-active cells, if all degrees of freedom of the FiniteElement are located in vertices. This functionality will vanish in a future release.
*/
- void get_dof_indices (std::vector<unsigned int> &dof_indices) const;
+ void get_dof_indices (std::vector<types::global_dof_index> &dof_indices) const;
/**
* @deprecated Use get_active_or_mg_dof_indices() with level_cell_iterator returned from begin_mg().
{
AssertDimension (dof_indices.size(), accessor.get_fe().dofs_per_cell);
- // check as in documentation that
- // cell is either active, or dofs
- // are only in vertices
- Assert (!accessor.has_children()
- ||
- (accessor.get_fe().dofs_per_cell ==
- accessor.get_fe().dofs_per_vertex * GeometryInfo<dim>::vertices_per_cell),
- ExcMessage ("Cell must either be active, or all DoFs must be in vertices"));
+ Assert (!accessor.has_children(),
+ ExcMessage ("Cell must be active."));
- unsigned int *cache = &accessor.dof_handler->levels[accessor.level()]
- ->cell_dof_indices_cache[accessor.present_index * accessor.get_fe().dofs_per_cell];
+ types::global_dof_index *cache = &accessor.dof_handler->levels[accessor.level()]
+ ->cell_dof_indices_cache[accessor.present_index * accessor.get_fe().dofs_per_cell];
for (unsigned int i=0; i<accessor.get_fe().dofs_per_cell; ++i, ++cache)
dof_indices[i] = *cache;
}
Assert (values.size() == accessor.get_dof_handler().n_dofs(),
typename BaseClass::ExcVectorDoesNotMatch());
- // check as in documentation that
- // cell is either active, or dofs
- // are only in vertices
- Assert (!accessor.has_children()
- ||
- (accessor.get_fe().dofs_per_cell ==
- accessor.get_fe().dofs_per_vertex * GeometryInfo<dim>::vertices_per_cell),
- ExcMessage ("Cell must either be active, or all DoFs must be in vertices"));
+ Assert (!accessor.has_children(),
+ ExcMessage ("Cell must be active."));
- unsigned int *cache = &accessor.dof_handler->levels[accessor.level()]
- ->cell_dof_indices_cache[accessor.present_index *
- accessor.get_fe().dofs_per_cell];
+ types::global_dof_index *cache = &accessor.dof_handler->levels[accessor.level()]
+ ->cell_dof_indices_cache[accessor.present_index *
+ accessor.get_fe().dofs_per_cell];
for ( ; local_values_begin != local_values_end; ++local_values_begin, ++cache)
*local_values_begin = values(*cache);
}
Assert (values.size() == accessor.get_dof_handler().n_dofs(),
typename BaseClass::ExcVectorDoesNotMatch());
- // check as in documentation that
- // cell is either active, or dofs
- // are only in vertices
- Assert (!accessor.has_children()
- ||
- (accessor.get_fe().dofs_per_cell ==
- accessor.get_fe().dofs_per_vertex * GeometryInfo<dim>::vertices_per_cell),
- ExcMessage ("Cell must either be active, or all DoFs must be in vertices"));
+ Assert (!accessor.has_children(),
+ ExcMessage ("Cell must be active."));
- unsigned int *cache = &accessor.dof_handler->levels[accessor.level()]
- ->cell_dof_indices_cache[accessor.present_index *
- accessor.get_fe().dofs_per_cell];
+ types::global_dof_index *cache = &accessor.dof_handler->levels[accessor.level()]
+ ->cell_dof_indices_cache[accessor.present_index *
+ accessor.get_fe().dofs_per_cell];
constraints.get_dof_values(values, *cache, local_values_begin,
local_values_end);
}
Assert (values.size() == accessor.get_dof_handler().n_dofs(),
typename BaseClass::ExcVectorDoesNotMatch());
- // check as in documentation that
- // cell is either active, or dofs
- // are only in vertices
- Assert (!accessor.has_children()
- ||
- (accessor.get_fe().dofs_per_cell ==
- accessor.get_fe().dofs_per_vertex * GeometryInfo<dim>::vertices_per_cell),
- ExcMessage ("Cell must either be active, or all DoFs must be in vertices"));
+ Assert (!accessor.has_children(),
+ ExcMessage ("Cell must be active."));
- unsigned int *cache = &accessor.dof_handler->levels[accessor.level()]
- ->cell_dof_indices_cache[accessor.present_index * accessor.get_fe().dofs_per_cell];
+ types::global_dof_index *cache = &accessor.dof_handler->levels[accessor.level()]
+ ->cell_dof_indices_cache[accessor.present_index * accessor.get_fe().dofs_per_cell];
for (unsigned int i=0; i<accessor.get_fe().dofs_per_cell; ++i, ++cache)
values(*cache) = local_values(i);
}
Assert (accessor.dof_handler->n_dofs() == global_vector.size(),
typename BaseClass::ExcVectorDoesNotMatch());
- // check as in documentation that
- // cell is either active, or dofs
- // are only in vertices
- Assert (!accessor.has_children()
- ||
- (accessor.get_fe().dofs_per_cell ==
- accessor.get_fe().dofs_per_vertex * GeometryInfo<dim>::vertices_per_cell),
- ExcMessage ("Cell must either be active, or all DoFs must be in vertices"));
+ Assert (!accessor.has_children(),
+ ExcMessage ("Cell must be active."));
const unsigned int n_dofs = accessor.get_fe().dofs_per_cell;
- unsigned int *dofs = &accessor.dof_handler->levels[accessor.level()]
- ->cell_dof_indices_cache[accessor.present_index *n_dofs];
+ types::global_dof_index *dofs = &accessor.dof_handler->levels[accessor.level()]
+ ->cell_dof_indices_cache[accessor.present_index *n_dofs];
// distribute cell matrices
for (unsigned int i=0; i<n_dofs; ++i)
template <class DH, bool lda>
inline
void
-DoFCellAccessor<DH,lda>::get_dof_indices (std::vector<unsigned int> &dof_indices) const
+DoFCellAccessor<DH,lda>::get_dof_indices (std::vector<types::global_dof_index> &dof_indices) const
{
+ Assert (this->active(), ExcMessage ("get_dof_indices() only works on active cells."));
Assert (this->is_artificial() == false,
ExcMessage ("Can't ask for DoF indices on artificial cells."));
AssertDimension (dof_indices.size(), this->get_fe().dofs_per_cell);
* the renumbering vector.
*/
template <int dim, int spacedim, class ITERATOR, class ENDITERATOR>
- unsigned int
- compute_component_wise (std::vector<unsigned int> &new_dof_indices,
+ types::global_dof_index
+ compute_component_wise (std::vector<types::global_dof_index> &new_dof_indices,
const ITERATOR &start,
const ENDITERATOR &end,
- const std::vector<unsigned int> &target_component);
+ const std::vector<unsigned int> &target_component,
+ bool is_level_operation);
/**
* @}
typename DH::level_cell_iterator start =dof_handler.begin(level);
typename DH::level_cell_iterator end = dof_handler.end(level);
- const unsigned int result =
+ const types::global_dof_index result =
compute_component_wise<DH::dimension, DH::space_dimension,
typename DH::level_cell_iterator, typename DH::level_cell_iterator>
- (renumbering, start, end, component_order_arg);
+ (renumbering, start, end, component_order_arg, true);
if (result == 0) return;
template <int dim, int spacedim, class ITERATOR, class ENDITERATOR>
- unsigned int
- compute_component_wise (std::vector<unsigned int> &new_indices,
+ types::global_dof_index
+ compute_component_wise (std::vector<types::global_dof_index> &new_indices,
const ITERATOR &start,
const ENDITERATOR &end,
- const std::vector<unsigned int> &component_order_arg)
+ const std::vector<unsigned int> &component_order_arg,
+ bool is_level_operation)
{
const hp::FECollection<dim,spacedim>
fe_collection (start->get_dof_handler().get_fe ());
// dof indices are entered
// multiply, so we will have to
// take care of that
- std::vector<std::vector<unsigned int> >
+ std::vector<std::vector<types::global_dof_index> >
component_to_dof_map (fe_collection.n_components());
for (ITERATOR cell=start; cell!=end; ++cell)
- if (cell->is_locally_owned())
- {
- // on each cell: get dof indices
- // and insert them into the global
- // list using their component
- const unsigned int fe_index = cell->active_fe_index();
- const unsigned int dofs_per_cell = fe_collection[fe_index].dofs_per_cell;
- local_dof_indices.resize (dofs_per_cell);
- cell->get_active_or_mg_dof_indices (local_dof_indices);
- for (unsigned int i=0; i<dofs_per_cell; ++i)
- if (start->get_dof_handler().locally_owned_dofs().is_element(local_dof_indices[i]))
- component_to_dof_map[component_list[fe_index][i]].
- push_back (local_dof_indices[i]);
- }
+ {
+ if (is_level_operation)
+ {
+ //we are dealing with mg dofs, skip foreign level cells:
+ if ((start->get_dof_handler().get_tria().locally_owned_subdomain() != numbers::invalid_subdomain_id)
+ &&
+ (cell->level_subdomain_id()!=start->get_dof_handler().get_tria().locally_owned_subdomain()))
+ continue;
+ }
+ else
+ {
+ //we are dealing with active dofs, skip the loop if not locally
+ // owned:
+ if (!cell->active() || !cell->is_locally_owned())
+ continue;
+ }
+ // on each cell: get dof indices
+ // and insert them into the global
+ // list using their component
+ const unsigned int fe_index = cell->active_fe_index();
+ const unsigned int dofs_per_cell = fe_collection[fe_index].dofs_per_cell;
+ local_dof_indices.resize (dofs_per_cell);
+ cell->get_active_or_mg_dof_indices (local_dof_indices);
+ for (unsigned int i=0; i<dofs_per_cell; ++i)
+ if (start->get_dof_handler().locally_owned_dofs().is_element(local_dof_indices[i]))
+ component_to_dof_map[component_list[fe_index][i]].
+ push_back (local_dof_indices[i]);
+ }
// now we've got all indices sorted
// into buckets labeled by their
}
void
- SolverBase::get_eigenpair (const unsigned int index,
+ SolverBase::get_eigenpair (const size_type index,
- double &eigenvalues,
+ PetscScalar &eigenvalues,
PETScWrappers::VectorBase &eigenvectors)
{
AssertThrow (solver_data.get() != 0, ExcSLEPcWrappersUsageError());
copy_indices_to_me.resize(n_levels);
IndexSet globally_relevant;
DoFTools::extract_locally_relevant_dofs(mg_dof, globally_relevant);
- std::vector<bool> dof_touched(globally_relevant.n_elements(), false);
- std::vector<unsigned int> global_dof_indices (dofs_per_cell);
- std::vector<unsigned int> level_dof_indices (dofs_per_cell);
+ std::vector<types::global_dof_index> global_dof_indices (dofs_per_cell);
+ std::vector<types::global_dof_index> level_dof_indices (dofs_per_cell);
// for (int level=mg_dof.get_tria().n_levels()-1; level>=0; --level)
for (unsigned int level=0; level<mg_dof.get_tria().n_levels(); ++level)
{
dofh.distribute_mg_dofs (fe);
{
- std::ofstream file((std::string("mg_03/ncpu_") + Utilities::int_to_string(Utilities::MPI::n_mpi_processes (MPI_COMM_WORLD)) + "/dat." + Utilities::int_to_string(myid)).c_str());
- file << "**** proc " << myid << std::endl;
- for (unsigned int lvl=0;lvl<tr.n_levels();++lvl)
- {
- file << "level " << lvl << ": ";
- typename DoFHandler<dim>::cell_iterator
- cell = dofh.begin(lvl),
- endc = dofh.end(lvl);
-
- for (;cell!=endc;++cell)
- {
- std::vector<types::global_dof_index> dofs(fe.n_dofs_per_cell());
- cell->get_mg_dof_indices(dofs);
-
- for (unsigned int i=0;i<dofs.size();++i)
- if (dofs[i]==numbers::invalid_dof_index)
- file << "- ";
- else
- file << dofs[i] << " ";
- file << " | ";
- }
- file << std::endl;
- }
+ for (unsigned int lvl=0;lvl<tr.n_levels();++lvl)
+ {
+ deallog << "level " << lvl << ": ";
+ typename DoFHandler<dim>::cell_iterator
+ cell = dofh.begin(lvl),
+ endc = dofh.end(lvl);
+
+ for (;cell!=endc;++cell)
+ {
- std::vector<unsigned int> dofs(fe.n_dofs_per_cell());
++ std::vector<types::global_dof_index> dofs(fe.n_dofs_per_cell());
+ cell->get_mg_dof_indices(dofs);
+
+ for (unsigned int i=0;i<dofs.size();++i)
+ if (dofs[i]==numbers::invalid_dof_index)
+ deallog << "- ";
+ else
+ deallog << dofs[i] << " ";
+ deallog << " | ";
+ }
+ deallog << std::endl;
+ }
}
- MPI_Barrier(MPI_COMM_WORLD);
-
- if (myid==0)
- {
- for (unsigned int i=0;i<Utilities::MPI::n_mpi_processes (MPI_COMM_WORLD);++i)
- {
- cat_file((std::string("mg_03/ncpu_") + Utilities::int_to_string(Utilities::MPI::n_mpi_processes (MPI_COMM_WORLD)) + "/dat." + Utilities::int_to_string(i)).c_str());
- }
- }
-
if (myid==0)
deallog << "OK" << std::endl;
}
dofh.distribute_mg_dofs (fe);
{
- std::ofstream file((std::string("mg_04/ncpu_") + Utilities::int_to_string(Utilities::MPI::n_mpi_processes (MPI_COMM_WORLD)) + "/dat." + Utilities::int_to_string(myid)).c_str());
- file << "**** proc " << myid << std::endl;
- for (unsigned int lvl=0;lvl<tr.n_levels();++lvl)
- {
- file << "level " << lvl << ": ";
- typename DoFHandler<dim>::cell_iterator
- cell = dofh.begin(lvl),
- endc = dofh.end(lvl);
-
- for (;cell!=endc;++cell)
- {
- std::vector<types::global_dof_index> dofs(fe.n_dofs_per_cell());
- cell->get_mg_dof_indices(dofs);
-
- for (unsigned int i=0;i<dofs.size();++i)
- if (dofs[i]==numbers::invalid_dof_index)
- file << "- ";
- else
- file << dofs[i] << " ";
- file << " | ";
- }
- file << std::endl;
- }
+ for (unsigned int lvl=0;lvl<tr.n_levels();++lvl)
+ {
+ deallog << "level " << lvl << ": ";
+ typename DoFHandler<dim>::cell_iterator
+ cell = dofh.begin(lvl),
+ endc = dofh.end(lvl);
+
+ for (;cell!=endc;++cell)
+ {
- std::vector<unsigned int> dofs(fe.n_dofs_per_cell());
++ std::vector<types::global_dof_index> dofs(fe.n_dofs_per_cell());
+ cell->get_mg_dof_indices(dofs);
+
+ for (unsigned int i=0;i<dofs.size();++i)
+ if (dofs[i]==numbers::invalid_dof_index)
+ deallog << "- ";
+ else
+ deallog << dofs[i] << " ";
+ deallog << " | ";
+ }
+ deallog << std::endl;
+ }
}
-
- MPI_Barrier(MPI_COMM_WORLD);
-
- if (myid==0)
- {
- for (unsigned int i=0;i<Utilities::MPI::n_mpi_processes (MPI_COMM_WORLD);++i)
- {
- cat_file((std::string("mg_04/ncpu_") + Utilities::int_to_string(Utilities::MPI::n_mpi_processes (MPI_COMM_WORLD)) + "/dat." + Utilities::int_to_string(i)).c_str());
- }
- }
-
+
if (myid==0)
deallog << "OK" << std::endl;
}
projects / dealii.git / commitdiff