// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2013 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
/**
* @page GlobalDoFIndex When to use types::global_dof_index instead of unsigned int
*
* deal.II can be configured to use 64-bit indices for degrees of freedom,
* rather than the usual unsigned integers that default to 32-bit on most
* current systems. This is necessary since we want to be able to solve
* problems with more than 4 billion unknowns (the limit of what can be
* represented with 32-bit unsigned integers). At the same time, we do not
* want to indiscriminately replace all integers in deal.II with 64-bit
* versions, since this would increase memory use in many places where we
* represent quantities that will most definitely not be larger than 4 billion.
*
* The data type we define for these indices to keep the bulk
* of the code base free of \#ifdefs is types::global_dof_index.
* If deal.II is configured as normal, this type is unsigned int,
* but can be switched to unsigned long long int if the right
* flag is provided (see the ReadMe file). This page is intended to clarify
* when types::global_dof_index must be used and when one can use a regular
* unsigned integer:
*
*
*
* - @anchor GlobalDoFIndexBlockIndices
* BlockIndices
* -
* The number of blocks is an unsigned int because the number is expected to
* be low, i.e less than four billions. However, the size of the block is a
* types::global_dof_index because each block can be arbitrary large.
*
*
* - @anchor GlobalDoFIndexCell Cell
* -
* The ID of cell is not unique: Cells with different levels of refinement
* and/or on different processors can have the same ID. Thus, all the data
* associated to cells can be unsigned int because on a single processor,
* one one mesh level, there will definitely not be more than 4 billion
* cells.
*
*
* - @anchor GlobalDoFIndexDoFHandler
* DoFHandler
* -
* The ID of each degree of freedom is unique in a parallel computation.
* Therefore, degrees of freedom
* are types::global_dof_index.
*
*
* - @anchor GlobalDoFIndexFullMatrix
* FullMatrix
* -
* The numbers of row and column are types::global_dof_index even if it is not
* expected that someone will create a FullMatrix with so many entries.
* However, some methods of the AffineConstraints class are templated on
* the matrix type and thus, the size of a FullMatrix has to be of the same
* type than the size of SparseMatrix.
*
*
* - @anchor GlobalDoFIndexSparseMatrix
* SparseMatrix
* -
* The size of SparseMatrix can be arbitrary large and it is conceivable that
* with sufficient memory on a single node, one may generate a matrix with
* more than 4 billion rows or columns. Therefore, types::global_dof_index is
* used. However, even for a large complex problem we can solve now, it is not
* reasonable to expect the number of non-zero entries in a sparse matrix to
* go over four billion. Thus, we still use unsigned int for, e.g.,
* SparsityPattern::row_lengths and similar functions.
*
*
*
*/