data_out.write_vtu_with_pvtu_record(
"./", "solution", out_index, MPI_COMM_WORLD, 5);
- out_index++;
+ ++out_index;
}
{
if (cell->is_locally_owned())
cell->set_active_fe_index(cell_other->active_fe_index());
- cell_other++;
+ ++cell_other;
}
}
else // coarse level
cell->set_active_fe_index(fe_index_for_degree[next_degree]);
}
- cell_other++;
+ ++cell_other;
}
}
locally_owned_array[j] =
internal::get_min(*read_position,
locally_owned_array[j]);
- read_position++;
+ ++read_position;
}
else if (vector_operation == VectorOperation::max)
for (const auto &import_range : import_indices_data)
locally_owned_array[j] =
internal::get_max(*read_position,
locally_owned_array[j]);
- read_position++;
+ ++read_position;
}
else
for (const auto &import_range : import_indices_data)
operator++()
{
AssertIndexRange(lane + 1, T::size() + 1);
- lane++;
+ ++lane;
return *this;
}
{
ref_key = std::get<0>(keys[i]);
- n_unique_entities++;
+ ++n_unique_entities;
n_unique_entity_vertices +=
cell_types[static_cast<types::geometric_entity_type>(
ad_entity_types[offset_i])]
if (ref_key != std::get<0>(keys[i]))
{
// new key: default orientation is correct
- counter++;
+ ++counter;
ref_key = std::get<0>(keys[i]);
ref_indices = ad_entity_vertices[offset_i];
operator++()
{
AssertIndexRange(index + 1, data->size() + 1);
- index++;
+ ++index;
return *this;
}
for (const auto &i : constrained_indices_by_ranks)
if (i.first != my_rank)
- n_rec_ranks++;
+ ++n_rec_ranks;
for (unsigned int i = 0; i < n_rec_ranks; ++i)
{
Assert(i >= n_inhomogeneous_rows, ExcInternalError());
std::swap(total_row_indices[n_active_rows + i],
total_row_indices[n_active_rows + n_inhomogeneous_rows]);
- n_inhomogeneous_rows++;
+ ++n_inhomogeneous_rows;
}
while (indices_begin != indices_end)
{
*values_begin = operator()(*indices_begin);
- indices_begin++;
- values_begin++;
+ ++indices_begin;
+ ++values_begin;
}
}
while (indices_begin != indices_end)
{
*values_begin = operator()(*indices_begin);
- indices_begin++;
- values_begin++;
+ ++indices_begin;
+ ++values_begin;
}
}
{
column_indices[n_columns] = col_indices[j];
column_values[n_columns] = value;
- n_columns++;
+ ++n_columns;
}
}
AssertIndexRange(n_columns, n_cols + 1);
{
column_indices[n_columns] = col_indices[j];
column_values[n_columns] = value;
- n_columns++;
+ ++n_columns;
}
}
AssertIndexRange(n_columns, n_cols + 1);
while (indices_begin != indices_end)
{
*values_begin = operator()(*indices_begin);
- indices_begin++;
- values_begin++;
+ ++indices_begin;
+ ++values_begin;
}
}
while (solver_state == SolverControl::iterate)
{
- it++;
+ ++it;
worker.do_iteration(it);
while (state == SolverControl::iterate)
{
- step++;
- it++;
+ ++step;
+ ++it;
//--------------------------------------------------------------
// Step 1: apply the system matrix and compute one inner product
//--------------------------------------------------------------
while (indices_begin != indices_end)
{
*values_begin = operator()(*indices_begin);
- indices_begin++;
- values_begin++;
+ ++indices_begin;
+ ++values_begin;
}
}
while (indices_begin != indices_end)
{
*values_begin = operator()(*indices_begin);
- indices_begin++;
- values_begin++;
+ ++indices_begin;
+ ++values_begin;
}
}
value);
operation.post_constraints(value, local_vector[ind_local][v]);
- ind_local++;
+ ++ind_local;
}
AssertIndexRange(ind_local, n_dofs_per_cell + 1);
for (unsigned int comp = 0; comp < n_components; ++comp)
operation.post_constraints(value[comp],
values_dofs[comp][ind_local][v]);
- ind_local++;
+ ++ind_local;
}
AssertIndexRange(ind_local, dofs_per_component + 1);
operation.post_constraints(value,
values_dofs[comp][ind_local][v]);
- ind_local++;
+ ++ind_local;
}
AssertIndexRange(ind_local, dofs_per_component + 1);
const auto fgi = func(ai);
fi = fgi.first;
gi = fgi.second;
- i++;
+ ++i;
if (debug_output)
deallog << "Bracketing phase: " << i << std::endl
const std::pair<NumberType, NumberType> fgi = func(ai);
fi = fgi.first;
gi = fgi.second;
- i++;
+ ++i;
if (debug_output)
deallog << "Sectioning phase: " << i << std::endl
deallog << "Line search a=" << alpha << " f=" << f << std::endl;
// 3. Check convergence
- k++;
+ ++k;
const Number g_l2 = g.l2_norm();
conv = this->iteration_status(k, g_l2, x);
if (conv != SolverControl::iterate)
ExcMessage(
"No residual function has been attached to the NOXSolver object."));
- n_residual_evaluations++;
+ ++n_residual_evaluations;
// evaluate residual
return internal::NOXWrappers::call_and_possibly_capture_exception(
<< "\" style=\"stroke:black; fill:url(#" << triangle_counter
<< "); stroke-width:" << flags.line_thickness << "\"/>" << '\n';
- triangle_counter++;
+ ++triangle_counter;
}
}
// Advance n_th_vector to at least the current data set we are on
while (n_th_vector < nonscalar_data_ranges.size() &&
std::get<0>(nonscalar_data_ranges[n_th_vector]) < data_set)
- n_th_vector++;
+ ++n_th_vector;
// Determine the dimension of this data
if (n_th_vector < nonscalar_data_ranges.size() &&
t = std::min(numbers::PI_2, std::max(0.0, t));
x = a * std::cos(t);
y = b * std::sin(t);
- iter++;
+ ++iter;
}
while (std::abs(delta_t) > tolerance && iter < max_iter);
AssertIndexRange(iter, max_iter);
indices.first.push_back(i);
indices.second.push_back(index);
}
- index++;
+ ++index;
}
Assert(targets.size() == indices_to_look_up_by_dict_rank.size(),
++fe)
if (vertex_fe_association[fe][v] == true)
{
- fe_slots_needed++;
+ ++fe_slots_needed;
vertex_slots_needed +=
dof_handler.get_fe(fe).n_dofs_per_vertex();
}
++fe)
if (line_fe_association[fe][line] == true)
{
- fe_slots_needed++;
+ ++fe_slots_needed;
line_slots_needed +=
dof_handler.get_fe(fe).n_dofs_per_line();
}
vector_dofs[fe.face_system_to_component_index(k, face_no)
.first -
first_vector_component] = k;
- n_found++;
+ ++n_found;
if (n_found == dim)
break;
}
else
points[index - 1] = unit_support_points[j](0);
- index++;
+ ++index;
}
}
// Do not consider the discontinuous node for dimension 1
else
points[index - 1] = unit_support_points[j](0);
- index++;
+ ++index;
}
}
// Do not consider the discontinuous node for dimension 1
unsigned int n_val_cells = 0;
for (unsigned int i = 0; i < n_cells; ++i)
if (material_id[i] != numbers::invalid_material_id)
- n_val_cells++;
+ ++n_val_cells;
std::vector<CellData<1>> cells(n_val_cells);
unsigned int id = 0;
cells[id].vertices[0] = x;
cells[id].vertices[1] = x + 1;
cells[id].material_id = material_id[x];
- id++;
+ ++id;
}
// create triangulation
SubCellData t;
for (unsigned int i = 0; i < material_id.size(0); ++i)
for (unsigned int j = 0; j < material_id.size(1); ++j)
if (material_id[i][j] != numbers::invalid_material_id)
- n_val_cells++;
+ ++n_val_cells;
std::vector<CellData<2>> cells(n_val_cells);
unsigned int id = 0;
cells[id].vertices[2] = (y + 1) * (repetitions[0] + 1) + x;
cells[id].vertices[3] = (y + 1) * (repetitions[0] + 1) + x + 1;
cells[id].material_id = material_id[x][y];
- id++;
+ ++id;
}
// create triangulation
for (unsigned int j = 0; j < material_id.size(1); ++j)
for (unsigned int k = 0; k < material_id.size(2); ++k)
if (material_id[i][j][k] != numbers::invalid_material_id)
- n_val_cells++;
+ ++n_val_cells;
std::vector<CellData<dim>> cells(n_val_cells);
unsigned int id = 0;
cells[id].vertices[6] = (z + 1) * n_xy + (y + 1) * n_x + x;
cells[id].vertices[7] = (z + 1) * n_xy + (y + 1) * n_x + x + 1;
cells[id].material_id = material_id[x][y][z];
- id++;
+ ++id;
}
// create triangulation
cell->face(0)->set_boundary_id(0);
cell->face(2)->set_boundary_id(1);
- cell++;
+ ++cell;
cell->face(1)->set_boundary_id(2);
cell->face(2)->set_boundary_id(1);
cell->face(3)->set_boundary_id(3);
- cell++;
+ ++cell;
cell->face(0)->set_boundary_id(0);
cell->face(1)->set_boundary_id(4);
<< "stroke:rgb(25,25,25); stroke-width:"
<< svg_flags.line_thickness << '}' << '\n';
- labeling_index++;
+ ++labeling_index;
}
}
out << "</text>" << '\n';
- labeling_index++;
+ ++labeling_index;
}
}
for (const auto &face : tria.active_face_iterators())
if ((face->at_boundary()) && (face->boundary_id() != 0))
- n_faces++;
+ ++n_faces;
return n_faces;
}
unsigned int boundary_face_counter = 0;
for (auto f : cell->face_indices())
if (cell->face(f)->at_boundary())
- boundary_face_counter++;
+ ++boundary_face_counter;
if (boundary_face_counter > dim)
{
has_cells_with_more_than_dim_faces_on_boundary = true;
if (has_cells_with_more_than_dim_faces_on_boundary)
{
tria.refine_global(1);
- refinement_cycles++;
+ ++refinement_cycles;
}
}
if (has_cells_with_dim_faces_on_boundary)
{
tria.refine_global(1);
- refinement_cycles++;
+ ++refinement_cycles;
}
else
{
vertex_list_reduced[local_vertex_count] =
vertex_list_all[new_line_table[configuration][i]];
local_remap[new_line_table[configuration][i]] = local_vertex_count;
- local_vertex_count++;
+ ++local_vertex_count;
}
// write back vertices
vertex_indices[count_vertex_indices].first = d;
vertex_indices[count_vertex_indices].second =
unit_point[d] > 0.5 ? 1 : 0;
- count_vertex_indices++;
+ ++count_vertex_indices;
}
else
free_direction = d;
{
for (const unsigned int v : cell->vertex_indices())
vertices_outside_subdomain[cell->vertex_index(v)] = true;
- n_non_predicate_cells++;
+ ++n_non_predicate_cells;
}
// If all the active cells conform to the predicate
while (continue_refinement && (iter < max_iterations))
{
if (max_iterations != numbers::invalid_unsigned_int)
- iter++;
+ ++iter;
continue_refinement = false;
for (const auto &cell : tria.active_cell_iterators())
while (continue_refinement && (iter < max_iterations))
{
- iter++;
+ ++iter;
continue_refinement = false;
for (const auto &cell : tria.active_cell_iterators())
{
subcell_object->vertices != key)
continue;
- counter++;
+ ++counter;
// set manifold id
manifold_id = subcell_object->manifold_id;
}
else
has_invalid = true;
- loc++;
+ ++loc;
}
if (!has_invalid)
indices_has_loc.clear();
}
else
has_invalid = true;
- loc++;
+ ++loc;
}
if (!has_invalid)
indices_want_loc.clear();
}
remotes[cnt].rank = owner;
remotes[cnt].index = idx - ranges[owner];
- cnt++;
+ ++cnt;
}
AssertPETSc(PetscSFCreate(communicator, &sf2));
// check if we need to override the success:
if (state == success)
{
- n_converged_iterations++;
+ ++n_converged_iterations;
if (n_converged_iterations == n_consecutive_iterations)
{
return success;
{
local_index_array[n_columns] = col_indices[j];
local_value_array[n_columns] = value;
- n_columns++;
+ ++n_columns;
}
}
slice_index,
*this,
false);
- slice_index++;
+ ++slice_index;
for (; slice_index < partition_row_index[part + 1];
slice_index++)
{
worker[worker_index]->set_ref_count(1);
- worker_index++;
+ ++worker_index;
worker[worker_index] =
new (worker[worker_index - 1]->allocate_child())
color::PartitionWork(funct,
blocked_worker[(part - 1) / 2]->dummy =
new (worker[worker_index]->allocate_child())
tbb::empty_task;
- worker_index++;
+ ++worker_index;
if (spawn_index_child == -1)
tbb::task::spawn(*blocked_worker[(part - 1) / 2]);
else
new (worker[worker_index]->allocate_child())
MPICommunication(funct, false);
tbb::task::spawn(*worker_dist);
- worker_index++;
+ ++worker_index;
}
part += 1;
if (part < partition_row_index.size() - 1)
slice_index,
*this,
true);
- slice_index++;
+ ++slice_index;
if (slice_index < partition_row_index[part + 1])
{
blocked_worker[part / 2]->set_ref_count(1);
slice_index,
*this,
false);
- slice_index++;
+ ++slice_index;
}
else
{
if (slice_index > partition_row_index[part])
{
worker[worker_index]->set_ref_count(1);
- worker_index++;
+ ++worker_index;
}
worker[worker_index] =
new (worker[worker_index - 1]->allocate_child())
false);
}
spawn_index_child = worker_index;
- worker_index++;
+ ++worker_index;
}
else
{
partition_list[start_up]);
partition_partition_list[counter++] =
partition_list[start_up];
- start_up++;
+ ++start_up;
break;
}
}
neighbor_it->column());
partition_partition_list[counter++] =
neighbor_it->column();
- partition_counter++;
+ ++partition_counter;
}
}
}
if (remaining_per_cell_batch[0] != 0)
{
filled = false;
- missing_macros++;
+ ++missing_macros;
}
}
missing_macros =
.push_back(neighbor->column());
partition_partition_list[counter] =
neighbor->column();
- counter++;
- partition_counter++;
+ ++counter;
+ ++partition_counter;
if (remaining_per_cell_batch
[this_index] == 0 &&
missing_macros > 0)
{
irregular_cells[n_cell_batches_before] =
partition_counter % vectorization_length;
- n_cell_batches_before++;
+ ++n_cell_batches_before;
}
}
}
for (unsigned int color = 0; color <= max_color; ++color)
{
cell_partition_data.push_back(color_counter);
- index_counter++;
+ ++index_counter;
for (unsigned int k = partition_size[part];
k < partition_size[part + 1];
k++)
neighbor_list.push_back(start_up);
partition_list[counter++] = start_up;
partition_size.back()++;
- start_up++;
+ ++start_up;
remainder--;
if (remainder == cluster_size)
remainder = 0;
while (neighbor_list.size() > 0)
{
- partition++;
+ ++partition;
// counter for number of cells so far in current partition
unsigned int partition_counter = 0;
// use as neighbors in next partition
neighbor_neighbor_list.push_back(neighbor->column());
partition_list[counter++] = neighbor->column();
- partition_counter++;
+ ++partition_counter;
}
}
}
}
}
if (remainder != 0)
- partition++;
+ ++partition;
AssertDimension(partition_size[partition], n_blocks);
}
DataOut_DoFData<patch_dim, patch_dim, spacedim, spacedim>::
DataVectorType::type_dof_data);
- counter++;
+ ++counter;
}
}
if (boundary_value.first >= matrix.block(block, 0).m() + offset)
{
offset += matrix.block(block, 0).m();
- block++;
+ ++block;
}
const types::global_dof_index index = boundary_value.first - offset;
block_boundary_values[block].insert(
if (boundary_value.first >= matrix.block(block, 0).m() + offset)
{
offset += matrix.block(block, 0).m();
- block++;
+ ++block;
}
const types::global_dof_index index =
boundary_value.first - offset;
.push_back(
internal::ElementAccess<VectorType>::get(solution,
solution_index));
- store_index++;
+ ++store_index;
}
}
}
data_store_field
->second[data_store_index * n_stored + store_index]
.push_back(computed_quantities[0](comp));
- store_index++;
+ ++store_index;
}
}
}
data_store_field
->second[data_store_index * n_stored + store_index]
.push_back(value(comp));
- store_index++;
+ ++store_index;
}
}
}
parallel_triangulation->get_communicator(),
&(requests[send_ops]));
AssertThrowMPI(ierr);
- send_ops++;
+ ++send_ops;
}
for (unsigned int i = 0; i < n_neighbors; ++i)
parallel_triangulation->get_communicator(),
&(requests[send_ops + recv_ops]));
AssertThrowMPI(ierr);
- recv_ops++;
+ ++recv_ops;
}
const int ierr =
MPI_Waitall(send_ops + recv_ops, requests.data(), MPI_STATUSES_IGNORE);
parallel_triangulation->get_communicator(),
&(requests[send_ops]));
AssertThrowMPI(ierr);
- send_ops++;
+ ++send_ops;
}
for (unsigned int i = 0; i < neighbors.size(); ++i)
parallel_triangulation->get_communicator(),
&(requests[send_ops + recv_ops]));
AssertThrowMPI(ierr);
- recv_ops++;
+ ++recv_ops;
}
const int ierr =
MPI_Waitall(send_ops + recv_ops, requests.data(), MPI_STATUSES_IGNORE);
while (solver_should_restart(t, solution, solution_dot))
reset(t, h, solution, solution_dot);
- step_number++;
+ ++step_number;
output_step(t, solution, solution_dot, step_number);
}
projects / dealii.git / commitdiff