partitioner->locally_owned_size() +
partitioner->n_ghost_indices());
// do not allow reading a vector which is not in ghost mode
- Assert(local_index < local_size() || vector_is_ghosted == true,
+ Assert(local_index < locally_owned_size() || vector_is_ghosted == true,
ExcMessage("You tried to read a ghost element of this vector, "
"but it has not imported its ghost values."));
thread_loop_partitioner = v.thread_loop_partitioner;
- const size_type this_size = local_size();
+ const size_type this_size = locally_owned_size();
if (this_size > 0)
{
dealii::internal::VectorOperations::
}
Vector<Number, ::dealii::MemorySpace::Host> tmp_vector(comm_pattern);
- data.copy_to(tmp_vector.begin(), local_size());
+ data.copy_to(tmp_vector.begin(), locally_owned_size());
// fill entries from ReadWriteVector into the distributed vector,
// including ghost entries. this is not really efficient right now
}
tmp_vector.compress(operation);
- data.copy_from(tmp_vector.begin(), local_size());
+ data.copy_from(tmp_vector.begin(), locally_owned_size());
}
template <typename Number, typename MemorySpaceType>
Vector<Number, MemorySpaceType> &
Vector<Number, MemorySpaceType>::operator=(const Number s)
{
- const size_type this_size = local_size();
+ const size_type this_size = locally_owned_size();
if (this_size > 0)
{
dealii::internal::VectorOperations::
ExcVectorTypeNotCompatible());
const VectorType &v = dynamic_cast<const VectorType &>(vv);
- AssertDimension(local_size(), v.local_size());
+ AssertDimension(locally_owned_size(), v.locally_owned_size());
dealii::internal::VectorOperations::
functions<Number, Number, MemorySpaceType>::add_vector(
ExcVectorTypeNotCompatible());
const VectorType &v = dynamic_cast<const VectorType &>(vv);
- AssertDimension(local_size(), v.local_size());
+ AssertDimension(locally_owned_size(), v.locally_owned_size());
dealii::internal::VectorOperations::
functions<Number, Number, MemorySpaceType>::subtract_vector(
const VectorType &v = dynamic_cast<const VectorType &>(vv);
AssertIsFinite(a);
- AssertDimension(local_size(), v.local_size());
+ AssertDimension(locally_owned_size(), v.locally_owned_size());
// nothing to do if a is zero
if (a == Number(0.))
AssertIsFinite(a);
AssertIsFinite(b);
- AssertDimension(local_size(), v.local_size());
- AssertDimension(local_size(), w.local_size());
+ AssertDimension(locally_owned_size(), v.locally_owned_size());
+ AssertDimension(locally_owned_size(), w.locally_owned_size());
dealii::internal::VectorOperations::
functions<Number, Number, MemorySpaceType>::add_avpbw(
const Vector<Number, MemorySpaceType> &v)
{
AssertIsFinite(x);
- AssertDimension(local_size(), v.local_size());
+ AssertDimension(locally_owned_size(), v.locally_owned_size());
dealii::internal::VectorOperations::
functions<Number, Number, MemorySpaceType>::sadd_xv(
AssertIsFinite(x);
AssertIsFinite(a);
- AssertDimension(local_size(), v.local_size());
+ AssertDimension(locally_owned_size(), v.locally_owned_size());
dealii::internal::VectorOperations::
functions<Number, Number, MemorySpaceType>::sadd_xav(
ExcVectorTypeNotCompatible());
const VectorType &v = dynamic_cast<const VectorType &>(vv);
- AssertDimension(local_size(), v.local_size());
+ AssertDimension(locally_owned_size(), v.locally_owned_size());
dealii::internal::VectorOperations::
functions<Number, Number, MemorySpaceType>::scale(
- thread_loop_partitioner, local_size(), v.data, data);
+ thread_loop_partitioner, locally_owned_size(), v.data, data);
if (vector_is_ghosted)
update_ghost_values();
const VectorType &v = dynamic_cast<const VectorType &>(vv);
AssertIsFinite(a);
- AssertDimension(local_size(), v.local_size());
+ AssertDimension(locally_owned_size(), v.locally_owned_size());
dealii::internal::VectorOperations::
functions<Number, Number, MemorySpaceType>::equ_au(
{
real_type max = 0.;
- const size_type local_size = partitioner->locally_owned_size();
+ const size_type locally_owned_size = partitioner->locally_owned_size();
internal::la_parallel_vector_templates_functions<
Number,
- MemorySpaceType>::linfty_norm_local(data, local_size, max);
+ MemorySpaceType>::linfty_norm_local(data, locally_owned_size, max);
return max;
}
const Vector<Number, MemorySpaceType> &w)
{
const size_type vec_size = partitioner->locally_owned_size();
- AssertDimension(vec_size, v.local_size());
- AssertDimension(vec_size, w.local_size());
+ AssertDimension(vec_size, v.locally_owned_size());
+ AssertDimension(vec_size, w.locally_owned_size());
Number sum = dealii::internal::VectorOperations::
functions<Number, Number, MemorySpaceType>::add_and_dot(
solution_old.begin(),
temp_vector1.begin(),
solution.begin());
- VectorUpdatesRange<Number>(upd, rhs.local_size());
+ VectorUpdatesRange<Number>(upd, rhs.locally_owned_size());
// swap vectors x^{n+1}->x^{n}, given the updates in the function above
if (iteration_index == 0)
types::global_dof_index first_local_range = 0;
if (!vector.locally_owned_elements().is_empty())
first_local_range = vector.locally_owned_elements().nth_index_in_set(0);
- for (unsigned int i = 0; i < vector.local_size(); ++i)
+ for (unsigned int i = 0; i < vector.locally_owned_size(); ++i)
vector.local_element(i) = (i + first_local_range) % 11;
const Number mean_value = vector.mean_value();
if (!vector.locally_owned_elements().is_empty())
first_local_range = vector.locally_owned_elements().nth_index_in_set(0);
- const auto n_local_elements = vector.local_size();
+ const auto n_local_elements = vector.locally_owned_size();
const int n_blocks =
1 + (n_local_elements - 1) / CUDAWrappers::block_size;
set_initial_guess_kernel<<<n_blocks, CUDAWrappers::block_size>>>(
LinearAlgebra::distributed::Vector<double> & dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
- AssertDimension(dst.local_size(),
+ AssertDimension(dst.locally_owned_size(),
preconditioner->OperatorDomainMap().NumMyElements());
- AssertDimension(src.local_size(),
+ AssertDimension(src.locally_owned_size(),
preconditioner->OperatorRangeMap().NumMyElements());
Epetra_Vector tril_dst(View,
preconditioner->OperatorDomainMap(),
LinearAlgebra::distributed::Vector<double> & dst,
const LinearAlgebra::distributed::Vector<double> &src) const
{
- AssertDimension(dst.local_size(),
+ AssertDimension(dst.locally_owned_size(),
preconditioner->OperatorDomainMap().NumMyElements());
- AssertDimension(src.local_size(),
+ AssertDimension(src.locally_owned_size(),
preconditioner->OperatorRangeMap().NumMyElements());
Epetra_Vector tril_dst(View,
preconditioner->OperatorDomainMap(),
internal::copy_constrained_dofs<Number>
<<<constraint_grid_dim, constraint_block_dim>>>(constrained_dofs,
n_constrained_dofs,
- src.local_size(),
+ src.locally_owned_size(),
src.get_values(),
dst.get_values());
AssertCudaKernel();
internal::set_constrained_dofs<Number>
<<<constraint_grid_dim, constraint_block_dim>>>(constrained_dofs,
n_constrained_dofs,
- dst.local_size(),
+ dst.locally_owned_size(),
val,
dst.get_values());
AssertCudaKernel();
for (unsigned int level = dst.min_level(); level <= dst.max_level(); ++level)
if (dst[level].size() != dof_handler.n_dofs(level) ||
- dst[level].local_size() !=
+ dst[level].locally_owned_size() !=
dof_handler.locally_owned_mg_dofs(level).n_elements())
{
// In case a ghosted level vector has been initialized, we can simply
if (perform_plain_copy)
{
// In this case, we can simply copy the local range.
- AssertDimension(dst[dst.max_level()].local_size(), src.local_size());
+ AssertDimension(dst[dst.max_level()].locally_owned_size(),
+ src.locally_owned_size());
dst[dst.max_level()].copy_locally_owned_data_from(src);
return;
}
else if (perform_renumbered_plain_copy)
{
- AssertDimension(dst[dst.max_level()].local_size(), src.local_size());
- AssertDimension(this_copy_indices.back().n_cols(), src.local_size());
+ AssertDimension(dst[dst.max_level()].locally_owned_size(),
+ src.locally_owned_size());
+ AssertDimension(this_copy_indices.back().n_cols(),
+ src.locally_owned_size());
Assert(copy_indices_level_mine.back().n_rows() == 0, ExcInternalError());
LinearAlgebra::distributed::Vector<Number> &dst_level =
dst[dst.max_level()];
// the ghosted vector should already have the correct local size (but
// different parallel layout)
- AssertDimension(ghosted_global_vector.local_size(), src.local_size());
+ AssertDimension(ghosted_global_vector.locally_owned_size(),
+ src.locally_owned_size());
// copy the source vector to the temporary vector that we hold for the
// purpose of data exchange
// stray data in ghost entries of the destination, make sure to clear
// them here.
dst.zero_out_ghost_values();
- AssertDimension(src[src.max_level()].local_size(), dst.local_size());
+ AssertDimension(src[src.max_level()].locally_owned_size(),
+ dst.locally_owned_size());
dst.copy_locally_owned_data_from(src[src.max_level()]);
return;
}
else if (perform_renumbered_plain_copy)
{
- AssertDimension(src[src.max_level()].local_size(), dst.local_size());
- AssertDimension(copy_indices.back().n_cols(), dst.local_size());
+ AssertDimension(src[src.max_level()].locally_owned_size(),
+ dst.locally_owned_size());
+ AssertDimension(copy_indices.back().n_cols(), dst.locally_owned_size());
Assert(copy_indices_global_mine.back().n_rows() == 0, ExcInternalError());
Assert(copy_indices_global_mine.back().empty(), ExcInternalError());
const LinearAlgebra::distributed::Vector<Number> &src_level =
{
// the ghosted vector should already have the correct local size (but
// different parallel layout)
- AssertDimension(ghosted_level_vector[level].local_size(),
- src[level].local_size());
+ AssertDimension(ghosted_level_vector[level].locally_owned_size(),
+ src[level].locally_owned_size());
// the first time around, we copy the source vector to the temporary
// vector that we hold for the purpose of data exchange
{
// the ghosted vector should already have the correct local size (but
// different parallel layout)
- AssertDimension(ghosted_level_vector[level].local_size(),
- src[level].local_size());
+ AssertDimension(ghosted_level_vector[level].locally_owned_size(),
+ src[level].locally_owned_size());
// the first time around, we copy the source vector to the temporary
// vector that we hold for the purpose of data exchange
for (unsigned int level = min_level; level <= max_level; ++level)
if (dst[level].size() != dof_handler.n_dofs(level) ||
- dst[level].local_size() !=
+ dst[level].locally_owned_size() !=
dof_handler.locally_owned_mg_dofs(level).n_elements())
dst[level].reinit(this->vector_partitioners[level]);
LinearAlgebra::distributed::Vector<Number> &v = dst[level].block(b);
if (v.size() !=
dof_handler[b]->locally_owned_mg_dofs(level).size() ||
- v.local_size() !=
+ v.locally_owned_size() !=
dof_handler[b]->locally_owned_mg_dofs(level).n_elements())
{
do_reinit[level] = true;
AssertIndexRange(locally_owned_size, n + 1);
ghosted = false;
- const PetscErrorCode ierr =
- VecCreateMPI(communicator, locally_owned_size, PETSC_DETERMINE, &vector);
+ const PetscErrorCode ierr = VecCreateMPI(communicator,
+ locally_owned_size,
+ PETSC_DETERMINE,
+ &vector);
AssertThrow(ierr == 0, ExcPETScError(ierr));
Assert(size() == n, ExcDimensionMismatch(size(), n));
ierr = VecGetOwnershipRange(vector, &begin, &end);
AssertThrow(ierr == 0, ExcPETScError(ierr));
- AssertDimension(locally_owned_size, static_cast<size_type>(end - begin));
+ AssertDimension(locally_owned_size,
+ static_cast<size_type>(end - begin));
Vec l;
ierr = VecGhostGetLocalForm(vector, &l);
this->vector_partitioners[to_level].get())
this->ghosted_level_vector[to_level].reinit(
this->vector_partitioners[to_level]);
- AssertDimension(this->ghosted_level_vector[to_level].local_size(),
- dst.local_size());
+ AssertDimension(this->ghosted_level_vector[to_level].locally_owned_size(),
+ dst.locally_owned_size());
}
const LinearAlgebra::distributed::Vector<Number> &src_vec =
this->vector_partitioners[from_level - 1].get())
this->ghosted_level_vector[from_level - 1].reinit(
this->vector_partitioners[from_level - 1]);
- AssertDimension(this->ghosted_level_vector[from_level - 1].local_size(),
- dst.local_size());
+ AssertDimension(
+ this->ghosted_level_vector[from_level - 1].locally_owned_size(),
+ dst.locally_owned_size());
this->ghosted_level_vector[from_level - 1] = 0.;
}