 |
Reference documentation for deal.II version 9.1.1
|
|
Reference documentation for deal.II version 9.1.1
|
This module contains classes that are used in the exception mechanism of deal.II. More...
Modules | |
| TrilinosWrappers | |
The classes in this module are wrappers around functionality provided by the Trilinos library. They provide a modern object-oriented interface that is compatible with the interfaces of the other linear algebra classes in deal.II. All classes and functions in this group reside in a namespace TrilinosWrappers. | |
Namespaces | |
| StandardExceptions | |
| deal_II_exceptions | |
| deal_II_exceptions::internals | |
| Patterns::Tools | |
Macros | |
| #define | DeclException0(Exception0) |
| #define | DeclExceptionMsg(Exception, defaulttext) |
| #define | DeclException1(Exception1, type1, outsequence) |
| #define | DeclException2(Exception2, type1, type2, outsequence) |
| #define | DeclException3(Exception3, type1, type2, type3, outsequence) |
| #define | DeclException4(Exception4, type1, type2, type3, type4, outsequence) |
| #define | DeclException5( Exception5, type1, type2, type3, type4, type5, outsequence) |
| #define | Assert(cond, exc) |
| #define | AssertNothrow(cond, exc) |
| #define | AssertThrow(cond, exc) |
| #define | AssertDimension(dim1, dim2) |
| #define | AssertVectorVectorDimension(VEC, DIM1, DIM2) |
| #define | AssertIndexRange(index, range) |
| #define | AssertIsFinite(number) |
| #define | AssertThrowMPI(error_code) AssertThrow(error_code == MPI_SUCCESS, ::ExcMPI(error_code)) |
| #define | AssertCuda(error_code) |
| #define | AssertNothrowCuda(error_code) |
| #define | AssertCusparse(error_code) |
| #define | AssertNothrowCusparse(error_code) |
| #define | AssertCusolver(error_code) |
Friends | |
| class | MultipleParameterLoop |
| template<typename , bool > | |
| class | BlockMatrixBase< MatrixType >::BlockMatrixIterators::Accessor |
| template<typename > | |
| class | MatrixIterator |
| template<typename number > | |
| class | BlockSparsityPatternBase< SparsityPatternType >::BlockSparseMatrix |
| template<typename , bool > | |
| class | internal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::Iterator |
| template<typename N , bool C> | |
| class | BlockVectorBase< VectorType >::::internal::BlockVectorIterators::Iterator |
| template<typename > | |
| class | BlockVectorBase |
| template<typename > | |
| class | ChunkSparsityPattern::ChunkSparseMatrix |
| class | ChunkSparsityPattern::ChunkSparsityPatternIterators::Accessor |
| class | PETScWrappers::MPI::SparseMatrix::BlockMatrixBase< SparseMatrix > |
| class | PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::const_iterator |
| class | SparseMatrixEZ< number >::const_iterator::Accessor::const_iterator |
Data storage and access | |
| static ::ExceptionBase & | GeneralDataStorage::ExcNameNotFound (std::string arg1) |
| static ::ExceptionBase & | GeneralDataStorage::ExcNameHasBeenFound (std::string arg1) |
| static ::ExceptionBase & | GeneralDataStorage::ExcTypeMismatch (std::string arg1, const char *arg2, const char *arg3) |
Deprecated Tensor operations | |
| static ::ExceptionBase & | ExcInvalidTensorContractionIndex (int arg1) |
| template<int dim, typename Number > | |
| Number | double_contract (const Tensor< 2, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
| template<int dim, typename Number > | |
| void | double_contract (Tensor< 2, dim, Number > &dest, const Tensor< 4, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
| template<int dim, typename Number > | |
| void | contract (Tensor< 2, dim, Number > &dest, const Tensor< 2, dim, Number > &src1, const unsigned int index1, const Tensor< 2, dim, Number > &src2, const unsigned int index3) |
| template<int dim, typename Number > | |
| void | contract (Tensor< 2, dim, Number > &dest, const Tensor< 3, dim, Number > &src1, const unsigned int index1, const Tensor< 1, dim, Number > &src2) |
| template<int dim, typename Number > | |
| void | contract (Tensor< 3, dim, Number > &dest, const Tensor< 3, dim, Number > &src1, const unsigned int index1, const Tensor< 2, dim, Number > &src2, const unsigned int index2) |
| template<int rank_1, int rank_2, int dim, typename Number > | |
| 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) |
| template<int dim, typename Number , typename OtherNumber > | |
| ProductType< Number, OtherNumber >::type | contract (const Tensor< 1, dim, Number > &src1, const Tensor< 1, dim, OtherNumber > &src2) |
| template<int dim, typename Number > | |
| void | cross_product (Tensor< 1, dim, Number > &dst, const Tensor< 1, dim, Number > &src) |
| template<int dim, typename Number > | |
| void | cross_product (Tensor< 1, dim, Number > &dst, const Tensor< 1, dim, Number > &src1, const Tensor< 1, dim, Number > &src2) |
| template<int rank_1, int rank_2, int dim, typename Number > | |
| void | outer_product (Tensor< rank_1+rank_2, dim, Number > &dst, const Tensor< rank_1, dim, Number > &src1, const Tensor< rank_2, dim, Number > &src2) |
| template<int dim, typename Number > | |
| void | outer_product (Tensor< 1, dim, Number > &dst, const Number src1, const Tensor< 1, dim, Number > &src2) |
| template<int dim, typename Number > | |
| void | outer_product (Tensor< 1, dim, Number > &dst, const Tensor< 1, dim, Number > src1, const Number src2) |
| template<int rank, typename Number > | |
| Number | determinant (const Tensor< rank, 1, Number > &t) |
| template<typename Number > | |
| Number | determinant (const Tensor< 1, 1, Number > &t) |
Bitwise operators | |
| std::ostream & | Differentiation::SD::operator<< (std::ostream &stream, const Expression &expression) |
| std::istream & | Differentiation::SD::operator>> (std::istream &stream, Expression &expression) |
Comparison operators | |
| Expression | Differentiation::SD::operator== (const Expression &lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator!= (const Expression &lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator< (const Expression &lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator> (const Expression &lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator<= (const Expression &lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator>= (const Expression &lhs, const Expression &rhs) |
Logical operators | |
| Expression | Differentiation::SD::operator! (const Expression &expression) |
| Expression | Differentiation::SD::operator& (const Expression &lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator| (const Expression &lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator^ (const Expression &lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator&& (const Expression &lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator|| (const Expression &lhs, const Expression &rhs) |
Mathematical operators | |
| Expression | Differentiation::SD::operator+ (Expression lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator- (Expression lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator* (Expression lhs, const Expression &rhs) |
| Expression | Differentiation::SD::operator/ (Expression lhs, const Expression &rhs) |
| template<typename NumberType , typename = typename std::enable_if< std::is_constructible<Expression, NumberType>::value>::type> | |
| Expression | Differentiation::SD::operator+ (const NumberType &lhs, const Expression &rhs) |
| template<typename NumberType , typename = typename std::enable_if< std::is_constructible<Expression, NumberType>::value>::type> | |
| Expression | Differentiation::SD::operator+ (const Expression &lhs, const NumberType &rhs) |
| template<typename NumberType , typename = typename std::enable_if< std::is_constructible<Expression, NumberType>::value>::type> | |
| Expression | Differentiation::SD::operator- (const NumberType &lhs, const Expression &rhs) |
| template<typename NumberType , typename = typename std::enable_if< std::is_constructible<Expression, NumberType>::value>::type> | |
| Expression | Differentiation::SD::operator- (const Expression &lhs, const NumberType &rhs) |
| template<typename NumberType , typename = typename std::enable_if< std::is_constructible<Expression, NumberType>::value>::type> | |
| Expression | Differentiation::SD::operator* (const NumberType &lhs, const Expression &rhs) |
| template<typename NumberType , typename = typename std::enable_if< std::is_constructible<Expression, NumberType>::value>::type> | |
| Expression | Differentiation::SD::operator* (const Expression &lhs, const NumberType &rhs) |
| template<typename NumberType , typename = typename std::enable_if< std::is_constructible<Expression, NumberType>::value>::type> | |
| Expression | Differentiation::SD::operator/ (const NumberType &lhs, const Expression &rhs) |
| template<typename NumberType , typename = typename std::enable_if< std::is_constructible<Expression, NumberType>::value>::type> | |
| Expression | Differentiation::SD::operator/ (const Expression &lhs, const NumberType &rhs) |
Constructors | |
| Differentiation::SD::Expression::Expression () | |
| Differentiation::SD::Expression::Expression (const bool &value) | |
| template<typename NumberType , typename = typename std::enable_if< std::is_arithmetic<NumberType>::value>::type> | |
| Differentiation::SD::Expression::Expression (const NumberType &value) | |
| template<typename NumberType , typename = typename std::enable_if< std::is_arithmetic<NumberType>::value>::type> | |
| Differentiation::SD::Expression::Expression (const std::complex< NumberType > &value) | |
| Differentiation::SD::Expression::Expression (const SymEngine::integer_class &value) | |
| template<typename NumberType , typename = typename std::enable_if< std::is_integral<NumberType>::value>::type> | |
| Differentiation::SD::Expression::Expression (const NumberType &numerator, const NumberType &denominator) | |
| Differentiation::SD::Expression::Expression (const SymEngine::rational_class &value) | |
| Differentiation::SD::Expression::Expression (const Expression &condition, const Expression &expression_if_true, const Expression &expression_if_false) | |
| Differentiation::SD::Expression::Expression (const std::vector< std::pair< Expression, Expression >> &condition_expression, const Expression &expression_otherwise) | |
| Differentiation::SD::Expression::Expression (const std::vector< std::pair< Expression, Expression >> &condition_expression) | |
| Differentiation::SD::Expression::Expression (const char *symbol) | |
| Differentiation::SD::Expression::Expression (const std::string &symb_expr, const bool parse_as_expression=false) | |
| Differentiation::SD::Expression::Expression (const std::string &symbol_func, const types::symbol_vector &arguments) | |
| Differentiation::SD::Expression::Expression (const Expression &rhs)=default | |
| Differentiation::SD::Expression::Expression (const SymEngine::Expression &rhs) | |
| Differentiation::SD::Expression::Expression (const SymEngine::RCP< const SymEngine::Basic > &rhs) | |
| Differentiation::SD::Expression::Expression (Expression &&rhs)=default | |
| Differentiation::SD::Expression::Expression (SymEngine::RCP< const SymEngine::Basic > &&rhs) | |
| virtual | Differentiation::SD::Expression::~Expression ()=default |
| Expression & | Differentiation::SD::Expression::parse (const std::string &expression) |
| std::ostream & | Differentiation::SD::Expression::print (std::ostream &stream) const |
| void | Differentiation::SD::Expression::save (std::ostream &stream) const |
| void | Differentiation::SD::Expression::load (std::istream &stream) |
| template<class Archive > | |
| void | Differentiation::SD::Expression::serialize (Archive &archive, const unsigned int version) |
Values | |
| const SymEngine::Expression & | Differentiation::SD::Expression::get_expression () const |
| const SymEngine::Basic & | Differentiation::SD::Expression::get_value () const |
| const SymEngine::RCP< const SymEngine::Basic > & | Differentiation::SD::Expression::get_RCP () const |
Math and relational operators with (potentially) symbolic types | |
| Expression & | Differentiation::SD::Expression::operator= (const Expression &rhs) |
| Expression & | Differentiation::SD::Expression::operator= (Expression &&rhs) |
| Expression & | Differentiation::SD::Expression::operator+= (const Expression &rhs) |
| Expression & | Differentiation::SD::Expression::operator-= (const Expression &rhs) |
| Expression & | Differentiation::SD::Expression::operator*= (const Expression &rhs) |
| Expression & | Differentiation::SD::Expression::operator/= (const Expression &rhs) |
Math and relational operators with numeric types | |
| template<typename NumberType > | |
| Expression & | Differentiation::SD::Expression::operator= (const NumberType &rhs) |
| Expression | Differentiation::SD::Expression::operator- () const |
| template<typename NumberType > | |
| Expression & | Differentiation::SD::Expression::operator+= (const NumberType &rhs) |
| template<typename NumberType > | |
| Expression & | Differentiation::SD::Expression::operator-= (const NumberType &rhs) |
| template<typename NumberType > | |
| Expression & | Differentiation::SD::Expression::operator*= (const NumberType &rhs) |
| template<typename NumberType > | |
| Expression & | Differentiation::SD::Expression::operator/= (const NumberType &rhs) |
Differentiation | |
| Expression | Differentiation::SD::Expression::differentiate (const Expression &symbol) const |
| Expression | Differentiation::SD::Expression::differentiate (const SymEngine::RCP< const SymEngine::Symbol > &symbol) const |
| Expression | Differentiation::SD::Expression::differentiate (const SymEngine::RCP< const SymEngine::Basic > &symbol) const |
Dictionary-based substitution | |
| Expression | Differentiation::SD::Expression::substitute (const types::substitution_map &substitution_values) const |
| Expression | Differentiation::SD::Expression::substitute (const Expression &symbol, const Expression &value) const |
| template<typename NumberType > | |
| Expression | Differentiation::SD::Expression::substitute (const Expression &symbol, const NumberType &value) const |
| template<typename ReturnType > | |
| ReturnType | Differentiation::SD::Expression::substitute_and_evaluate (const types::substitution_map &substitution_values) const |
Conversion operators | |
| SymEngine::Expression | Differentiation::SD::Expression::expression |
| template<typename ResultType > | |
| Differentiation::SD::Expression::operator ResultType () const | |
| Differentiation::SD::Expression::operator const SymEngine::Expression & () const | |
| Differentiation::SD::Expression::operator const SymEngine::RCP< const SymEngine::Basic > & () const | |
| SymEngine::Expression & | Differentiation::SD::Expression::get_expression () |
Cell iterator functions returning ranges of iterators | |
| static ::ExceptionBase & | DoFHandler< dim, spacedim >::ExcGridsDoNotMatch () |
| static ::ExceptionBase & | DoFHandler< dim, spacedim >::ExcInvalidBoundaryIndicator () |
| static ::ExceptionBase & | DoFHandler< dim, spacedim >::ExcNewNumbersNotConsecutive (types::global_dof_index arg1) |
| static ::ExceptionBase & | DoFHandler< dim, spacedim >::ExcInvalidLevel (int arg1) |
| static ::ExceptionBase & | DoFHandler< dim, spacedim >::ExcFacesHaveNoLevel () |
| static ::ExceptionBase & | DoFHandler< dim, spacedim >::ExcEmptyLevel (int arg1) |
Exceptions | |
| static ::ExceptionBase & | DoFTools::ExcFiniteElementsDontMatch () |
| static ::ExceptionBase & | DoFTools::ExcGridNotCoarser () |
| static ::ExceptionBase & | DoFTools::ExcGridsDontMatch () |
| static ::ExceptionBase & | DoFTools::ExcNoFESelected () |
| static ::ExceptionBase & | DoFTools::ExcInvalidBoundaryIndicator () |
Support points and interpolation | |
| static ::ExceptionBase & | FiniteElement< dim, spacedim >::ExcShapeFunctionNotPrimitive (int arg1) |
| static ::ExceptionBase & | FiniteElement< dim, spacedim >::ExcFENotPrimitive () |
| static ::ExceptionBase & | FiniteElement< dim, spacedim >::ExcUnitShapeValuesDoNotExist () |
| static ::ExceptionBase & | FiniteElement< dim, spacedim >::ExcFEHasNoSupportPoints () |
| static ::ExceptionBase & | FiniteElement< dim, spacedim >::ExcEmbeddingVoid () |
| static ::ExceptionBase & | FiniteElement< dim, spacedim >::ExcProjectionVoid () |
| static ::ExceptionBase & | FiniteElement< dim, spacedim >::ExcWrongInterfaceMatrixSize (int arg1, int arg2) |
| static ::ExceptionBase & | FiniteElement< dim, spacedim >::ExcInterpolationNotImplemented () |
Functions to support hp | |
| static ::ExceptionBase & | FE_Q_Base< PolynomialType, dim, spacedim >::ExcFEQCannotHaveDegree0 () |
Functions which should be in DoFTools | |
| static ::ExceptionBase & | FETools::ExcInvalidFEName (std::string arg1) |
| static ::ExceptionBase & | FETools::ExcInvalidFEDimension (char arg1, int arg2) |
| static ::ExceptionBase & | FETools::ExcInvalidFE () |
| static ::ExceptionBase & | FETools::ExcFENotPrimitive () |
| static ::ExceptionBase & | FETools::ExcTriangulationMismatch () |
| static ::ExceptionBase & | FETools::ExcHangingNodesNotAllowed () |
| static ::ExceptionBase & | FETools::ExcGridNotRefinedAtLeastOnce () |
| static ::ExceptionBase & | FETools::ExcMatrixDimensionMismatch (int arg1, int arg2, int arg3, int arg4) |
| static ::ExceptionBase & | FETools::ExcLeastSquaresError (double arg1) |
| static ::ExceptionBase & | FETools::ExcNotGreaterThan (int arg1, int arg2) |
Access to the raw data | |
| static ::ExceptionBase & | FEValuesBase< dim, spacedim >::ExcAccessToUninitializedField (std::string arg1) |
| static ::ExceptionBase & | FEValuesBase< dim, spacedim >::ExcFEDontMatch () |
| static ::ExceptionBase & | FEValuesBase< dim, spacedim >::ExcShapeFunctionNotPrimitive (int arg1) |
| static ::ExceptionBase & | FEValuesBase< dim, spacedim >::ExcFENotPrimitive () |
Exceptions | |
| static ::ExceptionBase & | Mapping< dim, spacedim >::ExcInvalidData () |
| static ::ExceptionBase & | Mapping< dim, spacedim >::ExcTransformationFailed () |
| static ::ExceptionBase & | Mapping< dim, spacedim >::ExcDistortedMappedCell (Point< spacedim > arg1, double arg2, int arg3) |
Exceptions | |
| static ::ExceptionBase & | GridGenerator::ExcInvalidRadii () |
| static ::ExceptionBase & | GridGenerator::ExcInvalidRepetitions (int arg1) |
| static ::ExceptionBase & | GridGenerator::ExcInvalidRepetitionsDimension (int arg1) |
| static ::ExceptionBase & | GridGenerator::ExcInvalidInputOrientation () |
Exceptions | |
| static ::ExceptionBase & | GridTools::ExcInvalidNumberOfPartitions (int arg1) |
| static ::ExceptionBase & | GridTools::ExcNonExistentSubdomain (int arg1) |
| static ::ExceptionBase & | GridTools::ExcTriangulationHasBeenRefined () |
| static ::ExceptionBase & | GridTools::ExcScalingFactorNotPositive (double arg1) |
| template<int N> | |
| static ::ExceptionBase & | GridTools::ExcPointNotFoundInCoarseGrid (Point< N > arg1) |
| template<int N> | |
| static ::ExceptionBase & | GridTools::ExcPointNotFound (Point< N > arg1) |
| static ::ExceptionBase & | GridTools::ExcVertexNotUsed (unsigned int arg1) |
Exceptions | |
| static ::ExceptionBase & | Triangulation< dim, spacedim >::ExcInvalidLevel (int arg1, int arg2) |
| static ::ExceptionBase & | Triangulation< dim, spacedim >::ExcTriangulationNotEmpty (int arg1, int arg2) |
| static ::ExceptionBase & | Triangulation< dim, spacedim >::ExcGridReadError () |
| static ::ExceptionBase & | Triangulation< dim, spacedim >::ExcFacesHaveNoLevel () |
| static ::ExceptionBase & | Triangulation< dim, spacedim >::ExcEmptyLevel (int arg1) |
| static ::ExceptionBase & | Triangulation< dim, spacedim >::ExcNonOrientableTriangulation () |
| static ::ExceptionBase & | Triangulation< dim, spacedim >::ExcBoundaryIdNotFound (types::boundary_id arg1) |
Exceptions | |
| static ::ExceptionBase & | TriaRawIterator< Accessor >::ExcDereferenceInvalidCell (Accessor arg1) |
| static ::ExceptionBase & | TriaRawIterator< Accessor >::ExcDereferenceInvalidObject (Accessor arg1) |
| static ::ExceptionBase & | TriaRawIterator< Accessor >::ExcAdvanceInvalidObject () |
| static ::ExceptionBase & | TriaRawIterator< Accessor >::ExcInvalidComparison () |
Advancement of iterators | |
| static ::ExceptionBase & | TriaIterator< Accessor >::ExcAssignmentOfUnusedObject () |
Advancement of iterators | |
| static ::ExceptionBase & | TriaActiveIterator< Accessor >::ExcAssignmentOfInactiveObject () |
Cell iterator functions returning ranges of iterators | |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcNoFESelected () |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcGridsDoNotMatch () |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcInvalidBoundaryIndicator () |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcMatrixHasWrongSize (int arg1) |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcFunctionNotUseful () |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcNewNumbersNotConsecutive (types::global_dof_index arg1) |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcInvalidFEIndex (int arg1, int arg2) |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcInvalidLevel (int arg1) |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcFacesHaveNoLevel () |
| static ::ExceptionBase & | hp::DoFHandler< dim, spacedim >::ExcEmptyLevel (int arg1) |
Input/Output | |
| SmartPointer< const BlockSparsityPattern, BlockSparseMatrix< number > > | BlockSparseMatrix< number >::sparsity_pattern |
| static ::ExceptionBase & | BlockSparseMatrix< number >::ExcBlockDimensionMismatch () |
| void | BlockSparseMatrix< number >::print_formatted (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const unsigned int width=0, const char *zero_string=" ", const double denominator=1.) const |
Multiplications | |
| static ::ExceptionBase & | FullMatrix< number >::ExcEmptyMatrix () |
| static ::ExceptionBase & | FullMatrix< number >::ExcNotRegular (number arg1) |
| static ::ExceptionBase & | FullMatrix< number >::ExcInvalidDestination (size_type arg1, size_type arg2, size_type arg3) |
| static ::ExceptionBase & | FullMatrix< number >::ExcSourceEqualsDestination () |
| static ::ExceptionBase & | FullMatrix< number >::ExcMatrixNotPositiveDefinite () |
2: Implementation of VectorSpaceVector | |
| static ::ExceptionBase & | LinearAlgebra::distributed::BlockVector< Number >::ExcVectorTypeNotCompatible () |
| static ::ExceptionBase & | LinearAlgebra::distributed::BlockVector< Number >::ExcIteratorRangeDoesNotMatchVectorSize () |
6: Mixed stuff | |
| static ::ExceptionBase & | LinearAlgebra::distributed::Vector< Number, MemorySpace >::ExcVectorTypeNotCompatible () |
| static ::ExceptionBase & | LinearAlgebra::distributed::Vector< Number, MemorySpace >::ExcNotAllowedForCuda () |
| static ::ExceptionBase & | LinearAlgebra::distributed::Vector< Number, MemorySpace >::ExcNonMatchingElements (Number arg1, Number arg2, unsigned int arg3) |
| static ::ExceptionBase & | LinearAlgebra::distributed::Vector< Number, MemorySpace >::ExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4) |
Input/Output | |
| SmartPointer< const SparsityPattern, SparseMatrix< number > > | SparseMatrix< number >::cols |
| std::unique_ptr< number[]> | SparseMatrix< number >::val |
| std::size_t | SparseMatrix< number >::max_len |
| template<typename somenumber > | |
| class | SparseMatrix< number >::SparseMatrix |
| template<typename somenumber > | |
| class | SparseLUDecomposition |
| template<typename > | |
| class | SparseILU |
| template<typename > | |
| class | SparseMatrix< number >::BlockMatrixBase |
| template<typename , bool > | |
| class | SparseMatrix< number >::SparseMatrixIterators::Iterator |
| template<typename , bool > | |
| class | SparseMatrixIterators::Accessor |
| template<typename Number > | |
| void | SparseMatrix< number >::Utilities::MPI::sum (const SparseMatrix< Number > &, const MPI_Comm &, SparseMatrix< Number > &) |
| static ::ExceptionBase & | SparseMatrix< number >::ExcInvalidIndex (int arg1, int arg2) |
| static ::ExceptionBase & | SparseMatrix< number >::ExcDifferentSparsityPatterns () |
| static ::ExceptionBase & | SparseMatrix< number >::ExcIteratorRange (int arg1, int arg2) |
| static ::ExceptionBase & | SparseMatrix< number >::ExcSourceEqualsDestination () |
| void | SparseMatrix< number >::prepare_add () |
| void | SparseMatrix< number >::prepare_set () |
| template<class StreamType > | |
| void | SparseMatrix< number >::print (StreamType &out, const bool across=false, const bool diagonal_first=true) const |
| void | SparseMatrix< number >::print_formatted (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const unsigned int width=0, const char *zero_string=" ", const double denominator=1.) const |
| void | SparseMatrix< number >::print_pattern (std::ostream &out, const double threshold=0.) const |
| void | SparseMatrix< number >::block_write (std::ostream &out) const |
| void | SparseMatrix< number >::block_read (std::istream &in) |
Input/Output | |
| size_type | SparseMatrixEZ< number >::n_columns |
| std::vector< RowInfo > | SparseMatrixEZ< number >::row_info |
| std::vector< Entry > | SparseMatrixEZ< number >::data |
| unsigned int | SparseMatrixEZ< number >::increment |
| unsigned int | SparseMatrixEZ< number >::saved_default_row_length |
| static ::ExceptionBase & | SparseMatrixEZ< number >::ExcNoDiagonal () |
| static ::ExceptionBase & | SparseMatrixEZ< number >::ExcInvalidEntry (int arg1, int arg2) |
| static ::ExceptionBase & | SparseMatrixEZ< number >::ExcEntryAllocationFailure (int arg1, int arg2) |
| const Entry * | SparseMatrixEZ< number >::locate (const size_type row, const size_type col) const |
| Entry * | SparseMatrixEZ< number >::locate (const size_type row, const size_type col) |
| Entry * | SparseMatrixEZ< number >::allocate (const size_type row, const size_type col) |
| template<typename somenumber > | |
| void | SparseMatrixEZ< number >::threaded_vmult (Vector< somenumber > &dst, const Vector< somenumber > &src, const size_type begin_row, const size_type end_row) const |
| template<typename somenumber > | |
| void | SparseMatrixEZ< number >::threaded_matrix_norm_square (const Vector< somenumber > &v, const size_type begin_row, const size_type end_row, somenumber *partial_sum) const |
| template<typename somenumber > | |
| void | SparseMatrixEZ< number >::threaded_matrix_scalar_product (const Vector< somenumber > &u, const Vector< somenumber > &v, const size_type begin_row, const size_type end_row, somenumber *partial_sum) const |
| void | SparseMatrixEZ< number >::print (std::ostream &out) const |
| void | SparseMatrixEZ< number >::print_formatted (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const unsigned int width=0, const char *zero_string=" ", const double denominator=1.) const |
| void | SparseMatrixEZ< number >::block_write (std::ostream &out) const |
| void | SparseMatrixEZ< number >::block_read (std::istream &in) |
Input/Output | |
| size_type | SparsityPatternBase::max_dim |
| size_type | SparsityPatternBase::rows |
| size_type | SparsityPatternBase::cols |
| std::size_t | SparsityPatternBase::max_vec_len |
| unsigned int | SparsityPatternBase::max_row_length |
| std::unique_ptr< std::size_t[]> | SparsityPatternBase::rowstart |
| std::unique_ptr< size_type[]> | SparsityPatternBase::colnums |
| bool | SparsityPatternBase::compressed |
| template<typename number > | |
| class | SparsityPatternBase::SparseMatrix |
| template<typename number > | |
| class | SparseLUDecomposition |
| template<typename number > | |
| class | SparseILU |
| template<typename number > | |
| class | ChunkSparseMatrix |
| class | ChunkSparsityPattern |
| class | DynamicSparsityPattern |
| class | SparsityPatternBase::SparsityPatternIterators::Iterator |
| class | SparsityPatternIterators::Accessor |
| class | ChunkSparsityPatternIterators::Accessor |
| static ::ExceptionBase & | SparsityPatternBase::ExcNotCompressed () |
| static ::ExceptionBase & | SparsityPatternBase::ExcNotEnoughSpace (int arg1, int arg2) |
| static ::ExceptionBase & | SparsityPatternBase::ExcMatrixIsCompressed () |
| void | SparsityPatternBase::print (std::ostream &out) const |
| void | SparsityPatternBase::print_gnuplot (std::ostream &out) const |
| void | SparsityPatternBase::print_svg (std::ostream &out) const |
| template<class Archive > | |
| void | SparsityPatternBase::save (Archive &ar, const unsigned int version) const |
| template<class Archive > | |
| void | SparsityPatternBase::load (Archive &ar, const unsigned int version) |
Construction and setup | |
Constructors, destructor, functions initializing, copying and filling an object. | |
| SparsityPattern::SparsityPattern () | |
| SparsityPattern::SparsityPattern (const SparsityPattern &) | |
| SparsityPattern::SparsityPattern (const size_type m, const size_type n, const unsigned int max_per_row) | |
| SparsityPattern::SparsityPattern (const size_type m, const size_type n, const std::vector< unsigned int > &row_lengths) | |
| SparsityPattern::SparsityPattern (const size_type m, const unsigned int max_per_row) | |
| SparsityPattern::SparsityPattern (const size_type m, const std::vector< unsigned int > &row_lengths) | |
| SparsityPattern::SparsityPattern (const SparsityPattern &original, const unsigned int max_per_row, const size_type extra_off_diagonals) | |
| SparsityPattern::~SparsityPattern () override=default | |
| SparsityPattern & | SparsityPattern::operator= (const SparsityPattern &) |
| virtual void | SparsityPattern::reinit (const size_type m, const size_type n, const ArrayView< const unsigned int > &row_lengths) override |
| void | SparsityPattern::compress () |
| template<typename ForwardIterator > | |
| void | SparsityPattern::copy_from (const size_type n_rows, const size_type n_cols, const ForwardIterator begin, const ForwardIterator end) |
| void | SparsityPattern::copy_from (const DynamicSparsityPattern &dsp) |
| void | SparsityPattern::copy_from (const SparsityPattern &sp) |
| template<typename number > | |
| void | SparsityPattern::copy_from (const FullMatrix< number > &matrix) |
| template<typename ForwardIterator > | |
| void | SparsityPattern::add_entries (const size_type row, ForwardIterator begin, ForwardIterator end, const bool indices_are_sorted=false) |
Querying information | |
| bool | SparsityPattern::operator== (const SparsityPattern &) const |
| bool | SparsityPattern::stores_only_added_elements () const |
| std::size_t | SparsityPattern::memory_consumption () const |
Accessing entries | |
| size_type | SparsityPattern::operator() (const size_type i, const size_type j) const |
Input/Output | |
| bool | SparsityPattern::store_diagonal_first_in_row |
| template<typename number > | |
| class | SparsityPattern::SparseMatrix |
| template<typename number > | |
| class | SparseLUDecomposition |
| template<typename number > | |
| class | SparseILU |
| template<typename number > | |
| class | ChunkSparseMatrix |
| class | ChunkSparsityPattern |
| class | DynamicSparsityPattern |
| class | SparsityPattern::SparsityPatternIterators::Iterator |
| class | SparsityPatternIterators::Accessor |
| class | ChunkSparsityPatternIterators::Accessor |
| void | SparsityPattern::block_write (std::ostream &out) const |
| void | SparsityPattern::block_read (std::istream &in) |
| template<class Archive > | |
| void | SparsityPattern::save (Archive &ar, const unsigned int version) const |
| template<class Archive > | |
| void | SparsityPattern::load (Archive &ar, const unsigned int version) |
| static ::ExceptionBase & | SparsityPattern::ExcIteratorRange (int arg1, int arg2) |
| static ::ExceptionBase & | SparsityPattern::ExcInvalidNumberOfPartitions (int arg1) |
Partitioners | |
| static ::ExceptionBase & | TrilinosWrappers::PreconditionBase::ExcNonMatchingMaps (std::string arg1) |
Input/Output | |
| static ::ExceptionBase & | TrilinosWrappers::SparseMatrix::ExcTrilinosError (int arg1) |
| static ::ExceptionBase & | TrilinosWrappers::SparseMatrix::ExcInvalidIndex (size_type arg1, size_type arg2) |
| static ::ExceptionBase & | TrilinosWrappers::SparseMatrix::ExcSourceEqualsDestination () |
| static ::ExceptionBase & | TrilinosWrappers::SparseMatrix::ExcMatrixNotCompressed () |
| static ::ExceptionBase & | TrilinosWrappers::SparseMatrix::ExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4) |
| static ::ExceptionBase & | TrilinosWrappers::SparseMatrix::ExcAccessToNonPresentElement (size_type arg1, size_type arg2) |
4: Mixed stuff | |
| static ::ExceptionBase & | TrilinosWrappers::MPI::Vector::ExcDifferentParallelPartitioning () |
| static ::ExceptionBase & | TrilinosWrappers::MPI::Vector::ExcTrilinosError (int arg1) |
| static ::ExceptionBase & | TrilinosWrappers::MPI::Vector::ExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4) |
Evaluation of functions and errors | |
| static ::ExceptionBase & | VectorTools::ExcPointNotAvailableHere () |
This module contains classes that are used in the exception mechanism of deal.II.
Exceptions are used in two different ways:
Static assertions: These are checks that are only enabled in debug mode, not in release (or optimized, production) mode. In deal.II, static assertions are typically used to check that parameters to functions satisfy certain properties, that internal data structures are consistent, and similar assertions. For example, static assertions are used to make sure that two vectors that are added together have the same number of components – everything else would not make any sense anyway.
Such checks are performed by the Assert macro in several thousand places within the library. Also, several tutorial programs starting with step-5 show how to do this.
If a static assertion is violated, the exception mechanism generates an exception of a type that indicates what exactly goes wrong, displays appropriate information including the exact location where the problem was detected, and then aborts the program – if you try to add two vectors of different length, there is nothing that can be done within the program to cope with the situation, you have to go fix the program code instead. There is generally not even a reason to throw an exception object using the usual C++ exception mechanism because there is nothing a function higher up could do in such cases to rectify the situation and deal with it in a useful way – it's not that the program received bad data; the program is just buggy, and one can not intelligently work around that.
(It is sometimes useful to change the behavior of the Assert macro from aborting a program to throwing exceptions. On the other hand, exceptions are not allowed to propagate out of destructors of classes. For this purpose, there is a variant of the macro, called AssertNothrow, that can be used in destructors. These use cases are discussed further down below on this page.)
Dynamic assertions: These are used to check conditions that depend on external things that may be different from one program run to the next, such as whether an output file can be written to.
These are things that shouldn't be checked statically, because it is not guaranteed that a program for which the condition is satisfied in a debug mode run, will also have the condition satisfied in a subsequent release mode run – in other words, it is not sufficient to only check these situations in debug mode.
Rather, one has to check them every time during execution of a program. Within deal.II, this is done using the AssertThrow macro introduced in step-9, step-13, and following tutorial programs. The macro checks a condition, and if violated throws an exception of one of the types declared in this module, using the C++ throw mechanism. Since these are run-time exceptions, this gives the program the chance to catch the exception and, for example, write the output to a writable file instead.
The error handling mechanism in deal.II is generally used in two ways. The first uses error checking in debug mode only and is useful for programs which are not fully tested. When the program shows no errors anymore, one may switch off error handling and get better performance by this, since checks for errors are done quite frequently in the library (a typical speed up is a factor of four!). This mode of exception generation is most useful for internal consistency checks such as range checking or checking of the validity of function arguments. Errors of this kind usually are programming errors and the program should abort with as detailed a message as possible, including location and reason for the generation of the exception.
The second mode is for error checks which should always be on, such as for I/O errors, failing memory requests and the like. It does not make much sense to turn this mode off, since this kind of errors may happen in tested and untested programs likewise. Exceptions of this kind do not terminate the program, rather they throw exceptions in the C++ manner, allowing the program to catch them and eventually do something about it. As it may be useful to have some information printed out if an exception could not be handled properly, additional information is passed along as for the first mode. The latter makes it necessary to provide a family of macros which enter this additional information into the exception class; this could in principle be done by the programmer himself each time by hand, but since the information can be obtained automatically, a macro is provided for this.
Both modes use exception classes, which need to have special features in additional to the C++ standard's std::exception class. Such a class is declared by the following lines of code:
This declares an exception class named ExcDomain, which has two variables as additional information (named arg1 and arg2 by default) and which outputs the given sequence (which is appended to an std::ostream variable's name, thus the weird syntax). There are other DeclExceptionN macros for exception classes with more or no parameters. By convention, the name of all exception classes starts with Exc... and most of them are declared locally to the class it is to be used in (a few very frequently found ones are also declared in the StandardExceptions namespace and are available everywhere). Declaring exceptions globally is possible but pollutes the global namespace, is less readable and most of the time unnecessary.
Since exception classes are declared the same way for both modes of error checking, it is possible to use an exception declared through the DeclExceptionN(...) macro family for both static as well as dynamic checks.
To use the exception mechanism for debug mode error checking, write lines like the following in your source code:
which by macro expansion does essentially the following (though the actual code is slightly more complicated):
That is, it issues an error only if the preprocessor variable DEBUG is set and if the given condition (in this case n < dim is violated).
If the exception was declared using the DeclException0 (...) macro, i.e., without any additional parameters, its name has nonetheless to be given with parentheses: Assert (i>m, ExcSomewhat());
If the DEBUG preprocessor directive is set, the call Assert (cond, exc); is basically converted by the preprocessor into the following sequence:
(Note that function names and exact calling sequences may change over time, but the general principle remains the same.) I.e., if the given condition is violated, then the file and line in which the exception occurred as well as the condition itself and the call sequence of the exception object is passed to the deal_II_exceptions::internals::issue_error_noreturn() function. Additionally an object of the form given by exc is created (this is normally an unnamed object like in ExcDomain (n, dim) of class ExcDomain) and transferred to this function.
__PRETTY_FUNCTION__ is a macro defined by some compilers and gives the name of the function. If another compiler is used, we try to set this function to something reasonable, if the compiler provides us with that, and "(not available)" otherwise.
In issue_error_noreturn, the given data is transferred into the exc object by calling the set_fields() function; Afterwards the program is either aborted (and information about the exception is printed to deallog) or the exception is thrown. The Assert macro does the first path (print and abort); AssertThrow does the second (throw). This behavior is consistent with the descriptions of static and dynamic assertions earlier in this document. If it can be obtained from the operating system, the output may also contain a stacktrace to show where the error happened. Several of the Tutorial programs programs show a typical output.
If the preprocessor variable DEBUG is not set then the Assert macro is expanded to {}.
Sometimes, there is no useful condition for an exception other than that the program flow should not have reached a certain point, e.g. a default section of a switch statement. In this case, raise the exception by the following construct:
See the step-7 and several other of the tutorial programs for a use of this construct.
As mentioned above, the program is terminated once a call to Assert fails. However, there is one case where we do not want to do this, namely when a C++ exception is active. The usual case where this happens is that someone throws an exception through the AssertThrow mechanism (see below) which, while the stack is unwound, leads to the destruction of other objects in stack frames above. If other objects refer to the objects being thus destroyed, some destructors raise an exception through Assert. If we would abort the program then, we would only ever see the message that an object is being destroyed which is still referenced from somewhere, but we would never see the original exception that triggered this. (You can see it in the debugger by putting a break point on the function __throw, but you cannot see it from the program itself.) In that case, we use a C++ standard library function to detect the presence of another active exception and do not terminate the program to allow that the thrown exception propagates to some place where its message can be displayed.
Since it is common that one failed assertion leads to a whole chain of others, we only ever print the very first message. If the program is then aborted, that is no problem. If it is not (since a C++ exception is active), only the first is displayed and a message about suppressed follow-up messages is shown.
C++ has a mechanism to indicate that something exceptional has happened: exceptions that can be triggered by throw statements and captured by catch clauses, see for example https://en.wikipedia.org/wiki/C%2B%2B#Exception_handling and http://www.cplusplus.com/doc/tutorial/exceptions/ .
At some fundamental level, a typical C++ exception is an object that is placed in some special place, and then the function exits the current scope (e.g., the current function) through an exceptional return path. This is often enough to tell what problem triggered the exception, but more frequently it would be nice if one had more information: for example, in which line of the code the problem happened, or what non-existent entry of a sparse matrix the code wanted to write into.
Dynamic assertions in deal.II therefore extend this mechanism a bit. Typically, one would raise an exception by code such as
and catch it using the statement
std::exception is a standard C++ class providing basic functionality for exceptions, such as the virtual function what() that returns some information on the exception itself. This information is useful if an exception can't be handled properly, in which case as precise a description as possible should be printed.
The problem here is that to get significant and useful information out of what(), it is necessary to overload this function in our exception class and call the throw operator with additional arguments to the exception class. The first thing, overloading the what function is done using the DeclExceptionN macros, but putting the right information, which is the same as explained above for the Assert expansion, requires some work if one would want to write it down each time:
For this purpose, the macro AssertThrow was invented. It does mainly the same job as does the Assert macro, but it does not abort the program; rather, it throws an exception as shown above. The mode of usage is
The condition to be checked is incorporated into the macro in order to allow passing the violated condition as a string. The expansion of the AssertThrow macro is not affected by the DEBUG preprocessor variable.
There is a whole family of DeclExceptionX macros where X is to be replaced by the number of additional parameters (0 to 5 presently). These macros are used to declare exception classes in the following way:
The first argument denotes the name of the exception class to be created. The next arguments are the types of the parameters (in this case there two types, corresponding to the X in DeclExceptionX) and finally the output sequence with which you can print additional information.
The syntax of the output sequence is a bit weird but gets clearer once you see how this macro is defined (again schematically, actual function names and definitions may change over time and be different):
If declared as specified, you can later use this exception class in the following manner:
and the output if the condition fails will be
Obviously for the DeclException0(name) macro, no types and also no output sequence is allowed.
Assert: The AssertNothrow macroThe default implementation of the Assert macro, as discussed above, prints detailed information about what exactly went wrong to the screen and then aborts the program. Aborting the program is useful because it allows easily finding the place where something went wrong – including all of the information how we got to that place – by running the program in a debugger.
On the other hand, there are cases where aborting a program may be undesirable and one needs to exit in a somewhat more graceful way – even if there is really not very much one can do in these cases to still produce a meaningful result. An example is if a deal.II program is run a one module in a bigger framework of software. Think, for example, of a case where a deal.II program computed the flow field that corresponds to a set of input variables provided by some optimization routine: if the optimizer on the outside provided a negative density as input (a condition one might want to check via Assert), then this clearly makes no sense, and the flow solver cannot produce a meaningful answer; but it should tell that to the optimizer nicely, rather than just aborting the entire process (optimizer and flow solver).
For this purpose, one can call deal_II_exceptions::disable_abort_on_exception() that switches what Assert does from aborting the program to essentially the same as AssertThrow does, namely using the C++ throw mechanism to raise an exception. This exception can then be caught at a higher level – e.g., in the optimization routine that sits atop the flow solver, and that can then decide what it wants to do with the situation.
This is all nice and good, but C++ does not allow throwing exceptions inside the destructors of classes, or in a function that is currently being called from a destructor higher up in the call stack. To this end, there is a separate macro, AssertNothrow, that can be used in destructors: It acts just like Assert usually does – in particular, it only checks the condition in debug mode – but it is immune to the effect of deal_II_exceptions::disable_abort_on_exception(): It will only ever abort the program, and never throw an exception.
| #define DeclException0 | ( | Exception0 | ) |
Declare an exception class derived from ExceptionBase without parameters.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 473 of file exceptions.h.
| #define DeclExceptionMsg | ( | Exception, | |
| defaulttext | |||
| ) |
Declare an exception class derived from ExceptionBase that can take one runtime argument, but if none is given in the place where you want to throw the exception, it simply reverts to the default text provided when declaring the exception class through this macro.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included. Definition at line 496 of file exceptions.h.
| #define DeclException1 | ( | Exception1, | |
| type1, | |||
| outsequence | |||
| ) |
Declare an exception class derived from ExceptionBase with one additional parameter.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included. Definition at line 518 of file exceptions.h.
| #define DeclException2 | ( | Exception2, | |
| type1, | |||
| type2, | |||
| outsequence | |||
| ) |
Declare an exception class derived from ExceptionBase with two additional parameters.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included. Definition at line 541 of file exceptions.h.
| #define DeclException3 | ( | Exception3, | |
| type1, | |||
| type2, | |||
| type3, | |||
| outsequence | |||
| ) |
Declare an exception class derived from ExceptionBase with three additional parameters.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included. Definition at line 564 of file exceptions.h.
| #define DeclException4 | ( | Exception4, | |
| type1, | |||
| type2, | |||
| type3, | |||
| type4, | |||
| outsequence | |||
| ) |
Declare an exception class derived from ExceptionBase with four additional parameters.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included. Definition at line 587 of file exceptions.h.
| #define DeclException5 | ( | Exception5, | |
| type1, | |||
| type2, | |||
| type3, | |||
| type4, | |||
| type5, | |||
| outsequence | |||
| ) |
Declare an exception class derived from ExceptionBase with five additional parameters.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included. Definition at line 613 of file exceptions.h.
| #define Assert | ( | cond, | |
| exc | |||
| ) |
A macro that serves as the main routine in the exception mechanism for debug mode error checking. It asserts that a certain condition is fulfilled, otherwise issues an error and aborts the program.
A more detailed description can be found in the Exceptions and assertions module. It is first used in step-5 and step-6. See also the ExceptionBase class for more information.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1407 of file exceptions.h.
| #define AssertNothrow | ( | cond, | |
| exc | |||
| ) |
A variant of the Assert macro above that exhibits the same runtime behavior as long as disable_abort_on_exception was not called.
However, if disable_abort_on_exception was called, this macro merely prints the exception that would be thrown to deallog and continues normally without throwing an exception.
A more detailed description can be found in the Exceptions and assertions module, in the discussion about the corner case at the bottom of the page.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1471 of file exceptions.h.
| #define AssertThrow | ( | cond, | |
| exc | |||
| ) |
A macro that serves as the main routine in the exception mechanism for dynamic error checking. It asserts that a certain condition is fulfilled, otherwise throws an exception via the C++ throw mechanism. This exception can be caught via a catch clause, as is shown in step-6 and all following tutorial programs.
A more detailed description can be found in the Exceptions and assertions module. It is first used in step-9 and step-13. See also the ExceptionBase class for more information.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1519 of file exceptions.h.
| #define AssertDimension | ( | dim1, | |
| dim2 | |||
| ) |
Special assertion for dimension mismatch.
Since this is used very often and always repeats the arguments, we introduce this special assertion for ExcDimensionMismatch in order to keep the user codes shorter.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1567 of file exceptions.h.
| #define AssertVectorVectorDimension | ( | VEC, | |
| DIM1, | |||
| DIM2 | |||
| ) |
An assertion that tests whether vec has size dim1, and each entry of the vector is itself an array that has the size dim2.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1595 of file exceptions.h.
| #define AssertIndexRange | ( | index, | |
| range | |||
| ) |
An assertion that tests that a given index is within the half-open range [0,range). It throws an exception object ExcIndexRange(index,0,range) if the assertion fails.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1637 of file exceptions.h.
| #define AssertIsFinite | ( | number | ) |
An assertion that checks whether a number is finite or not. We explicitly cast the number to std::complex to match the signature of the exception (see there for an explanation of why we use std::complex at all) and to satisfy the fact that std::complex has no implicit conversions.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1669 of file exceptions.h.
| #define AssertThrowMPI | ( | error_code | ) | AssertThrow(error_code == MPI_SUCCESS, ::ExcMPI(error_code)) |
An assertion that checks whether or not an error code returned by an MPI function is equal to MPI_SUCCESS. If the check fails then an exception of type ExcMPI is thrown with the given error code as an argument.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1695 of file exceptions.h.
| #define AssertCuda | ( | error_code | ) |
An assertion that checks that the error code produced by calling a CUDA routine is equal to cudaSuccess.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1722 of file exceptions.h.
| #define AssertNothrowCuda | ( | error_code | ) |
The non-throwing equivalent of AssertCuda.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1750 of file exceptions.h.
| #define AssertCusparse | ( | error_code | ) |
An assertion that checks that the error code produced by calling a cuSPARSE routine is equal to CUSPARSE_STATUS_SUCCESS.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1779 of file exceptions.h.
| #define AssertNothrowCusparse | ( | error_code | ) |
The non-throwing equivalent of AssertCusparse.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1810 of file exceptions.h.
| #define AssertCusolver | ( | error_code | ) |
An assertion that checks that the error code produced by calling a cuSOLVER routine is equal to CUSOLVER_STATUS_SUCCESS.
#undef this macro, as well as all other macros defined by deal.II that are not prefixed with either DEAL or deal, by including the header deal.II/base/undefine_macros.h after all other deal.II headers have been included.Definition at line 1842 of file exceptions.h.
| using DataOutBase::EpsFlags::ColorFunction = RgbValues (*)(const double value, const double min_value, const double max_value) |
Definition of a function pointer type taking a value and returning a triple of color values in RGB values.
Besides the actual value by which the color is to be computed, min and max values of the data to be colorized are given as well.
Definition at line 952 of file data_out_base.h.
|
private |
The data type used in counter_map.
Definition at line 222 of file subscriptor.h.
|
private |
The iterator type used in counter_map.
Definition at line 227 of file subscriptor.h.
| using BlockVectorBase< VectorType >::BlockType = VectorType |
Typedef the type of the underlying vector.
Definition at line 457 of file block_vector_base.h.
| using BlockVectorBase< VectorType >::real_type = typename BlockType::real_type |
Declare a type that has holds real-valued numbers with the same precision as the template argument to this class. If the template argument of this class is a real data type, then real_type equals the template argument. If the template argument is a std::complex type then real_type equals the type underlying the complex numbers.
This alias is used to represent the return type of norms.
Definition at line 489 of file block_vector_base.h.
|
private |
Define number type of matrix.
Definition at line 390 of file precondition_block.h.
| using PreconditionBlockJacobi< MatrixType, inverse_type >::size_type = types::global_dof_index |
Declare type for container size.
Definition at line 396 of file precondition_block.h.
| using PreconditionBlockSOR< MatrixType, inverse_type >::size_type = types::global_dof_index |
Declare type for container size.
Definition at line 669 of file precondition_block.h.
| using PreconditionBlockSOR< MatrixType, inverse_type >::number = typename MatrixType::value_type |
Define number type of matrix.
Definition at line 679 of file precondition_block.h.
| using PreconditionBlockSSOR< MatrixType, inverse_type >::size_type = types::global_dof_index |
Declare type for container size.
Definition at line 834 of file precondition_block.h.
| using PreconditionBlockSSOR< MatrixType, inverse_type >::number = typename MatrixType::value_type |
Define number type of matrix.
Definition at line 839 of file precondition_block.h.
Declare type for container size.
Definition at line 865 of file sparsity_pattern.h.
Typedef an iterator class that allows to walk over all nonzero elements of a sparsity pattern.
Definition at line 871 of file sparsity_pattern.h.
Typedef an iterator class that allows to walk over all nonzero elements of a sparsity pattern.
Since the iterator does not allow to modify the sparsity pattern, this type is the same as that for const_iterator.
Definition at line 880 of file sparsity_pattern.h.
| using GrowingVectorMemory< VectorType >::size_type = types::global_dof_index |
Declare type for container size.
Definition at line 326 of file vector_memory.h.
|
private |
A type that describes this entries of an array that represents the vectors stored by this object. The first component of the pair is be a flag telling whether the vector is used, the second a pointer to the vector itself.
Definition at line 403 of file vector_memory.h.
Enum denoting the possibilities whether the scaling should be done such that the given size equals the width or the height of the resulting picture.
| Enumerator | |
|---|---|
| width | Scale to given width. |
| height | Scale to given height. |
Definition at line 819 of file data_out_base.h.
A data type providing the different possible zlib compression levels. These map directly to constants defined by zlib.
Definition at line 1132 of file data_out_base.h.
Declare what a multiple entry is: a variant entry (in curly braces {, }) or an array (in double curly braces {{, }}).
| Enumerator | |
|---|---|
| variant | A variant entry. |
| array | An array entry. |
Definition at line 2042 of file parameter_handler.h.
Files can be used for input or output. This can be specified in the constructor by choosing the flag type.
| Enumerator | |
|---|---|
| input | Open for input. |
| output | Open for output. |
Definition at line 1091 of file patterns.h.
|
static |
An entry with this name does not exist in the AnyData object.
|
static |
The requested type and the stored type are different.
|
static |
Exception indicating that a function expected a vector to have a certain name, but we store a different name in that position.
|
static |
An entry with this name does not exist in the internal boost::any map.
|
static |
An entry with this name does not exist in the internal boost::any map.
|
static |
The requested type and the stored type are different.
|
static |
Exception
| DataOutBase::Patch< dim, spacedim >::Patch | ( | ) |
Default constructor. Sets n_subdivisions to one, points_are_available to false, and patch_index to no_neighbor.
Definition at line 1756 of file data_out_base.cc.
| bool DataOutBase::Patch< dim, spacedim >::operator== | ( | const Patch< dim, spacedim > & | patch | ) | const |
Compare the present patch for equality with another one. This is used in a few of the automated tests in our testsuite.
Definition at line 1774 of file data_out_base.cc.
| std::size_t DataOutBase::Patch< dim, spacedim >::memory_consumption | ( | ) | const |
Return an estimate for the memory consumption, in bytes, of this object. This is not exact (but will usually be close) because calculating the memory usage of trees (e.g., std::map) is difficult.
Definition at line 1813 of file data_out_base.cc.
| void DataOutBase::Patch< dim, spacedim >::swap | ( | Patch< dim, spacedim > & | other_patch | ) |
Swap the current object's contents with those of the given argument.
Definition at line 1829 of file data_out_base.cc.
|
static |
Exception
| DataOutBase::Patch< 0, spacedim >::Patch | ( | ) |
Default constructor. Sets points_are_available to false, and patch_index to no_neighbor.
Definition at line 1857 of file data_out_base.cc.
| bool DataOutBase::Patch< 0, spacedim >::operator== | ( | const Patch< 0, spacedim > & | patch | ) | const |
Compare the present patch for equality with another one. This is used in a few of the automated tests in our testsuite.
Definition at line 1868 of file data_out_base.cc.
| std::size_t DataOutBase::Patch< 0, spacedim >::memory_consumption | ( | ) | const |
Return an estimate for the memory consumption, in bytes, of this object. This is not exact (but will usually be close) because calculating the memory usage of trees (e.g., std::map) is difficult.
Definition at line 1902 of file data_out_base.cc.
| void DataOutBase::Patch< 0, spacedim >::swap | ( | Patch< 0, spacedim > & | other_patch | ) |
Swap the current object's contents with those of the given argument.
Definition at line 1913 of file data_out_base.cc.
|
static |
Exception
|
static |
Declare all flags with name and type as offered by this class, for use in input files.
This method does nothing, but child classes may override this method to add fields to prm.
Definition at line 570 of file data_out_base.h.
| void DataOutBase::OutputFlagsBase< FlagsType >::parse_parameters | ( | const ParameterHandler & | prm | ) |
Read the parameters declared in declare_parameters() and set the flags for this output format accordingly.
This method does nothing, but child classes may override this method to add fields to prm.
Definition at line 576 of file data_out_base.h.
| std::size_t DataOutBase::OutputFlagsBase< FlagsType >::memory_consumption | ( | ) | const |
Return an estimate for the memory consumption, in bytes, of this object. This is not exact (but will usually be close) because calculating the memory usage of trees (e.g., std::map) is difficult.
Definition at line 582 of file data_out_base.h.
| DataOutBase::DXFlags::DXFlags | ( | const bool | write_neighbors = false, |
| const bool | int_binary = false, |
||
| const bool | coordinates_binary = false, |
||
| const bool | data_binary = false |
||
| ) |
Constructor.
Definition at line 2015 of file data_out_base.cc.
|
static |
Declare all flags with name and type as offered by this class, for use in input files.
Definition at line 2028 of file data_out_base.cc.
| void DataOutBase::DXFlags::parse_parameters | ( | const ParameterHandler & | prm | ) |
Read the parameters declared in declare_parameters() and set the flags for this output format accordingly.
The flags thus obtained overwrite all previous contents of this object.
Definition at line 2059 of file data_out_base.cc.
| DataOutBase::UcdFlags::UcdFlags | ( | const bool | write_preamble = false | ) |
Constructor.
Definition at line 1923 of file data_out_base.cc.
|
static |
Declare all flags with name and type as offered by this class, for use in input files.
Definition at line 2068 of file data_out_base.cc.
| void DataOutBase::UcdFlags::parse_parameters | ( | const ParameterHandler & | prm | ) |
Read the parameters declared in declare_parameters() and set the flags for this output format accordingly.
The flags thus obtained overwrite all previous contents of this object.
Definition at line 2082 of file data_out_base.cc.
| DataOutBase::GnuplotFlags::GnuplotFlags | ( | ) |
Default constructor. Sets up the dimension labels with the default values of "x", "y", and "z".
Definition at line 1929 of file data_out_base.cc.
| DataOutBase::GnuplotFlags::GnuplotFlags | ( | const std::vector< std::string > & | space_dimension_labels | ) |
Constructor which sets up non-default values for the dimension labels.
Definition at line 1938 of file data_out_base.cc.
| std::size_t DataOutBase::GnuplotFlags::memory_consumption | ( | ) | const |
Return an estimate for the memory consumption, in bytes, of this object.
Definition at line 1945 of file data_out_base.cc.
|
static |
Exception to raise when there are not enough specified dimension labels.
| DataOutBase::PovrayFlags::PovrayFlags | ( | const bool | smooth = false, |
| const bool | bicubic_patch = false, |
||
| const bool | external_data = false |
||
| ) |
Constructor.
Definition at line 1952 of file data_out_base.cc.
|
static |
Declare all flags with name and type as offered by this class, for use in input files.
Definition at line 2108 of file data_out_base.cc.
| void DataOutBase::PovrayFlags::parse_parameters | ( | const ParameterHandler & | prm | ) |
Read the parameters declared in declare_parameters() and set the flags for this output format accordingly.
The flags thus obtained overwrite all previous contents of this object.
Definition at line 2130 of file data_out_base.cc.
|
inline |
Return true if the color represented by the three color values is a grey scale, i.e. all components are equal.
Definition at line 3670 of file data_out_base.h.
|
static |
Default colorization function. This one does what one usually wants: It shifts colors from black (lowest value) through blue, green and red to white (highest value). For the exact definition of the color scale refer to the implementation.
This function was originally written by Stefan Nauber.
Definition at line 2168 of file data_out_base.cc.
|
static |
This is an alternative color function producing a grey scale between black (lowest values) and white (highest values). You may use it by setting the color_function variable to the address of this function.
Definition at line 2256 of file data_out_base.cc.
|
static |
This is one more alternative color function producing a grey scale between white (lowest values) and black (highest values), i.e. the scale is reversed to the previous one. You may use it by setting the color_function variable to the address of this function.
Definition at line 2269 of file data_out_base.cc.
| DataOutBase::EpsFlags::EpsFlags | ( | const unsigned int | height_vector = 0, |
| const unsigned int | color_vector = 0, |
||
| const SizeType | size_type = width, |
||
| const unsigned int | size = 300, |
||
| const double | line_width = 0.5, |
||
| const double | azimut_angle = 60, |
||
| const double | turn_angle = 30, |
||
| const double | z_scaling = 1.0, |
||
| const bool | draw_mesh = true, |
||
| const bool | draw_cells = true, |
||
| const bool | shade_cells = true, |
||
| const ColorFunction | color_function = &default_color_function |
||
| ) |
Constructor.
Definition at line 2139 of file data_out_base.cc.
|
static |
Declare all flags with name and type as offered by this class, for use in input files.
For coloring, only the color functions declared in this class are offered.
Definition at line 2291 of file data_out_base.cc.
| void DataOutBase::EpsFlags::parse_parameters | ( | const ParameterHandler & | prm | ) |
Read the parameters declared in declare_parameters() and set the flags for this output format accordingly.
The flags thus obtained overwrite all previous contents of this object.
Definition at line 2358 of file data_out_base.cc.
| DataOutBase::TecplotFlags::TecplotFlags | ( | const char * | tecplot_binary_file_name = nullptr, |
| const char * | zone_name = nullptr, |
||
| const double | solution_time = -1.0 |
||
| ) |
Constructor.
Definition at line 2388 of file data_out_base.cc.
| std::size_t DataOutBase::TecplotFlags::memory_consumption | ( | ) | const |
Return an estimate for the memory consumption, in bytes, of this object.
Definition at line 2399 of file data_out_base.cc.
| DataOutBase::VtkFlags::VtkFlags | ( | const double | time = std::numeric_limits<double>::min(), |
| const unsigned int | cycle = std::numeric_limits<unsigned int>::min(), |
||
| const bool | print_date_and_time = true, |
||
| const ZlibCompressionLevel | compression_level = best_compression, |
||
| const bool | write_higher_order_cells = false |
||
| ) |
Constructor.
Definition at line 2408 of file data_out_base.cc.
| DataOutBase::SvgFlags::SvgFlags | ( | const unsigned int | height_vector = 0, |
| const int | azimuth_angle = 37, |
||
| const int | polar_angle = 45, |
||
| const unsigned int | line_thickness = 1, |
||
| const bool | margin = true, |
||
| const bool | draw_colorbar = true |
||
| ) |
Constructor.
Definition at line 2089 of file data_out_base.cc.
| DataOutBase::DataOutFilterFlags::DataOutFilterFlags | ( | const bool | filter_duplicate_vertices = false, |
| const bool | xdmf_hdf5_output = false |
||
| ) |
Constructor.
Definition at line 1961 of file data_out_base.cc.
|
static |
Declare all flags with name and type as offered by this class, for use in input files.
Definition at line 1969 of file data_out_base.cc.
| void DataOutBase::DataOutFilterFlags::parse_parameters | ( | const ParameterHandler & | prm | ) |
Read the parameters declared in declare_parameters and set the flags for this output format accordingly.
The flags thus obtained overwrite all previous contents of this object.
Definition at line 2007 of file data_out_base.cc.
| std::size_t DataOutBase::DataOutFilterFlags::memory_consumption | ( | ) | const |
Determine an estimate for the memory consumption (in bytes) of this object.
| DataOutBase::DataOutFilter::DataOutFilter | ( | ) |
Default constructor.
Definition at line 455 of file data_out_base.cc.
| DataOutBase::DataOutFilter::DataOutFilter | ( | const DataOutBase::DataOutFilterFlags & | flags | ) |
Destructor with a given set of flags. See DataOutFilterFlags for possible flags.
Definition at line 463 of file data_out_base.cc.
| void DataOutBase::DataOutFilter::write_point | ( | const unsigned int | index, |
| const Point< dim > & | p | ||
| ) |
Write a point with the specified index into the filtered data set. If the point already exists and we are filtering redundant values, the provided index will internally refer to another recorded point.
Definition at line 473 of file data_out_base.cc.
| void DataOutBase::DataOutFilter::write_cell | ( | const unsigned int | index, |
| const unsigned int | start, | ||
| const unsigned int | d1, | ||
| const unsigned int | d2, | ||
| const unsigned int | d3 | ||
| ) |
Record a deal.II cell in the internal reordered format.
Definition at line 602 of file data_out_base.cc.
| void DataOutBase::DataOutFilter::write_data_set | ( | const std::string & | name, |
| const unsigned int | dimension, | ||
| const unsigned int | set_num, | ||
| const Table< 2, double > & | data_vectors | ||
| ) |
Filter and record a data set. If there are multiple values at a given vertex and redundant values are being removed, one is arbitrarily chosen as the recorded value. In the future this can be expanded to average/min/max multiple values at a given vertex.
Definition at line 633 of file data_out_base.cc.
| void DataOutBase::DataOutFilter::fill_node_data | ( | std::vector< double > & | node_data | ) | const |
Resize and fill a vector with all the filtered node vertex points, for output to a file.
Definition at line 511 of file data_out_base.cc.
| void DataOutBase::DataOutFilter::fill_cell_data | ( | const unsigned int | local_node_offset, |
| std::vector< unsigned int > & | cell_data | ||
| ) | const |
Resize and fill a vector with all the filtered cell vertex indices, for output to a file.
Definition at line 526 of file data_out_base.cc.
| std::string DataOutBase::DataOutFilter::get_data_set_name | ( | const unsigned int | set_num | ) | const |
Get the name of the data set indicated by the set number.
Definition at line 541 of file data_out_base.cc.
| unsigned int DataOutBase::DataOutFilter::get_data_set_dim | ( | const unsigned int | set_num | ) | const |
Get the dimensionality of the data set indicated by the set number.
Definition at line 549 of file data_out_base.cc.
| const double * DataOutBase::DataOutFilter::get_data_set | ( | const unsigned int | set_num | ) | const |
Get the raw double valued data of the data set indicated by the set number.
Definition at line 557 of file data_out_base.cc.
| unsigned int DataOutBase::DataOutFilter::n_nodes | ( | ) | const |
Return the number of nodes in this DataOutFilter. This may be smaller than the original number of nodes if filtering is enabled.
Definition at line 565 of file data_out_base.cc.
| unsigned int DataOutBase::DataOutFilter::n_cells | ( | ) | const |
Return the number of filtered cells in this DataOutFilter. Cells are not filtered so this will be the original number of cells.
Definition at line 573 of file data_out_base.cc.
| unsigned int DataOutBase::DataOutFilter::n_data_sets | ( | ) | const |
Return the number of filtered data sets in this DataOutFilter. Data sets are not filtered so this will be the original number of data sets.
Definition at line 581 of file data_out_base.cc.
| void DataOutBase::DataOutFilter::flush_points | ( | ) |
Empty functions to do base class inheritance.
Definition at line 589 of file data_out_base.cc.
| void DataOutBase::DataOutFilter::flush_cells | ( | ) |
Empty functions to do base class inheritance.
Definition at line 595 of file data_out_base.cc.
|
private |
Record a cell vertex index based on the internal reordering.
Definition at line 502 of file data_out_base.cc.
|
static |
Exception
|
static |
An output function did not receive any patches for writing.
|
static |
Exception
|
static |
Exception
| DataOutInterface< dim, spacedim >::DataOutInterface | ( | ) |
Constructor.
Definition at line 7299 of file data_out_base.cc.
|
virtualdefault |
Destructor. Does nothing, but is declared virtual since this class has virtual functions.
| void DataOutInterface< dim, spacedim >::write_dx | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in OpenDX format. See DataOutBase::write_dx.
Definition at line 7308 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_eps | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in EPS format. See DataOutBase::write_eps.
Definition at line 7360 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_gmv | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in GMV format. See DataOutBase::write_gmv.
Definition at line 7373 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_gnuplot | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in GNUPLOT format. See DataOutBase::write_gnuplot.
Definition at line 7334 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_povray | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in POVRAY format. See DataOutBase::write_povray.
Definition at line 7347 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_tecplot | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in Tecplot format. See DataOutBase::write_tecplot.
Definition at line 7386 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_tecplot_binary | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it in the Tecplot binary output format. Note that the name of the output file must be specified through the TecplotFlags interface.
Definition at line 7399 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_ucd | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in UCD format for AVS. See DataOutBase::write_ucd.
Definition at line 7321 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_vtk | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in Vtk format. See DataOutBase::write_vtk.
Definition at line 7412 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_vtu | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in Vtu (VTK's XML) format. See DataOutBase::write_vtu.
Some visualization programs, such as ParaView, can read several separate VTU files to parallelize visualization. In that case, you need a .pvtu file that describes which VTU files form a group. The DataOutInterface::write_pvtu_record() function can generate such a master record. Likewise, DataOutInterface::write_visit_record() does the same for older versions of VisIt (although VisIt can also read pvtu records since version 2.5.1). Finally, DataOutInterface::write_pvd_record() can be used to group together the files that jointly make up a time dependent simulation.
Definition at line 7423 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_vtu_in_parallel | ( | const std::string & | filename, |
| MPI_Comm | comm | ||
| ) | const |
Collective MPI call to write the solution from all participating nodes (those in the given communicator) to a single compressed .vtu file on a shared file system. The communicator can be a sub communicator of the one used by the computation. This routine uses MPI I/O to achieve high performance on parallel filesystems. Also see DataOutInterface::write_vtu().
Definition at line 7445 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_pvtu_record | ( | std::ostream & | out, |
| const std::vector< std::string > & | piece_names | ||
| ) | const |
Some visualization programs, such as ParaView, can read several separate VTU files that all form part of the same simulation, in order to parallelize visualization. In that case, you need a .pvtu file that describes which VTU files (written, for example, through the DataOutInterface::write_vtu() function) form a group. The current function can generate such a master record.
The master record file generated by this function contains a list of (scalar or vector) fields that describes which fields can actually be found in the individual files that comprise the set of parallel VTU files along with the names of these files. This function gets the names and types of fields through the get_dataset_names() and get_nonscalar_data_ranges() functions of this class. The second argument to this function specifies the names of the files that form the parallel set.
pvtu files that each describe one time step of a time dependent simulation, see the DataOutBase::write_pvd_record() function.pvtu records. However, it can read visit records as written by the write_visit_record() function. Definition at line 7536 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_svg | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in SVG format. See DataOutBase::write_svg.
Definition at line 7434 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_deal_II_intermediate | ( | std::ostream & | out | ) | const |
Obtain data through get_patches() and write it to out in deal.II intermediate format. See DataOutBase::write_deal_II_intermediate.
Note that the intermediate format is what its name suggests: a direct representation of internal data. It isn't standardized and will change whenever we change our internal representation. You can only expect to process files written in this format using the same version of deal.II that was used for writing.
Definition at line 7550 of file data_out_base.cc.
| XDMFEntry DataOutInterface< dim, spacedim >::create_xdmf_entry | ( | const DataOutBase::DataOutFilter & | data_filter, |
| const std::string & | h5_filename, | ||
| const double | cur_time, | ||
| MPI_Comm | comm | ||
| ) | const |
Create an XDMFEntry based on the data in the data_filter. This assumes the mesh and solution data were written to a single file. See write_xdmf_file() for an example of usage.
Definition at line 7563 of file data_out_base.cc.
| XDMFEntry DataOutInterface< dim, spacedim >::create_xdmf_entry | ( | const DataOutBase::DataOutFilter & | data_filter, |
| const std::string & | h5_mesh_filename, | ||
| const std::string & | h5_solution_filename, | ||
| const double | cur_time, | ||
| MPI_Comm | comm | ||
| ) | const |
Create an XDMFEntry based on the data in the data_filter. This assumes the mesh and solution data were written to separate files. See write_xdmf_file() for an example of usage.
Definition at line 7577 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_xdmf_file | ( | const std::vector< XDMFEntry > & | entries, |
| const std::string & | filename, | ||
| MPI_Comm | comm | ||
| ) | const |
Write an XDMF file based on the provided vector of XDMFEntry objects. Below is an example of how to use this function with HDF5 and the DataOutFilter:
Definition at line 7650 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_hdf5_parallel | ( | const DataOutBase::DataOutFilter & | data_filter, |
| const std::string & | filename, | ||
| MPI_Comm | comm | ||
| ) | const |
Write the data in data_filter to a single HDF5 file containing both the mesh and solution values. Below is an example of how to use this function with the DataOutFilter:
Definition at line 7860 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_hdf5_parallel | ( | const DataOutBase::DataOutFilter & | data_filter, |
| const bool | write_mesh_file, | ||
| const std::string & | mesh_filename, | ||
| const std::string & | solution_filename, | ||
| MPI_Comm | comm | ||
| ) | const |
Write the data in data_filter to HDF5 file(s). If write_mesh_file is false, the mesh data will not be written and the solution file will contain only the solution values. If write_mesh_file is true and the filenames are the same, the resulting file will contain both mesh data and solution values.
Definition at line 7872 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write_filtered_data | ( | DataOutBase::DataOutFilter & | filtered_data | ) | const |
DataOutFilter is an intermediate data format that reduces the amount of data that will be written to files. The object filled by this function can then later be used again to write data in a concrete file format; see, for example, DataOutBase::write_hdf5_parallel().
Definition at line 7695 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::write | ( | std::ostream & | out, |
| const DataOutBase::OutputFormat | output_format = DataOutBase::default_format |
||
| ) | const |
Write data and grid to out according to the given data format. This function simply calls the appropriate write_* function. If no output format is requested, the default_format is written.
An error occurs if no format is provided and the default format is default_format.
Definition at line 8261 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::set_default_format | ( | const DataOutBase::OutputFormat | default_format | ) |
Set the default format. The value set here is used anytime, output for format default_format is requested.
Definition at line 8331 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::set_flags | ( | const FlagType & | flags | ) |
Set the flags to be used for output. This method expects flags to be a member of one of the child classes of OutputFlagsBase.
Definition at line 8341 of file data_out_base.cc.
| std::string DataOutInterface< dim, spacedim >::default_suffix | ( | const DataOutBase::OutputFormat | output_format = DataOutBase::default_format | ) | const |
A function that returns the same string as the respective function in the base class does; the only exception being that if the parameter is omitted, then the value for the present default format is returned, i.e. the correct suffix for the format that was set through set_default_format() or parse_parameters() before calling this function.
Definition at line 8376 of file data_out_base.cc.
|
static |
Declare parameters for all output formats by declaring subsections within the parameter file for each output format and call the respective declare_parameters functions of the flag classes for each output format.
Some of the declared subsections may not contain entries, if the respective format does not export any flags.
Note that the top-level parameters denoting the number of subdivisions per patch and the output format are not declared, since they are only passed to virtual functions and are not stored inside objects of this type. You have to declare them yourself.
Definition at line 8389 of file data_out_base.cc.
| void DataOutInterface< dim, spacedim >::parse_parameters | ( | ParameterHandler & | prm | ) |
Read the parameters declared in declare_parameters() and set the flags for the output formats accordingly.
The flags thus obtained overwrite all previous contents of the flag objects as default-constructed or set by the set_flags() function.
Definition at line 8442 of file data_out_base.cc.
| std::size_t DataOutInterface< dim, spacedim >::memory_consumption | ( | ) | const |
Return an estimate for the memory consumption, in bytes, of this object. This is not exact (but will usually be close) because calculating the memory usage of trees (e.g., std::map) is difficult.
Definition at line 8489 of file data_out_base.cc.
|
protectedpure virtual |
This is the abstract function through which derived classes propagate preprocessed data in the form of Patch structures (declared in the base class DataOutBase) to the actual output function. You need to overload this function to allow the output functions to know what they shall print.
Implemented in DataOutReader< dim, spacedim >, DataOut_DoFData< DoFHandlerType, patch_dim, patch_space_dim >, DataOut_DoFData< DoFHandler< dim >, DoFHandler< dim > ::dimension, DoFHandler< dim > ::space_dimension >, DataOut_DoFData< DoFHandlerType, DoFHandlerType::dimension, DoFHandlerType::space_dimension >, DataOut_DoFData< DoFHandlerType, DoFHandlerType::dimension - 1, DoFHandlerType::dimension >, DataOut_DoFData< DoFHandlerType, DoFHandlerType::dimension+1 >, DataOutStack< dim, spacedim, DoFHandlerType >, and MatrixOut.
|
protectedpure virtual |
Abstract virtual function through which the names of data sets are obtained by the output functions of the base class.
Implemented in DataOutReader< dim, spacedim >, DataOut_DoFData< DoFHandlerType, patch_dim, patch_space_dim >, DataOut_DoFData< DoFHandler< dim >, DoFHandler< dim > ::dimension, DoFHandler< dim > ::space_dimension >, DataOut_DoFData< DoFHandlerType, DoFHandlerType::dimension, DoFHandlerType::space_dimension >, DataOut_DoFData< DoFHandlerType, DoFHandlerType::dimension - 1, DoFHandlerType::dimension >, DataOut_DoFData< DoFHandlerType, DoFHandlerType::dimension+1 >, DataOutStack< dim, spacedim, DoFHandlerType >, and MatrixOut.
|
protectedvirtual |
This functions returns information about how the individual components of output files that consist of more than one data set are to be interpreted.
Definition at line 8525 of file data_out_base.cc.
|
protectedvirtual |
This functions returns information about how the individual components of output files that consist of more than one data set are to be interpreted.
It returns a list of index pairs and corresponding name and type indicating which components of the output are to be considered vector- or tensor-valued rather than just a collection of scalar data. The index pairs are inclusive; for example, if we have a Stokes problem in 2d with components (u,v,p), then the corresponding vector data range should be (0,1), and the returned list would consist of only a single element with a tuple such as (0,1,"velocity",component_is_part_of_vector).
Since some of the derived classes do not know about non-scalar data, this function has a default implementation that simply returns an empty string, meaning that all data is to be considered a collection of scalar fields.
Reimplemented in DataOutReader< dim, spacedim >, DataOut_DoFData< DoFHandlerType, patch_dim, patch_space_dim >, DataOut_DoFData< DoFHandler< dim >, DoFHandler< dim > ::dimension, DoFHandler< dim > ::space_dimension >, DataOut_DoFData< DoFHandlerType, DoFHandlerType::dimension, DoFHandlerType::space_dimension >, DataOut_DoFData< DoFHandlerType, DoFHandlerType::dimension - 1, DoFHandlerType::dimension >, and DataOut_DoFData< DoFHandlerType, DoFHandlerType::dimension+1 >.
Definition at line 8512 of file data_out_base.cc.
|
protected |
Validate that the names of the datasets returned by get_dataset_names() and get_nonscalar_data_ranges() are valid. This currently consists of checking that names are not used more than once. If an invalid state is encountered, an Assert() will be triggered in debug mode.
Definition at line 8547 of file data_out_base.cc.
| void DataOutReader< dim, spacedim >::read | ( | std::istream & | in | ) |
Read a sequence of patches as written previously by DataOutBase::write_deal_II_intermediate and store them in the present object. This overwrites any previous content.
Definition at line 8603 of file data_out_base.cc.
| void DataOutReader< dim, spacedim >::merge | ( | const DataOutReader< dim, spacedim > & | other | ) |
This function can be used to merge the patches read by the other object into the patches that this present object stores. This is sometimes handy if one has, for example, a domain decomposition algorithm where each block is represented by a DoFHandler of its own, but one wants to output the solution on all the blocks at the same time. Alternatively, it may also be used for parallel programs, where each process only generates output for its share of the cells, even if all processes can see all cells.
For this to work, the input files for the present object and the given argument need to have the same number of output vectors, and they need to use the same number of subdivisions per patch. The output will probably look rather funny if patches in both objects overlap in space.
If you call read() for this object after merging in patches, the previous state is overwritten, and the merged-in patches are lost.
This function will fail if either this or the other object did not yet set up any patches.
The use of this function is demonstrated in step-19.
Definition at line 8714 of file data_out_base.cc.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
overrideprotectedvirtual |
This is the function through which this class propagates preprocessed data in the form of Patch structures (declared in the base class DataOutBase) to the actual output function.
It returns the patches as read the last time a stream was given to the read() function.
Implements DataOutInterface< dim, spacedim >.
Definition at line 8776 of file data_out_base.cc.
|
overrideprotectedvirtual |
Abstract virtual function through which the names of data sets are obtained by the output functions of the base class.
Return the names of the variables as read the last time we read a file.
Implements DataOutInterface< dim, spacedim >.
Definition at line 8785 of file data_out_base.cc.
|
overrideprotectedvirtual |
This functions returns information about how the individual components of output files that consist of more than one data set are to be interpreted.
It returns a list of index pairs and corresponding name indicating which components of the output are to be considered vector-valued rather than just a collection of scalar data. The index pairs are inclusive; for example, if we have a Stokes problem in 2d with components (u,v,p), then the corresponding vector data range should be (0,1), and the returned list would consist of only a single element with a tuple such as (0,1,"velocity").
Since some of the derived classes do not know about vector data, this function has a default implementation that simply returns an empty string, meaning that all data is to be considered a collection of scalar fields.
Reimplemented from DataOutInterface< dim, spacedim >.
Definition at line 8798 of file data_out_base.cc.
| XDMFEntry::XDMFEntry | ( | ) |
Default constructor that creates an invalid object.
Definition at line 8807 of file data_out_base.cc.
| XDMFEntry::XDMFEntry | ( | const std::string & | filename, |
| const double | time, | ||
| const unsigned int | nodes, | ||
| const unsigned int | cells, | ||
| const unsigned int | dim | ||
| ) |
Simplified constructor that calls the complete constructor for cases where solution_filename == mesh_filename, and dim==spacedim.
Definition at line 8820 of file data_out_base.cc.
| XDMFEntry::XDMFEntry | ( | const std::string & | mesh_filename, |
| const std::string & | solution_filename, | ||
| const double | time, | ||
| const unsigned int | nodes, | ||
| const unsigned int | cells, | ||
| const unsigned int | dim | ||
| ) |
Simplified constructor that calls the complete constructor for cases where dim==spacedim.
Definition at line 8830 of file data_out_base.cc.
| XDMFEntry::XDMFEntry | ( | const std::string & | mesh_filename, |
| const std::string & | solution_filename, | ||
| const double | time, | ||
| const unsigned int | nodes, | ||
| const unsigned int | cells, | ||
| const unsigned int | dim, | ||
| const unsigned int | spacedim | ||
| ) |
Constructor that sets all members to provided parameters.
Definition at line 8841 of file data_out_base.cc.
| void XDMFEntry::add_attribute | ( | const std::string & | attr_name, |
| const unsigned int | dimension | ||
| ) |
Record an attribute and associated dimensionality.
Definition at line 8861 of file data_out_base.cc.
|
inline |
Read or write the data of this object for serialization
Definition at line 3602 of file data_out_base.h.
| std::string XDMFEntry::get_xdmf_content | ( | const unsigned int | indent_level | ) | const |
Get the XDMF content associated with this entry. If the entry is not valid, this returns an empty string.
Definition at line 8887 of file data_out_base.cc.
| std::ostream& DataOutBase::operator<< | ( | std::ostream & | out, |
| const Patch< dim, spacedim > & | patch | ||
| ) |
Output operator for an object of type DataOutBase::Patch. This operator dumps the intermediate graphics format represented by the patch data structure. It may later be converted into regular formats for a number of graphics programs.
Definition at line 8970 of file data_out_base.cc.
| std::istream& DataOutBase::operator>> | ( | std::istream & | in, |
| Patch< dim, spacedim > & | patch | ||
| ) |
Input operator for an object of type DataOutBase::Patch. This operator reads the intermediate graphics format represented by the patch data structure, using the format in which it was written using the operator<<.
Definition at line 9002 of file data_out_base.cc.
|
static |
Exception.
|
static |
Exception denoting a division by zero.
|
static |
Exception raised if a number is not finite.
This exception should be used to catch infinite or not a number results of arithmetic operations that do not result from a division by zero (use ExcDivideByZero for those).
The exception uses std::complex as its argument to ensure that we can use it for all scalar arguments (real or complex-valued).
|
static |
Trying to allocate a new object failed due to lack of free memory.
|
static |
A memory handler reached a point where all allocated objects should have been released. Since this exception is thrown, some were still allocated.
|
static |
An error occurred reading or writing a file.
|
static |
An error occurred opening the named file.
The constructor takes a single argument of type char* naming the file.
|
static |
Exception denoting a part of the library or application program that has not yet been implemented. In many cases, this only indicates that there wasn't much need for something yet, not that this is difficult to implement. It is therefore quite worth the effort to take a look at the corresponding place and see whether it can be implemented without too much effort.
|
static |
This exception usually indicates that some condition which the programmer thinks must be satisfied at a certain point in an algorithm, is not fulfilled. This might be due to some programming error above, due to changes to the algorithm that did not preserve this assertion, or due to assumptions the programmer made that are not valid at all (i.e. the exception is thrown although there is no error here). Within the library, this exception is most often used when we write some kind of complicated algorithm and are not yet sure whether we got it right; we then put in assertions after each part of the algorithm that check for some conditions that should hold there, and throw an exception if they do not.
We usually leave in these assertions even after we are confident that the implementation is correct, since if someone later changes or extends the algorithm, these exceptions will indicate to him if he violates assumptions that are used later in the algorithm. Furthermore, it sometimes happens that an algorithm does not work in very rare corner cases. These cases will then be trapped sooner or later by the exception, so that the algorithm can then be fixed for these cases as well.
|
static |
This exception is used in functions that may not be called (i.e. in pure functions) but could not be declared pure since the class is intended to be used anyway, even though the respective function may only be called if a derived class is used.
|
static |
This exception is used if some object is found uninitialized.
|
static |
The object is in a state not suitable for this operation.
|
static |
This exception is raised if a functionality is not possible in the given dimension. Mostly used to throw function calls in 1d.
The constructor takes a single int, denoting the dimension.
|
static |
This exception is raised if a functionality is not possible in the given combination of dimension and space-dimension.
The constructor takes two int, denoting the dimension and the space dimension.
|
static |
A number is zero, but it should not be here.
|
static |
The object should have been filled with something before this member function is called.
|
static |
This exception is raised whenever the sizes of two objects were assumed to be equal, but were not.
Parameters to the constructor are the first and second size, both of type int.
|
static |
The first dimension should be either equal to the second or the third, but it is neither.
|
static |
This exception indicates that an index is not within the expected range. For example, it may be that you are trying to access an element of a vector which does not exist.
The constructor takes three int arguments, namely
|
static |
This exception indicates that an index is not within the expected range. For example, it may be that you are trying to access an element of a vector which does not exist.
The constructor takes three arguments, namely
This generic exception differs from ExcIndexRange by allowing to specify the type of indices.
|
static |
A number is too small.
|
static |
A generic exception definition for the ExcLowerRange above.
|
static |
This exception indicates that the first argument should be an integer multiple of the second, but is not.
|
static |
This exception is thrown if the iterator you access has corrupted data. It might for instance be, that the container it refers does not have an entry at the point the iterator refers.
Typically, this will be an internal error of deal.II, because the increment and decrement operators should never yield an invalid iterator.
|
static |
This exception is thrown if the iterator you incremented or decremented was already at its final state.
|
static |
This exception works around a design flaw in the DeclException0 macro: exceptions declared through DeclException0 do not allow one to specify a message that is displayed when the exception is raised, as opposed to the other exceptions which allow to show a text along with the given parameters.
When throwing this exception, you can give a message as a std::string as argument to the exception that is then displayed. The argument can, of course, be constructed at run-time, for example including the name of a file that can't be opened, or any other text you may want to assemble from different pieces.
|
static |
Parallel vectors with ghost elements are read-only vectors.
|
static |
Some of our numerical classes allow for setting all entries to zero using the assignment operator =.
In many cases, this assignment operator makes sense only for the argument zero. In other cases, this exception is thrown.
|
static |
This function requires support for the LAPACK library.
|
static |
This function requires support for the NetCDF library.
|
static |
This function requires support for the FunctionParser library.
|
static |
This function requires support for the Assimp library.
|
static |
This exception is raised if an error happened in a CUDA kernel.
The constructor takes a single char*, the output of cudaGetErrorString.
|
static |
This exception is raised if an error happened in a cuSPARSE function.
|
static |
|
static |
|
static |
|
static |
|
static |
|
static |
|
private |
Initialize fp and vars on the current thread. This function may only be called once per thread. A thread can test whether the function has already been called by testing whether 'fp.get().size()==0' (not initialized) or >0 (already initialized).
Definition at line 278 of file function_parser.cc.
|
static |
Exception.
|
static |
Exception.
|
static |
Exception
|
static |
Exception
|
static |
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception for when there are an unequal number of 'subsection' and 'end' statements. The first argument is the name of the file and the second argument is a formatted list of the subsection path before and after entering the parser.
|
static |
Exception for when, during parsing of a parameter file, the parser encounters a subsection in the file that was not previously declared.
|
static |
General exception for a line that could not be parsed, taking, as arguments, the line number, file name, and a brief description of why the line cannot be parsed.
|
static |
Exception for an entry in a parameter file that does not match the provided pattern. The arguments are, in order, the line number, file name, entry value, entry name, and a description of the pattern.
|
static |
Exception for when an XML file cannot be read at all. This happens when there is no top-level XML element called "ParameterHandler" or when there are multiple top level elements.
|
static |
Exception for when an entry in an XML parameter file does not match the provided pattern. The arguments are, in order, the entry value, entry name, and a description of the pattern.
|
static |
Exception for when the file given in an include statement cannot be open. The arguments are, in order, the line number of the include statement, current parameter file name, and the name of the file intended for inclusion.
|
staticprivate |
Given a list of directories and subdirectories that identify a particular place in the tree, return the string that identifies this place in the way the BOOST property tree libraries likes to identify things.
Definition at line 255 of file parameter_handler.cc.
|
private |
Return the string that identifies the current path into the property tree. This is only a path, i.e. it is not terminated by the path_separator character.
This function simply calls collate_path_string() with subsection_path as argument
Definition at line 274 of file parameter_handler.cc.
|
private |
Given the name of an entry as argument, the function computes a full path into the parameter tree using the current subsection.
Definition at line 282 of file parameter_handler.cc.
|
private |
This function computes a full path into the parameter tree given a path from the current subsection and the name of an entry.
Definition at line 296 of file parameter_handler.cc.
|
private |
Scan one line of input. input_filename and current_line_n are the name of the input file and the number of the line presently scanned (these are used in exception messages to show where parse errors occurred). This function will raise an exception if the line contains an undeclared subsection or entry, if the line's entry does not match its given pattern, or if the line could not be understood as a valid parameter file expression.
The function modifies its argument, but also takes it by value, so the caller's variable is not changed.
If skip_undefined is true, the parser will skip undefined sections and entries. This is useful for partially parsing a parameter file, for example to obtain only the spatial dimension of the problem. By default all entries and subsections are expected to be declared.
Definition at line 2073 of file parameter_handler.cc.
|
private |
Print out the parameters of the subsection given by the target_subsection_path argument, as well as all subsections within it recursively. This function is called from the print_parameters() function, and is implemented for all style arguments other than XML and JSON (where we can output the entire set of parameters via BOOST functions). The indent_level argument indicates how many spaces the output should be indented, so that subsections properly nest inside the output of higher sections.
Definition at line 1124 of file parameter_handler.cc.
|
virtualdefault |
Destructor. It doesn't actually do anything, but is declared to force derived classes to have a virtual destructor.
|
pure virtual |
create_new must provide a clean object, either by creating a new one or by cleaning an old one.
|
pure virtual |
Get the parameters and run any necessary action.
| MultipleParameterLoop::MultipleParameterLoop | ( | ) |
Constructor
Definition at line 2301 of file parameter_handler.cc.
|
overridevirtualdefault |
Destructor. Declare this only to have a virtual destructor, which is safer as we have virtual functions. It actually does nothing spectacular.
|
overridevirtual |
Read input from a stream until the stream returns the eof condition or error. The second argument can be used to denote the name of the file (if that's what the input stream represents) we are reading from; this is only used when creating output for error messages.
If non-empty last_line is provided, the ParameterHandler object will stop parsing lines after encountering last_line . This is handy when adding extra data that shall be parsed manually.
If skip_undefined is true, the parameter handler will skip undefined sections and entries. This is useful for partially parsing a parameter file, for example to obtain only the spatial dimension of the problem. By default all entries and subsections are expected to be declared.
parse_input functions implemented by ParameterHandler overridden with new behavior by this class. This is because the other two parse_input functions just reformat their inputs and then call this version. Reimplemented from ParameterHandler.
Definition at line 2308 of file parameter_handler.cc.
| void MultipleParameterLoop::loop | ( | MultipleParameterLoop::UserClass & | uc | ) |
run the central loop.
Definition at line 2325 of file parameter_handler.cc.
| std::size_t MultipleParameterLoop::memory_consumption | ( | ) | const |
Determine an estimate for the memory consumption (in bytes) of this object.
Definition at line 2469 of file parameter_handler.cc.
|
inline |
Constructor
Definition at line 2057 of file parameter_handler.h.
| MultipleParameterLoop::Entry::Entry | ( | const std::vector< std::string > & | Path, |
| const std::string & | Name, | ||
| const std::string & | Value | ||
| ) |
Construct an object with given subsection path, name and value. The splitting up into the different variants is done later by split_different_values.
Definition at line 2480 of file parameter_handler.cc.
| void MultipleParameterLoop::Entry::split_different_values | ( | ) |
Split the entry value into the different branches.
Definition at line 2492 of file parameter_handler.cc.
| std::size_t MultipleParameterLoop::Entry::memory_consumption | ( | ) | const |
Determine an estimate for the memory consumption (in bytes) of this object.
Definition at line 2544 of file parameter_handler.cc.
|
private |
Initialize the different branches, i.e. construct the combinations.
Definition at line 2339 of file parameter_handler.cc.
|
private |
Traverse the section currently set by enter_subsection()/leave_subsection() and see which of the entries are variant or array entries. Then fill the multiple_choices variable using this information.
Definition at line 2380 of file parameter_handler.cc.
|
private |
Transfer the entry values for one run to the entry tree.
Definition at line 2421 of file parameter_handler.cc.
|
static |
Exception
|
static |
Exception
|
static |
This class was not registered in the path search mechanism.
|
static |
The PathSearch class could not find a file with this name in its path list.
|
static |
Exception.
| Patterns::Map::Map | ( | const PatternBase & | key_pattern, |
| const PatternBase & | value_pattern, | ||
| const unsigned int | min_elements = 0, |
||
| const unsigned int | max_elements = max_int_value, |
||
| const std::string & | separator = ",", |
||
| const std::string & | key_value_separator = ":" |
||
| ) |
Constructor. Take the given parameter as the specification of valid elements of the list.
The four other arguments can be used to denote minimal and maximal allowable lengths of the list as well as the separators used to delimit pairs of the map and the symbol used to separate keys and values.
Definition at line 821 of file patterns.cc.
| Patterns::Map::Map | ( | const Map & | other | ) |
Copy constructor.
Definition at line 849 of file patterns.cc.
|
overridevirtual |
Return true if the string is a comma-separated list of strings each of which match the pattern given to the constructor.
Implements Patterns::PatternBase.
Definition at line 861 of file patterns.cc.
|
overridevirtual |
Return a description of the pattern that valid strings are expected to match.
Implements Patterns::PatternBase.
Definition at line 891 of file patterns.cc.
|
overridevirtual |
Return a copy of the present object, which is newly allocated on the heap. Ownership of that object is transferred to the caller of this function.
Implements Patterns::PatternBase.
Definition at line 941 of file patterns.cc.
|
static |
Create a new object if the start of description matches description_init. Ownership of that object is transferred to the caller of this function.
Definition at line 965 of file patterns.cc.
|
overridevirtual |
Determine an estimate for the memory consumption (in bytes) of this object.
Reimplemented from Patterns::PatternBase.
Definition at line 953 of file patterns.cc.
| const PatternBase & Patterns::Map::get_key_pattern | ( | ) | const |
Return a reference to the key pattern.
Definition at line 1020 of file patterns.cc.
| const PatternBase & Patterns::Map::get_value_pattern | ( | ) | const |
Return a reference to the value pattern.
Definition at line 1028 of file patterns.cc.
| const std::string & Patterns::Map::get_separator | ( | ) | const |
Return the separator of the map entries.
Definition at line 1036 of file patterns.cc.
| const std::string & Patterns::Map::get_key_value_separator | ( | ) | const |
Return the key-value separator.
Definition at line 1043 of file patterns.cc.
|
static |
Exception.
| Patterns::Tuple::Tuple | ( | const std::vector< std::unique_ptr< PatternBase >> & | patterns, |
| const std::string & | separator = ":" |
||
| ) |
Constructor. Use a vector of unique pointers to Patterns to construct the tuple.
| patterns | The pattern each object of the Tuple should match |
| separator | An optional string used to delimit each element Constructor. |
Definition at line 1053 of file patterns.cc.
| Patterns::Tuple::Tuple | ( | const std::vector< std::unique_ptr< PatternBase >> & | patterns, |
| const char * | separator | ||
| ) |
Constructor. Same as above, specialized for const char *. This is necessary to avoid compilers errors due to the variadic constructors provided below.
Definition at line 1068 of file patterns.cc.
| Patterns::Tuple::Tuple | ( | const std::string & | separator, |
| const PatternTypes &... | patterns | ||
| ) |
Constructor. Creates a Tuple from more than one class derived from PatternBase.
| separator | What separator to use. |
| patterns | The list of patterns to use |
Definition at line 1432 of file patterns.h.
| Patterns::Tuple::Tuple | ( | const char * | separator, |
| const PatternTypes &... | patterns | ||
| ) |
Constructor. This is needed to allow users to specify directly the separator without using std::string(";").
Since we support a pure variadic templates version, without this specialization, the compiler will fail with cryptic errors.
Definition at line 1424 of file patterns.h.
| Patterns::Tuple::Tuple | ( | const PatternTypes &... | patterns | ) |
Constructor. Same as above, using the default separator.
| patterns | The list of patterns to use |
Definition at line 1448 of file patterns.h.
| Patterns::Tuple::Tuple | ( | const Tuple & | other | ) |
Copy constructor.
Definition at line 1075 of file patterns.cc.
|
overridevirtual |
Return true if the string is a list of strings each of which matches the patterns given to the constructor.
Implements Patterns::PatternBase.
Definition at line 1086 of file patterns.cc.
|
overridevirtual |
Return a description of the pattern that valid strings are expected to match.
Definition at line 1105 of file patterns.cc.
|
overridevirtual |
Return a copy of the present object, which is newly allocated on the heap. Ownership of that object is transferred to the caller of this function.
Implements Patterns::PatternBase.
Definition at line 1155 of file patterns.cc.
|
static |
Create a new object if the start of description matches description_init. Ownership of that object is transferred to the caller of this function.
Definition at line 1171 of file patterns.cc.
|
overridevirtual |
Determine an estimate for the memory consumption (in bytes) of this object.
Reimplemented from Patterns::PatternBase.
Definition at line 1162 of file patterns.cc.
| const PatternBase & Patterns::Tuple::get_pattern | ( | const unsigned int | i | ) | const |
Return a reference to the i-th pattern in the tuple.
Definition at line 1219 of file patterns.cc.
| const std::string & Patterns::Tuple::get_separator | ( | ) | const |
Return the separator of the tuple entries.
Definition at line 1227 of file patterns.cc.
| Patterns::MultipleSelection::MultipleSelection | ( | const std::string & | seq | ) |
Constructor. seq is a list of valid options separated by "|".
Definition at line 1237 of file patterns.cc.
|
overridevirtual |
Return true if the string is an element of the description list passed to the constructor.
Implements Patterns::PatternBase.
Definition at line 1252 of file patterns.cc.
|
overridevirtual |
Return a description of the pattern that valid strings are expected to match. Here, this is the list of valid strings passed to the constructor.
Implements Patterns::PatternBase.
Definition at line 1318 of file patterns.cc.
|
overridevirtual |
Return a copy of the present object, which is newly allocated on the heap. Ownership of that object is transferred to the caller of this function.
Implements Patterns::PatternBase.
Definition at line 1353 of file patterns.cc.
|
static |
Create a new object if the start of description matches description_init. Ownership of that object is transferred to the caller of this function.
Definition at line 1369 of file patterns.cc.
|
overridevirtual |
Determine an estimate for the memory consumption (in bytes) of this object.
Reimplemented from Patterns::PatternBase.
Definition at line 1360 of file patterns.cc.
|
static |
Exception.
| Patterns::Bool::Bool | ( | ) |
Constructor.
Definition at line 1391 of file patterns.cc.
|
overridevirtual |
Return a description of the pattern that valid strings are expected to match.
Definition at line 1398 of file patterns.cc.
|
overridevirtual |
Return a copy of the present object, which is newly allocated on the heap. Ownership of that object is transferred to the caller of this function.
Reimplemented from Patterns::Selection.
Definition at line 1426 of file patterns.cc.
|
static |
Create a new object if the start of description matches description_init. Ownership of that object is transferred to the caller of this function.
Definition at line 1434 of file patterns.cc.
|
default |
Constructor. (Allow for at least one non-virtual function in this class, as otherwise sometimes no virtual table is emitted.)
|
overridevirtual |
Return true if the string matches its constraints, i.e. always.
Implements Patterns::PatternBase.
Definition at line 1451 of file patterns.cc.
|
overridevirtual |
Return a description of the pattern that valid strings are expected to match. Here, this is the string "[Anything]".
Implements Patterns::PatternBase.
Definition at line 1459 of file patterns.cc.
|
overridevirtual |
Return a copy of the present object, which is newly allocated on the heap. Ownership of that object is transferred to the caller of this function.
Implements Patterns::PatternBase.
Definition at line 1487 of file patterns.cc.
|
static |
Create a new object if the start of description matches description_init. Ownership of that object is transferred to the caller of this function.
Definition at line 1495 of file patterns.cc.
Constructor. The type of the file can be specified by choosing the flag.
Definition at line 1510 of file patterns.cc.
|
overridevirtual |
Return true if the string matches its constraints, i.e. always.
Implements Patterns::PatternBase.
Definition at line 1517 of file patterns.cc.
|
overridevirtual |
Return a description of the pattern that valid strings are expected to match. Here, this is the string "[Filename]".
Definition at line 1525 of file patterns.cc.
|
overridevirtual |
Return a copy of the present object, which is newly allocated on the heap. Ownership of that object is transferred to the caller of this function.
Implements Patterns::PatternBase.
Definition at line 1561 of file patterns.cc.
|
static |
Create a new object if the start of description matches description_init. Ownership of that object is transferred to the caller of this function.
Definition at line 1569 of file patterns.cc.
|
default |
Constructor.
|
overridevirtual |
Return true if the string matches its constraints, i.e. always.
Implements Patterns::PatternBase.
Definition at line 1601 of file patterns.cc.
|
overridevirtual |
Return a description of the pattern that valid strings are expected to match. Here, this is the string "[Filename]".
Implements Patterns::PatternBase.
Definition at line 1609 of file patterns.cc.
|
overridevirtual |
Return a copy of the present object, which is newly allocated on the heap. Ownership of that object is transferred to the caller of this function.
Implements Patterns::PatternBase.
Definition at line 1637 of file patterns.cc.
|
static |
Create a new object if the start of description matches description_init. Ownership of that object is transferred to the caller of this function.
Definition at line 1645 of file patterns.cc.
|
staticdelete |
Return a std::unique_ptr to a Pattern that can be used to interpret a string as the type of the template argument, and the other way around.
While the current function (in the general Convert template) is deleted, it is implemented and available in the specializations of the Convert class template for particular kinds of template arguments T.
|
staticdelete |
Return a string containing a textual version of the variable s. Use the pattern passed to perform the conversion, or create and use a default one.
While the current function (in the general Convert template) is deleted, it is implemented and available in the specializations of the Convert class template for particular kinds of template arguments T.
|
staticdelete |
Convert a string to a value, using the given pattern. Use the pattern passed to perform the conversion, or create and use a default one.
While the current function (in the general Convert template) is deleted, it is implemented and available in the specializations of the Convert class template for particular kinds of template arguments T.
| std::string Patterns::Tools::to_string | ( | const T & | t | ) |
A utility function that simplifies the conversion to strings of arbitrarily complex types.
This function calls the method Convert<T>::to_string() with the default pattern. An example usage is the following:
See the documentation of the class Patterns::Tools::Convert, and of the helper class Patterns::Tools::RankInfo for details on the way separators are selected when outputting STL container types.
Definition at line 2363 of file patterns.h.
| void Patterns::Tools::to_value | ( | const std::string & | s, |
| T & | t | ||
| ) |
A utility function that simplifies the conversion from strings to arbitrary types.
This function calls the method Convert<T>::to_value() with the default pattern. An example usage is the following:
See the documentation of the class Patterns::Tools::Convert, and of the helper class Patterns::Tools::RankInfo for details on the separators you should use in your string patterns when converting from a string to a container type.
Notice that the current content of variable t is ignored. Its type is used to infer how to interpret the string. If the string is successfully parsed, then t will be set to the parsed content of s.
Definition at line 2371 of file patterns.h.
|
static |
Exception.
|
inlinestatic |
Convert a string to a value, using the given pattern, or a default one.
Definition at line 2168 of file patterns.h.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
staticprivate |
This static function creates a quadrature object according to the name given as a string, and the appropriate order (if the name is "gauss"). It is called from the constructor.
Definition at line 24 of file quadrature_selector.cc.
|
static |
Exception: Object may not be deleted, since it is used.
|
static |
A subscriber with the identification string given to Subscriptor::unsubscribe() did not subscribe to the object.
|
inline |
Read or write the data of this object to or from a stream for the purpose of serialization.
This function does not actually serialize any of the member variables of this class. The reason is that what this class stores is only who subscribes to this object, but who does so at the time of storing the contents of this object does not necessarily have anything to do with who subscribes to the object when it is restored. Consequently, we do not want to overwrite the subscribers at the time of restoring, and then there is no reason to write the subscribers out in the first place.
Definition at line 301 of file subscriptor.h.
|
privatenoexcept |
Check that there are no objects subscribing to this object. If this check passes then it is safe to destroy the current object. It this check fails then this function will either abort or print an error message to deallog (by using the AssertNothrow mechanism), but will not throw an exception.
Definition at line 53 of file subscriptor.cc.
|
static |
Exception for range check. Do not use global exception since this way we can output which index is the wrong one.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
| TableHandler::Column::Column | ( | ) |
Constructor needed by std::map.
Definition at line 147 of file table_handler.cc.
| TableHandler::Column::Column | ( | const std::string & | tex_caption | ) |
Constructor.
Definition at line 136 of file table_handler.cc.
| void TableHandler::Column::pad_column_below | ( | const unsigned int | length | ) |
Pad this column with default constructed elements to the number of rows given by the argument.
Definition at line 159 of file table_handler.cc.
| void TableHandler::Column::save | ( | Archive & | ar, |
| const unsigned int | version | ||
| ) | const |
Read or write the data of this object to or from a stream for the purpose of serialization.
Definition at line 945 of file table_handler.h.
| void TableHandler::Column::invalidate_cache | ( | ) |
Invalidates the string cache of all the entries and recomputes the maximum length max_length.
Definition at line 179 of file table_handler.cc.
|
protected |
Help function that gives a vector of the keys of all columns that are mentioned in column_order, where each supercolumn key is replaced by its subcolumn keys.
This function implicitly checks the consistency of the data. The result is returned in sel_columns.
Definition at line 770 of file table_handler.cc.
|
protected |
Builtin function, that gives the number of rows in the table and that checks if the number of rows is equal in every column. This function is e.g. called before writing output.
Definition at line 749 of file table_handler.cc.
|
static |
|
static |
Exception
|
inline |
Add another task object to the collection.
Definition at line 1818 of file thread_management.h.
|
inline |
Wait for all tasks in the collection to finish. It is not a problem if some of them have already been waited for, i.e. you may call this function more than once, and you can also add new task objects between subsequent calls to this function if you want.
Definition at line 1831 of file thread_management.h.
|
static |
Exception denoting that a class requires some specialization in order to be used.
|
static |
Exception denoting that ADOL-C is a required feature.
|
static |
This exception is raised whenever the an auto-differentiable number does not support the required number of derivative operations
The first parameter to the constructor is the number of derivative operations that it provides, and the second is the minimum number that are required. Both parameters are of type int.
|
static |
An exception which states that a function has been disabled due to the configuration of ADOL-C with the advanced branching feature enabled.
|
static |
An exception to indicate that the string sent to the SymEngine parser is not valid.
| Differentiation::SD::Expression::Expression | ( | ) |
Default constructor.
Definition at line 48 of file symengine_number_types.cc.
|
explicit |
Constructor for boolean types.
Definition at line 53 of file symengine_number_types.cc.
|
explicit |
Constructor for arithmetic number types.
|
explicit |
Constructor for complex numbers templated on arithmetic number types.
| Differentiation::SD::Expression::Expression | ( | const SymEngine::integer_class & | value | ) |
Constructor for integer types.
| Differentiation::SD::Expression::Expression | ( | const NumberType & | numerator, |
| const NumberType & | denominator | ||
| ) |
Constructor for rational types.
It is expected that both the numerator and denominator be integral types.
| Differentiation::SD::Expression::Expression | ( | const SymEngine::rational_class & | value | ) |
Constructor for rational types.
| Differentiation::SD::Expression::Expression | ( | const Expression & | condition, |
| const Expression & | expression_if_true, | ||
| const Expression & | expression_if_false | ||
| ) |
Constructor for a piecewise defined function.
The generated expression may be interpreted as the result of the teniary operator, i.e. (condition ? expression_if_true : expression_if_false).
The condition can be any expression that renders an expression that is convertible to a SymEngine::Boolean operator. This includes:
An example of this constructor's use is as follows:
Definition at line 68 of file symengine_number_types.cc.
| Differentiation::SD::Expression::Expression | ( | const std::vector< std::pair< Expression, Expression >> & | condition_expression, |
| const Expression & | expression_otherwise | ||
| ) |
Constructor for a piecewise defined function.
The generated expression may be interpreted as the result of the set of nested if-elseif-else statements, i.e. (in pseudo-code)
if the input vector has more than 2 elements.
This variant takes the piecewise evaluated conditions and its results as the first argument, and the default return value as the second argument.
Definition at line 84 of file symengine_number_types.cc.
| Differentiation::SD::Expression::Expression | ( | const std::vector< std::pair< Expression, Expression >> & | condition_expression | ) |
Constructor for a piecewise defined function.
The generated expression may be interpreted as the result of the set of nested if-elseif statements, i.e. (in pseudo-code)
if the input vector has more than 2 elements.
This variant takes only the piecewise evaluated conditions and its results. If none of the conditions are met upon evaluation then the returned result will be NaN.
Definition at line 111 of file symengine_number_types.cc.
| Differentiation::SD::Expression::Expression | ( | const char * | symbol | ) |
Constructor for symbolic types.
This constructor initializes a symbolic type with a character array representing its symbolic value.
Definition at line 122 of file symengine_number_types.cc.
| Differentiation::SD::Expression::Expression | ( | const std::string & | symb_expr, |
| const bool | parse_as_expression = false |
||
| ) |
Constructor for symbolic types.
This constructor initializes a symbolic type with a string representing its symbolic value. If the parse_as_expression flag is false, then the symb_expr (potentially composed of multiple characters) will be interpreted as a single symbol. If the parse_as_expression flag is true, then the symb_expr will be parsed as a symbolic expression (potentially composed of multiple symbols, constants, etc.).
Definition at line 127 of file symengine_number_types.cc.
| Differentiation::SD::Expression::Expression | ( | const std::string & | symbol_func, |
| const types::symbol_vector & | arguments | ||
| ) |
Constructor for function symbol types.
This constructor initializes a function symbol with a string representing its symbolic name.
Definition at line 145 of file symengine_number_types.cc.
|
default |
Copy constructor.
|
explicit |
Copy constructor.
| Differentiation::SD::Expression::Expression | ( | const SymEngine::RCP< const SymEngine::Basic > & | rhs | ) |
Copy constructor.
This allows us to create our class straight from the results of SymEngine operations. This is especially important for operations like "diff", because the returned result is not primitive, but rather a set of compound operations.
|
default |
Move constructor.
| Differentiation::SD::Expression::Expression | ( | SymEngine::RCP< const SymEngine::Basic > && | rhs | ) |
Move constructor.
This allows us to create our class straight from the results of SymEngine operations. This is especially important for operations like "diff", because the returned result is not primitive, but rather a set of compound operations.
|
virtualdefault |
Destructor.
| Expression & Differentiation::SD::Expression::parse | ( | const std::string & | expression | ) |
Utilities Parse an expression from a string representing a symbolic expression. This overwrites any existing value or expression that this object represents.
Definition at line 172 of file symengine_number_types.cc.
| std::ostream & Differentiation::SD::Expression::print | ( | std::ostream & | stream | ) | const |
Print the value stored by this object.
Since the stored value could be one of a number of types, we leave SymEngine to cast and output the correct representation of the data.
Definition at line 180 of file symengine_number_types.cc.
| void Differentiation::SD::Expression::save | ( | std::ostream & | stream | ) | const |
Save the value stored by this object to the stream.
Each expression will be saved on a new line of the stream.
Definition at line 188 of file symengine_number_types.cc.
| void Differentiation::SD::Expression::load | ( | std::istream & | stream | ) |
Load the value stored in the stream into this object.
It is expected that each expression appears on its own on single line of stream.
Definition at line 198 of file symengine_number_types.cc.
| void Differentiation::SD::Expression::serialize | ( | Archive & | archive, |
| const unsigned int | version | ||
| ) |
Write and read the data of this object from a stream for the purpose of serialization.
This effecively saves or loads the value stored into/out of the archive with the given version number into this object. If deserializing data, then the previous contents of this object are thrown away.
| const SE::Expression & Differentiation::SD::Expression::get_expression | ( | ) | const |
Return the value or expression that this class instance represents.
Definition at line 213 of file symengine_number_types.cc.
| const SE::Basic & Differentiation::SD::Expression::get_value | ( | ) | const |
Return the primitive SymEngine data type that stores the value or expression represented by this object.
Definition at line 227 of file symengine_number_types.cc.
| const SE::RCP< const SE::Basic > & Differentiation::SD::Expression::get_RCP | ( | ) | const |
Return the pointer to the primitive SymEngine data type that stores the value or expression represented by this object.
Definition at line 234 of file symengine_number_types.cc.
| Expression & Differentiation::SD::Expression::operator= | ( | const Expression & | rhs | ) |
Assignment operator.
Sets the data of this object's expression equal to that of the rhs object.
Definition at line 310 of file symengine_number_types.cc.
| Expression & Differentiation::SD::Expression::operator= | ( | Expression && | rhs | ) |
Assignment operator.
Sets the data of this object's expression equal to that of the rhs object.
Definition at line 320 of file symengine_number_types.cc.
| Expression & Differentiation::SD::Expression::operator+= | ( | const Expression & | rhs | ) |
Addition assignment.
The rhs expression is added in-place to that of this object's expression.
Definition at line 337 of file symengine_number_types.cc.
| Expression & Differentiation::SD::Expression::operator-= | ( | const Expression & | rhs | ) |
Subtraction assignment.
The rhs expression is subtracted in-place from that of this object's expression.
Definition at line 345 of file symengine_number_types.cc.
| Expression & Differentiation::SD::Expression::operator*= | ( | const Expression & | rhs | ) |
Multiplication assignment.
This object's expression is multiplied in-place by that of the rhs expression.
Definition at line 353 of file symengine_number_types.cc.
| Expression & Differentiation::SD::Expression::operator/= | ( | const Expression & | rhs | ) |
Division assignment.
This object's expression is divided in-place by that of the rhs expression.
Definition at line 361 of file symengine_number_types.cc.
| Expression& Differentiation::SD::Expression::operator= | ( | const NumberType & | rhs | ) |
Assignment operator.
Set the data of this object's expression equal to the numerical value of the rhs.
| Expression Differentiation::SD::Expression::operator- | ( | ) | const |
Negation operator.
Return a the result of pre-multipying this object's expression by -1.
Definition at line 330 of file symengine_number_types.cc.
| Expression& Differentiation::SD::Expression::operator+= | ( | const NumberType & | rhs | ) |
Addition assignment.
The numerical value of the rhs is added in-place to that of this object's expression.
| Expression& Differentiation::SD::Expression::operator-= | ( | const NumberType & | rhs | ) |
Subtraction assignment.
The numerical value of the rhs is subtracted in-place from that of this object's expression.
| Expression& Differentiation::SD::Expression::operator*= | ( | const NumberType & | rhs | ) |
Multiplication assignment.
This object's expression is multiplied in-place by that of the numerical value of the rhs.
| Expression& Differentiation::SD::Expression::operator/= | ( | const NumberType & | rhs | ) |
Division assignment.
This object's expression is divided in-place by that of the numerical value of the rhs.
| Expression Differentiation::SD::Expression::differentiate | ( | const Expression & | symbol | ) | const |
Return the derivative of this object's expression with respect to the given symbol.
Definition at line 259 of file symengine_number_types.cc.
| Expression Differentiation::SD::Expression::differentiate | ( | const SymEngine::RCP< const SymEngine::Symbol > & | symbol | ) | const |
Return the derivative of this object's expression with respect to the given symbol.
| Expression Differentiation::SD::Expression::differentiate | ( | const SymEngine::RCP< const SymEngine::Basic > & | symbol | ) | const |
Return the derivative of this object's expression with respect to the potential symbol.
| Expression Differentiation::SD::Expression::substitute | ( | const types::substitution_map & | substitution_values | ) | const |
Perform substitution of all symbols found in this object's expression that match a key in the substitution_values map.
substitution_values that is paired with a key) need not necessarily be numerical, but may also be another symbolic type.Definition at line 284 of file symengine_number_types.cc.
| Expression Differentiation::SD::Expression::substitute | ( | const Expression & | symbol, |
| const Expression & | value | ||
| ) | const |
Perform substitution of all symbols found in this object's expression that match the symbol. Each symbol will be substituted with the given value.
Definition at line 293 of file symengine_number_types.cc.
| Expression Differentiation::SD::Expression::substitute | ( | const Expression & | symbol, |
| const NumberType & | value | ||
| ) | const |
Perform substitution of all symbols found in this object's expression that match the symbol. Each symbol will be substituted with the given value.
| ReturnType Differentiation::SD::Expression::substitute_and_evaluate | ( | const types::substitution_map & | substitution_values | ) | const |
Full substitution and evaluation. This creates a Expression by symbol substitution and then immediately computes its numerical value.
|
explicit |
Conversion operator for real integer or floating point values, and complex integer or floating point values.
const NumberType val = static_cast<NumberType>(Expression);
or, probably less desirably,
const NumberType val = NumberType(Expression);
|
explicit |
Conversion operator that returns the value or expression that this class instance represents.
| Differentiation::SD::Expression::operator const SymEngine::RCP< const SymEngine::Basic > & | ( | ) | const |
Conversion operator that returns a SymEngine reference counted pointer to the fundamental type.
|
protected |
Return the value or expression that this class instance represents.
Definition at line 220 of file symengine_number_types.cc.
| std::ostream & Differentiation::SD::operator<< | ( | std::ostream & | stream, |
| const Expression & | expression | ||
| ) |
Bitwise left shift operator.
This is used to output the expression to the input stream.
Definition at line 369 of file symengine_number_types.cc.
| std::istream & Differentiation::SD::operator>> | ( | std::istream & | stream, |
| Expression & | expression | ||
| ) |
Bitwise right shift operator.
This is used to read in an expression from the input stream.
Definition at line 377 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator== | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Equality operator.
Return whether the lhs is equal to the rhs.
Definition at line 387 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator!= | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Non-equality operator.
Return whether the lhs is not equal to the rhs.
Definition at line 394 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator< | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Less than operator.
Return whether the lhs is less than the rhs.
Definition at line 401 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator> | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Greater than operator.
Return whether the lhs is greater than the rhs.
Definition at line 408 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator<= | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Less than or equals operator.
Return whether the lhs is less than, or equal to, the rhs.
Definition at line 415 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator>= | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Greater than or equals operator.
Return whether the lhs is greater than, or equal to, the rhs.
Definition at line 422 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator! | ( | const Expression & | expression | ) |
Logical not operator.
Definition at line 428 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator& | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Logical and operator.
Definition at line 440 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator| | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Logical inclusive or operator.
Definition at line 457 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator^ | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Logical exclusive or (xor) operator.
Definition at line 474 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator&& | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
And operator.
Definition at line 491 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator|| | ( | const Expression & | lhs, |
| const Expression & | rhs | ||
| ) |
Inclusive or operator.
Definition at line 498 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator+ | ( | Expression | lhs, |
| const Expression & | rhs | ||
| ) |
Addition operator.
Return the result of adding the rhs to the lhs.
Definition at line 505 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator- | ( | Expression | lhs, |
| const Expression & | rhs | ||
| ) |
Subtraction operator.
Return the result of subtracting the rhs from the lhs.
Definition at line 513 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator* | ( | Expression | lhs, |
| const Expression & | rhs | ||
| ) |
Multiplication operator.
Return the result of multiplying the lhs by the rhs.
Definition at line 520 of file symengine_number_types.cc.
| Expression Differentiation::SD::operator/ | ( | Expression | lhs, |
| const Expression & | rhs | ||
| ) |
Division operator.
Return the result of dividing the lhs by the rhs.
Definition at line 528 of file symengine_number_types.cc.
|
inline |
General addition operator.
Return the result of adding the rhs to the lhs. The lhs type may be any supported number type, and the result is promoted to a Expression. The type conversion makes writing scalar expressions using Expression more natural.
Definition at line 1020 of file symengine_number_types.h.
|
inline |
General addition operator.
Return the result of adding the rhs to the lhs. The rhs type may be any supported number type, and the result is promoted to a Expression. The type conversion makes writing scalar expressions using Expression more natural.
Definition at line 1037 of file symengine_number_types.h.
|
inline |
General subtraction operator.
Return the result of subtracting the rhs from the lhs. The lhs type may be any supported number type, and the result is promoted to a Expression. The type conversion makes writing scalar expressions using Expression more natural.
Definition at line 1054 of file symengine_number_types.h.
|
inline |
General subtraction operator.
Return the result of subtracting the rhs from the lhs. The rhs type may be any supported number type, and the result is promoted to a Expression. The type conversion makes writing scalar expressions using Expression more natural.
Definition at line 1071 of file symengine_number_types.h.
|
inline |
General multiplication operator.
Return the result of multiplying the lhs by the rhs. The lhs type may be any supported number type, and the result is promoted to a Expression. The type conversion makes writing scalar expressions using Expression more natural.
Definition at line 1087 of file symengine_number_types.h.
|
inline |
General multiplication operator.
Return the result of multiplying the lhs by the rhs. The rhs type may be any supported number type, and the result is promoted to a Expression. The type conversion makes writing scalar expressions using Expression more natural.
Definition at line 1103 of file symengine_number_types.h.
|
inline |
General division operator.
Return the result of dividing the lhs by the rhs. The lhs type may be any supported number type, and the result is promoted to a Expression. The type conversion makes writing scalar expressions using Expression more natural.
Definition at line 1120 of file symengine_number_types.h.
|
inline |
General division operator.
Return the result of dividing the lhs by the rhs. The lhs type may be any supported number type, and the result is promoted to a Expression. The type conversion makes writing scalar expressions using Expression more natural.
Definition at line 1137 of file symengine_number_types.h.
|
static |
Exceptions for child classes
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
A function has been called for a cell which should be active, but is refined.
|
static |
Exception
|
static |
Exceptions for child classes
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
A function has been called for a cell which should be active, but is refined.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
The triangulation level you accessed is empty.
|
static |
Exception
|
static |
Exception
|
static |
The function is only implemented for Discontinuous Galerkin Finite elements.
|
static |
|
static |
|
static |
Exception
|
static |
The DoFHandler or hp::DoFHandler was not initialized with a finite element. Please call DoFHandler::distribute_dofs() etc. first.
|
static |
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Attempt to access support points of a finite element that is not Lagrangian.
|
static |
Attempt to access embedding matrices of a finite element that did not implement these matrices.
|
static |
Attempt to access restriction matrices of a finite element that did not implement these matrices.
Exception
|
static |
Exception
|
static |
Exception
|
static |
Attempt to construct an FE_Q object of degree 0
|
static |
The string used for get_fe_by_name() cannot be translated to a finite element.
Either the string is badly formatted or you are using a custom element that must be added using add_fe_name() first.
|
static |
The string used for get_fe_by_name() cannot be translated to a finite element.
Dimension arguments in finite element names should be avoided. If they are there, the dimension should be dim or d. Here, you gave a numeric dimension argument, which does not match the template dimension of the finite element class.
|
static |
Exception
|
static |
The finite element must be primitive.
|
static |
Exception
|
static |
A continuous element is used on a mesh with hanging nodes, but the constraint matrices are missing.
|
static |
You need at least two grid levels.
|
static |
The dimensions of the matrix used did not match the expected dimensions.
|
static |
Exception thrown if an embedding matrix was computed inaccurately.
|
static |
Exception thrown if one variable may not be greater than another.
|
static |
This exception is thrown if FEValuesBase is asked to return the value of a field which was not required by the UpdateFlags for this FEValuesBase.
|
static |
Mismatch between the FEValues FiniteElement and cell->get_dof_handler().get_fe()
|
static |
A given shape function is not primitive, but it needs to be.
|
static |
The given FiniteElement is not a primitive element, see FiniteElement::is_primitive().
|
static |
|
static |
|
static |
Exception
|
static |
Computing the mapping between a real space point and a point in reference space failed, typically because the given point lies outside the cell where the inverse mapping is not unique.
|
static |
deal.II assumes the Jacobian determinant to be positive. When the cell geometry is distorted under the image of the mapping, the mapping becomes invalid and this exception is thrown.
|
static |
Exception
|
static |
Exception.
|
static |
Exception which is thrown when the mapping is being evaluated at non-active cell.
|
static |
Exception.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception for input that is not properly oriented.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
|
static |
|
static |
Exception
|
static |
An exception thrown if the vector with cell criteria contains negative values
|
static |
One of the threshold parameters causes trouble. Or the refinement and coarsening thresholds overlap.
|
static |
An exception that is thrown whenever the edges of a mesh are not orientable.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
staticprivate |
|
static |
Exception.
|
static |
Exception.
|
static |
Exception
|
static |
The function raising this exception can only operate on an empty Triangulation, i.e., a Triangulation without grid cells.
|
static |
Trying to re-read a grid, an error occurred.
|
static |
Exception
|
static |
The triangulation level you accessed is empty.
|
static |
Exception
|
static |
Exception
Requested boundary_id not found
|
static |
|
static |
The cell is not an active cell, but it already has children. Some operations, like setting refinement flags or accessing degrees of freedom are only possible on active cells.
|
static |
Trying to access the children of a cell which is in fact active.
|
static |
Trying to access the parent of a cell which is in the coarsest level of the triangulation.
|
static |
|
static |
|
static |
|
static |
You are trying to access the level of a face, but faces have no inherent level. The level of a face can only be determined by the level of an adjacent face, which in turn implies that a face can have several levels.
|
static |
You are trying to get the periodic neighbor for a face, which does not have a periodic neighbor. For more information on this, refer to entry for periodic boundaries.
|
static |
|
static |
Exception for TriaObjects with level, i.e. cells.
|
static |
Exception.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Triangulation objects can either access a user pointer or a user index. What you tried to do is trying to access one of those after using the other.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
The triangulation level you accessed is empty.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
staticprivate |
Exceptions.
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
static |
Each diagonal block must contain one and only one matrix. If this exception is thrown, you did not enter a matrix here.
|
static |
Each diagonal block must contain one and only one matrix. If this exception is thrown, you entered a second matrix here.
|
private |
Add all off-diagonal contributions and return the entry of the diagonal element for one row.
Definition at line 282 of file block_matrix_array.cc.
|
static |
Exception
|
static |
Exception
|
protected |
Release all memory and return to a state just like after having called the default constructor. It also forgets the sparsity pattern it was previously tied to.
This calls clear for all sub-matrices and then resets this object to have no blocks at all.
This function is protected since it may be necessary to release additional structures. A derived class can make it public again, if it is sufficient.
|
protected |
This function collects the sizes of the sub-objects and stores them in internal arrays, in order to be able to relay global indices into the matrix to indices into the subobjects. You must call this function each time after you have changed the size of the sub-objects.
Derived classes should call this function whenever the size of the sub- objects has changed and the X_block_indices arrays need to be updated.
Note that this function is not public since not all derived classes need to export its interface. For example, for the usual deal.II SparseMatrix class, the sizes are implicitly determined whenever reinit() is called, and individual blocks cannot be resized. For that class, this function therefore does not have to be public. On the other hand, for the PETSc classes, there is no associated sparsity pattern object that determines the block sizes, and for these the function needs to be publicly available. These classes therefore export this function.
|
protected |
Matrix-vector multiplication: let 
with 
being this matrix.
Due to problems with deriving template arguments between the block and non-block versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
|
protected |
Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block column.
Due to problems with deriving template arguments between the block and non-block versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
|
protected |
Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block row.
Due to problems with deriving template arguments between the block and non-block versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
|
protected |
Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block.
Due to problems with deriving template arguments between the block and non-block versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
|
protected |
Matrix-vector multiplication: let 
with being this matrix. This function does the same as vmult() but takes the transposed matrix.
Due to problems with deriving template arguments between the block and non-block versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
|
protected |
Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block row.
Due to problems with deriving template arguments between the block and non-block versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
|
protected |
Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block column.
Due to problems with deriving template arguments between the block and non-block versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
|
protected |
Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block.
Due to problems with deriving template arguments between the block and non-block versions of the vmult/Tvmult functions, the actual functions are implemented in derived classes, with implementations forwarding the calls to the implementations provided here under a unique name for which template arguments can be derived by the compiler.
|
protected |
Some matrix types, in particular PETSc, need to synchronize set and add operations. This has to be done for all matrices in the BlockMatrix. This routine prepares adding of elements by notifying all blocks. Called by all internal routines before adding elements.
|
protected |
Notifies all blocks to let them prepare for setting elements, see prepare_add_operation().
|
inline |
Copy operator. This is needed because the default copy operator of this class is deleted (since Threads::Mutex is not copyable) and hence the default copy operator of the enclosing class is also deleted.
The implementation here simply does nothing – TemporaryData objects are just scratch objects that are resized at the beginning of their use, so there is no point actually copying anything.
Definition at line 1049 of file block_matrix_base.h.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
default |
Initialize the matrix empty, that is with no memory allocated. This is useful if you want such objects as member variables in other classes. You can make the structure usable by calling the reinit() function.
Initialize the matrix with the given number of block rows and columns. The blocks themselves are still empty, and you have to call collect_sizes() after you assign them sizes.
Definition at line 331 of file block_sparsity_pattern.cc.
|
inline |
Forwarding to BlockSparsityPatternBase::reinit().
Definition at line 998 of file block_sparsity_pattern.h.
| void BlockSparsityPattern::reinit | ( | const BlockIndices & | row_indices, |
| const BlockIndices & | col_indices, | ||
| const std::vector< std::vector< unsigned int >> & | row_lengths | ||
| ) |
Initialize the pattern with two BlockIndices for the block structures of matrix rows and columns as well as a row length vector.
The row length vector should be in the format produced by DoFTools. Alternatively, there is a simplified version, where each of the inner vectors has length one. Then, the corresponding entry is used as the maximal row length.
For the diagonal blocks, the inner SparsityPattern is initialized with optimized diagonals, while this is not done for the off-diagonal blocks.
Definition at line 338 of file block_sparsity_pattern.cc.
| bool BlockSparsityPattern::is_compressed | ( | ) | const |
Return whether the structure is compressed or not, i.e. whether all sub- matrices are compressed.
Definition at line 376 of file block_sparsity_pattern.cc.
| std::size_t BlockSparsityPattern::memory_consumption | ( | ) | const |
Determine an estimate for the memory consumption (in bytes) of this object.
Definition at line 387 of file block_sparsity_pattern.cc.
| void BlockSparsityPattern::copy_from | ( | const BlockDynamicSparsityPattern & | dsp | ) |
Copy data from an object of type BlockDynamicSparsityPattern, i.e. resize this object to the size of the given argument, and copy over the contents of each of the subobjects. Previous content of this object is lost.
Definition at line 405 of file block_sparsity_pattern.cc.
|
default |
Initialize the matrix empty, that is with no memory allocated. This is useful if you want such objects as member variables in other classes. You can make the structure usable by calling the reinit() function.
| BlockDynamicSparsityPattern::BlockDynamicSparsityPattern | ( | const size_type | n_rows, |
| const size_type | n_columns | ||
| ) |
Initialize the matrix with the given number of block rows and columns. The blocks themselves are still empty, and you have to call collect_sizes() after you assign them sizes.
Definition at line 423 of file block_sparsity_pattern.cc.
| BlockDynamicSparsityPattern::BlockDynamicSparsityPattern | ( | const std::vector< size_type > & | row_block_sizes, |
| const std::vector< size_type > & | col_block_sizes | ||
| ) |
Initialize the pattern with two BlockIndices for the block structures of matrix rows and columns. This function is equivalent to calling the previous constructor with the length of the two index vector and then entering the index values.
Definition at line 431 of file block_sparsity_pattern.cc.
| BlockDynamicSparsityPattern::BlockDynamicSparsityPattern | ( | const std::vector< IndexSet > & | partitioning | ) |
Initialize the pattern with symmetric blocks. The number of IndexSets in the vector determine the number of rows and columns of blocks. The size of each block is determined by the size() of the respective IndexSet. Each block only stores the rows given by the values in the IndexSet, which is useful for distributed memory parallel computations and usually corresponds to the locally owned DoFs.
Definition at line 444 of file block_sparsity_pattern.cc.
| BlockDynamicSparsityPattern::BlockDynamicSparsityPattern | ( | const BlockIndices & | row_indices, |
| const BlockIndices & | col_indices | ||
| ) |
Initialize the pattern with two BlockIndices for the block structures of matrix rows and columns.
Definition at line 458 of file block_sparsity_pattern.cc.
| void BlockDynamicSparsityPattern::reinit | ( | const std::vector< size_type > & | row_block_sizes, |
| const std::vector< size_type > & | col_block_sizes | ||
| ) |
Resize the pattern to a tensor product of matrices with dimensions defined by the arguments.
The matrix will have as many block rows and columns as there are entries in the two arguments. The block at position (i,j) will have the dimensions row_block_sizes[i] times col_block_sizes[j].
Definition at line 467 of file block_sparsity_pattern.cc.
| void BlockDynamicSparsityPattern::reinit | ( | const std::vector< IndexSet > & | partitioning | ) |
Resize the pattern with symmetric blocks determined by the size() of each IndexSet. See the constructor taking a vector of IndexSets for details.
Definition at line 480 of file block_sparsity_pattern.cc.
| void BlockDynamicSparsityPattern::reinit | ( | const BlockIndices & | row_indices, |
| const BlockIndices & | col_indices | ||
| ) |
Resize the matrix to a tensor product of matrices with dimensions defined by the arguments. The two BlockIndices objects must be initialized and the sparsity pattern will have the same block structure afterwards.
Definition at line 493 of file block_sparsity_pattern.cc.
|
inline |
Access to column number field. Return the column number of the index th entry in row row.
Definition at line 969 of file block_sparsity_pattern.h.
|
static |
Exception
|
static |
Exception thrown when one performs arithmetical comparisons on iterators belonging to two different block vectors.
|
private |
Move forward one element.
|
private |
Move backward one element.
|
default |
Default constructor.
|
default |
Copy constructor.
|
defaultnoexcept |
Move constructor. Each block of the argument vector is moved into the current object if the underlying VectorType is move-constructible, otherwise they are copied.
| void BlockVectorBase< VectorType >::collect_sizes | ( | ) |
Update internal structures after resizing vectors. Whenever you reinited a block of a block vector, the internal data structures are corrupted. Therefore, you should call this function after all blocks got their new size.
| void BlockVectorBase< VectorType >::compress | ( | ::VectorOperation::values | operation | ) |
Call the compress() function on all the subblocks of the matrix.
This functionality only needs to be called if using MPI based vectors and exists in other objects for compatibility.
See Compressing distributed objects for more information.
| BlockType& BlockVectorBase< VectorType >::block | ( | const unsigned int | i | ) |
Access to a single block.
| const BlockType& BlockVectorBase< VectorType >::block | ( | const unsigned int | i | ) | const |
Read-only access to a single block.
| const BlockIndices& BlockVectorBase< VectorType >::get_block_indices | ( | ) | const |
Return a reference on the object that describes the mapping between block and global indices. The use of this function is highly deprecated and it should vanish in one of the next versions
| unsigned int BlockVectorBase< VectorType >::n_blocks | ( | ) | const |
Number of blocks.
| std::size_t BlockVectorBase< VectorType >::size | ( | ) | const |
Return dimension of the vector. This is the sum of the dimensions of all components.
| IndexSet BlockVectorBase< VectorType >::locally_owned_elements | ( | ) | const |
Return an index set that describes which elements of this vector are owned by the current processor. Note that this index set does not include elements this vector may store locally as ghost elements but that are in fact owned by another processor. As a consequence, the index sets returned on different processors if this is a distributed vector will form disjoint sets that add up to the complete index set. Obviously, if a vector is created on only one processor, then the result would satisfy
For block vectors, this function returns the union of the locally owned elements of the individual blocks, shifted by their respective index offsets.
| iterator BlockVectorBase< VectorType >::begin | ( | ) |
Return an iterator pointing to the first element.
| const_iterator BlockVectorBase< VectorType >::begin | ( | ) | const |
Return an iterator pointing to the first element of a constant block vector.
| iterator BlockVectorBase< VectorType >::end | ( | ) |
Return an iterator pointing to the element past the end.
| const_iterator BlockVectorBase< VectorType >::end | ( | ) | const |
Return an iterator pointing to the element past the end of a constant block vector.
| value_type BlockVectorBase< VectorType >::operator() | ( | const size_type | i | ) | const |
Access components, returns U(i).
| reference BlockVectorBase< VectorType >::operator() | ( | const size_type | i | ) |
Access components, returns U(i) as a writeable reference.
| value_type BlockVectorBase< VectorType >::operator[] | ( | const size_type | i | ) | const |
Access components, returns U(i).
Exactly the same as operator().
| reference BlockVectorBase< VectorType >::operator[] | ( | const size_type | i | ) |
Access components, returns U(i) as a writeable reference.
Exactly the same as operator().
| void BlockVectorBase< VectorType >::extract_subvector_to | ( | const std::vector< size_type > & | indices, |
| std::vector< OtherNumber > & | values | ||
| ) | const |
Instead of getting individual elements of a vector via operator(), this function allows getting a whole set of elements at once. The indices of the elements to be read are stated in the first argument, the corresponding values are returned in the second.
If the current vector is called v, then this function is the equivalent to the code
indices and values arrays must be identical. | void BlockVectorBase< VectorType >::extract_subvector_to | ( | ForwardIterator | indices_begin, |
| const ForwardIterator | indices_end, | ||
| OutputIterator | values_begin | ||
| ) | const |
Instead of getting individual elements of a vector via operator(), this function allows getting a whole set of elements at once. In contrast to the previous function, this function obtains the indices of the elements by dereferencing all elements of the iterator range provided by the first two arguments, and puts the vector values into memory locations obtained by dereferencing a range of iterators starting at the location pointed to by the third argument.
If the current vector is called v, then this function is the equivalent to the code
values_begin as there are iterators between indices_begin and indices_end. | BlockVectorBase& BlockVectorBase< VectorType >::operator= | ( | const value_type | s | ) |
Copy operator: fill all components of the vector with the given scalar value.
| BlockVectorBase& BlockVectorBase< VectorType >::operator= | ( | const BlockVectorBase< VectorType > & | V | ) |
Copy operator for arguments of the same type.
|
default |
Move assignment operator. Move each block of the given argument vector into the current object if VectorType is move-constructible, otherwise copy them.
| BlockVectorBase& BlockVectorBase< VectorType >::operator= | ( | const BlockVectorBase< VectorType2 > & | V | ) |
Copy operator for template arguments of different types.
| BlockVectorBase& BlockVectorBase< VectorType >::operator= | ( | const VectorType & | v | ) |
Copy operator from non-block vectors to block vectors.
| bool BlockVectorBase< VectorType >::operator== | ( | const BlockVectorBase< VectorType2 > & | v | ) | const |
Check for equality of two block vector types. This operation is only allowed if the two vectors already have the same block structure.
| value_type BlockVectorBase< VectorType >::operator* | ( | const BlockVectorBase< VectorType > & | V | ) | const |
: scalar product.
| real_type BlockVectorBase< VectorType >::norm_sqr | ( | ) | const |
Return the square of the 
-norm.
| value_type BlockVectorBase< VectorType >::mean_value | ( | ) | const |
Return the mean value of the elements of this vector.
| real_type BlockVectorBase< VectorType >::l1_norm | ( | ) | const |
Return the 
-norm of the vector, i.e. the sum of the absolute values.
| real_type BlockVectorBase< VectorType >::l2_norm | ( | ) | const |
Return the -norm of the vector, i.e. the square root of the sum of the squares of the elements.
| real_type BlockVectorBase< VectorType >::linfty_norm | ( | ) | const |
Return the maximum absolute value of the elements of this vector, which is the 
-norm of a vector.
| value_type BlockVectorBase< VectorType >::add_and_dot | ( | const value_type | a, |
| const BlockVectorBase< VectorType > & | V, | ||
| const BlockVectorBase< VectorType > & | W | ||
| ) |
Performs a combined operation of a vector addition and a subsequent inner product, returning the value of the inner product. In other words, the result of this function is the same as if the user called
The reason this function exists is that this operation involves less memory transfer than calling the two functions separately on deal.II's vector classes (Vector<Number> and LinearAlgebra::distributed::Vector<double>). This method only needs to load three vectors, this, V, W, whereas calling separate methods means to load the calling vector this twice. Since most vector operations are memory transfer limited, this reduces the time by 25% (or 50% if W equals this).
For complex-valued vectors, the scalar product in the second step is implemented as 
.
| bool BlockVectorBase< VectorType >::in_local_range | ( | const size_type | global_index | ) | const |
Return true if the given global index is in the local range of this processor. Asks the corresponding block.
| bool BlockVectorBase< VectorType >::all_zero | ( | ) | const |
Return whether the vector contains only elements with value zero. This function is mainly for internal consistency check and should seldom be used when not in debug mode since it uses quite some time.
| bool BlockVectorBase< VectorType >::is_non_negative | ( | ) | const |
Return true if the vector has no negative entries, i.e. all entries are zero or positive. This function is used, for example, to check whether refinement indicators are really all positive (or zero).
| BlockVectorBase& BlockVectorBase< VectorType >::operator+= | ( | const BlockVectorBase< VectorType > & | V | ) |
Addition operator. Fast equivalent to U.add(1, V).
| BlockVectorBase& BlockVectorBase< VectorType >::operator-= | ( | const BlockVectorBase< VectorType > & | V | ) |
Subtraction operator. Fast equivalent to U.add(-1, V).
| void BlockVectorBase< VectorType >::add | ( | const std::vector< size_type > & | indices, |
| const std::vector< Number > & | values | ||
| ) |
A collective add operation: This function adds a whole set of values stored in values to the vector components specified by indices.
| void BlockVectorBase< VectorType >::add | ( | const std::vector< size_type > & | indices, |
| const Vector< Number > & | values | ||
| ) |
This is a second collective add operation. As a difference, this function takes a deal.II vector of values.
| void BlockVectorBase< VectorType >::add | ( | const size_type | n_elements, |
| const size_type * | indices, | ||
| const Number * | values | ||
| ) |
Take an address where n_elements are stored contiguously and add them into the vector. Handles all cases which are not covered by the other two add() functions above.
| void BlockVectorBase< VectorType >::add | ( | const value_type | s | ) |
. Addition of s to all components. Note that s is a scalar and not a vector.
| void BlockVectorBase< VectorType >::add | ( | const value_type | a, |
| const BlockVectorBase< VectorType > & | V | ||
| ) |
U+=a*V. Simple addition of a scaled vector.
| void BlockVectorBase< VectorType >::add | ( | const value_type | a, |
| const BlockVectorBase< VectorType > & | V, | ||
| const value_type | b, | ||
| const BlockVectorBase< VectorType > & | W | ||
| ) |
U+=a*V+b*W. Multiple addition of scaled vectors.
| void BlockVectorBase< VectorType >::sadd | ( | const value_type | s, |
| const BlockVectorBase< VectorType > & | V | ||
| ) |
U=s*U+V. Scaling and simple vector addition.
| void BlockVectorBase< VectorType >::sadd | ( | const value_type | s, |
| const value_type | a, | ||
| const BlockVectorBase< VectorType > & | V | ||
| ) |
U=s*U+a*V. Scaling and simple addition.
| void BlockVectorBase< VectorType >::sadd | ( | const value_type | s, |
| const value_type | a, | ||
| const BlockVectorBase< VectorType > & | V, | ||
| const value_type | b, | ||
| const BlockVectorBase< VectorType > & | W | ||
| ) |
U=s*U+a*V+b*W. Scaling and multiple addition.
| void BlockVectorBase< VectorType >::sadd | ( | const value_type | s, |
| const value_type | a, | ||
| const BlockVectorBase< VectorType > & | V, | ||
| const value_type | b, | ||
| const BlockVectorBase< VectorType > & | W, | ||
| const value_type | c, | ||
| const BlockVectorBase< VectorType > & | X | ||
| ) |
U=s*U+a*V+b*W+c*X. Scaling and multiple addition.
| BlockVectorBase& BlockVectorBase< VectorType >::operator*= | ( | const value_type | factor | ) |
Scale each element of the vector by a constant value.
| BlockVectorBase& BlockVectorBase< VectorType >::operator/= | ( | const value_type | factor | ) |
Scale each element of the vector by the inverse of the given value.
| void BlockVectorBase< VectorType >::scale | ( | const BlockVector2 & | v | ) |
Multiply each element of this vector by the corresponding element of v.
| void BlockVectorBase< VectorType >::equ | ( | const value_type | a, |
| const BlockVector2 & | V | ||
| ) |
U=a*V. Assignment.
| void BlockVectorBase< VectorType >::equ | ( | const value_type | a, |
| const BlockVectorBase< VectorType > & | V, | ||
| const value_type | b, | ||
| const BlockVectorBase< VectorType > & | W | ||
| ) |
U=a*V+b*W. Replacing by sum.
| void BlockVectorBase< VectorType >::update_ghost_values | ( | ) | const |
Update the ghost values by calling update_ghost_values for each block.
| std::size_t BlockVectorBase< VectorType >::memory_consumption | ( | ) | const |
Determine an estimate for the memory consumption (in bytes) of this object.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
private |
Return the location of entry 
within the val array.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
The operation is only allowed after the SparsityPattern has been set up and compress() was called.
|
static |
This operation changes the structure of the SparsityPattern and is not possible after compress() has been called.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Attempt to perform an operation between two incompatible vector types.
|
staticprotected |
|
static |
This function only works for quadratic matrices.
|
static |
The operation cannot be finished since the matrix is singular.
|
static |
Block indices of two block objects are different.
|
static |
An error of a Trilinos function was encountered. Check the Trilinos documentation for details.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Attempt to perform an operation between two incompatible vector types.
|
static |
Exception
|
static |
Attempt to perform an operation between two incompatible vector types.
|
static |
Attempt to perform an operation not implemented on the device.
|
static |
Exception
|
static |
Exception
|
static |
Attempt to perform an operation between two incompatible vector types.
|
static |
A LAPACK function returned an error code.
|
static |
Exception thrown when a matrix is not in a suitable state for an operation. For instance, a LAPACK routine may have left the matrix in an unusable state, then vmult does not make sense anymore.
|
static |
Exception thrown when a matrix does not have suitable properties for an operation.
|
static |
This exception is thrown if a certain LAPACK function is not available because no LAPACK installation was detected during configuration.
|
static |
The block number computed from an index by using BlockIndices does not match the block coordinates stored in this object.
|
staticprivate |
PArpackExcInfoPdnaupds.
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
staticprivate |
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception.
|
static |
Exception
| PetscScalar SparseMatrix< number >::matrix_norm_square | ( | const Vector & | v | ) | const |
Return the square of the norm of the vector 
with respect to the norm induced by this matrix, i.e. 
. This is useful, e.g. in the finite element context, where the 
norm of a function equals the matrix norm with respect to the mass matrix of the vector representing the nodal values of the finite element function.
Obviously, the matrix needs to be quadratic for this operation.
The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.
Definition at line 677 of file petsc_parallel_sparse_matrix.cc.
| PetscScalar SparseMatrix< number >::matrix_scalar_product | ( | const Vector & | u, |
| const Vector & | v | ||
| ) | const |
Compute the matrix scalar product 
.
The implementation of this function is not as efficient as the one in the MatrixBase class used in deal.II (i.e. the original one, not the PETSc wrapper class) since PETSc doesn't support this operation and needs a temporary vector.
Definition at line 686 of file petsc_parallel_sparse_matrix.cc.
| IndexSet SparseMatrix< number >::locally_owned_domain_indices | ( | ) | const |
Return the partitioning of the domain space of this matrix, i.e., the partitioning of the vectors this matrix has to be multiplied with.
Definition at line 695 of file petsc_parallel_sparse_matrix.cc.
| IndexSet SparseMatrix< number >::locally_owned_range_indices | ( | ) | const |
Return the partitioning of the range space of this matrix, i.e., the partitioning of the vectors that result from matrix-vector products.
Definition at line 721 of file petsc_parallel_sparse_matrix.cc.
| void SparseMatrix< number >::mmult | ( | SparseMatrix & | C, |
| const SparseMatrix & | B, | ||
| const MPI::Vector & | V = MPI::Vector() |
||
| ) | const |
Perform the matrix-matrix multiplication 
, or, 
given a compatible vector 
.
This function calls MatrixBase::mmult() to do the actual work.
Definition at line 747 of file petsc_parallel_sparse_matrix.cc.
| void SparseMatrix< number >::Tmmult | ( | SparseMatrix & | C, |
| const SparseMatrix & | B, | ||
| const MPI::Vector & | V = MPI::Vector() |
||
| ) | const |
Perform the matrix-matrix multiplication with the transpose of this, i.e., 
, or, 
given a compatible vector .
This function calls MatrixBase::Tmmult() to do the actual work.
Definition at line 758 of file petsc_parallel_sparse_matrix.cc.
|
private |
Do the actual work for the respective reinit() function and the matching constructor, i.e. create a matrix. Getting rid of the previous matrix is left to the caller.
do_reinit is deprecated: please use the overload with a sparsity pattern argument instead. Definition at line 245 of file petsc_parallel_sparse_matrix.cc.
|
private |
Same as previous function.
do_reinit is deprecated: please use the overload with a sparsity pattern argument instead. Definition at line 281 of file petsc_parallel_sparse_matrix.cc.
|
private |
Same as previous functions.
Definition at line 495 of file petsc_parallel_sparse_matrix.cc.
|
private |
Same as previous functions.
Definition at line 352 of file petsc_parallel_sparse_matrix.cc.
| PreconditionBlock< MatrixType, inverse_type >::AdditionalData::AdditionalData | ( | const size_type | block_size, |
| const double | relaxation = 1., |
||
| const bool | invert_diagonal = true, |
||
| const bool | same_diagonal = false |
||
| ) |
Constructor. Block size must be given since there is no reasonable default parameter.
|
static |
For non-overlapping block preconditioners, the block size must divide the matrix size. If not, this exception gets thrown.
|
static |
Exception
| PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::Accessor | ( | const PreconditionBlockJacobi< MatrixType, inverse_type > * | matrix, |
| const size_type | row | ||
| ) |
Constructor. Since we use accessors only for read access, a const matrix pointer is sufficient.
| size_type PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::row | ( | ) | const |
Row number of the element represented by this object.
| size_type PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::column | ( | ) | const |
Column number of the element represented by this object.
| inverse_type PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::value | ( | ) | const |
Value of this matrix entry.
| PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::const_iterator | ( | const PreconditionBlockJacobi< MatrixType, inverse_type > * | matrix, |
| const size_type | row | ||
| ) |
Constructor.
| const_iterator& PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator++ | ( | ) |
Prefix increment.
| const Accessor& PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator* | ( | ) | const |
Dereferencing operator.
| const Accessor* PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator-> | ( | ) | const |
Dereferencing operator.
| bool PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator== | ( | const const_iterator & | ) | const |
Comparison. True, if both iterators point to the same matrix position.
| bool PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator!= | ( | const const_iterator & | ) | const |
Inverse of ==.
| bool PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator< | ( | const const_iterator & | ) | const |
Comparison operator. Result is true if either the first row number is smaller or if the row numbers are equal and the first index is smaller.
| template void PreconditionBlockJacobi< MatrixType, inverse_type >::vmult< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Execute block Jacobi preconditioning.
This function will automatically use the inverse matrices if they exist, if not then BlockJacobi will need much time inverting the diagonal block matrices in each preconditioning step.
| template void PreconditionBlockJacobi< MatrixType, inverse_type >::Tvmult< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Same as vmult, since Jacobi is symmetric.
| template void PreconditionBlockJacobi< MatrixType, inverse_type >::vmult_add< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Execute block Jacobi preconditioning, adding to dst.
This function will automatically use the inverse matrices if they exist, if not then BlockJacobi will need much time inverting the diagonal block matrices in each preconditioning step.
| template void PreconditionBlockJacobi< MatrixType, inverse_type >::Tvmult_add< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Same as vmult_add, since Jacobi is symmetric.
| void PreconditionBlockJacobi< MatrixType, inverse_type >::step | ( | Vector< number2 > & | dst, |
| const Vector< number2 > & | rhs | ||
| ) | const |
Perform one step of the Jacobi iteration.
| void PreconditionBlockJacobi< MatrixType, inverse_type >::Tstep | ( | Vector< number2 > & | dst, |
| const Vector< number2 > & | rhs | ||
| ) | const |
Perform one step of the Jacobi iteration.
| const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::begin | ( | ) | const |
Iterator starting at the first entry.
| const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::end | ( | ) | const |
Final iterator.
| const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::begin | ( | const size_type | r | ) | const |
Iterator starting at the first entry of row r.
| const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::end | ( | const size_type | r | ) | const |
Final iterator of row r.
|
private |
Actual implementation of the preconditioner.
Depending on adding, the result of preconditioning is added to the destination vector.
| PreconditionBlockSOR< MatrixType, inverse_type >::PreconditionBlockSOR | ( | ) |
Default constructor.
| template void PreconditionBlockSOR< MatrixType, inverse_type >::vmult< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Execute block SOR preconditioning.
This function will automatically use the inverse matrices if they exist, if not then BlockSOR will waste much time inverting the diagonal block matrices in each preconditioning step.
For matrices which are empty above the diagonal blocks BlockSOR is a direct solver.
| template void PreconditionBlockSOR< MatrixType, inverse_type >::vmult_add< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Execute block SOR preconditioning.
Warning: this function performs normal vmult without adding. The reason for its existence is that BlockMatrixArray requires the adding version by default. On the other hand, adding requires an additional auxiliary vector, which is not desirable.
| template void PreconditionBlockSOR< MatrixType, inverse_type >::Tvmult< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Backward application of vmult().
In the current implementation, this is not the transpose of vmult(). It is a transposed Gauss-Seidel algorithm applied to the whole matrix, but the diagonal blocks being inverted are not transposed. Therefore, it is the transposed, if the diagonal blocks are symmetric.
| template void PreconditionBlockSOR< MatrixType, inverse_type >::Tvmult_add< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Execute backward block SOR preconditioning.
Warning: this function performs normal vmult without adding. The reason for its existence is that BlockMatrixArray requires the adding version by default. On the other hand, adding requires an additional auxiliary vector, which is not desirable.
| void PreconditionBlockSOR< MatrixType, inverse_type >::step | ( | Vector< number2 > & | dst, |
| const Vector< number2 > & | rhs | ||
| ) | const |
Perform one step of the SOR iteration.
| void PreconditionBlockSOR< MatrixType, inverse_type >::Tstep | ( | Vector< number2 > & | dst, |
| const Vector< number2 > & | rhs | ||
| ) | const |
Perform one step of the transposed SOR iteration.
|
protected |
Constructor to be used by PreconditionBlockSSOR.
|
protected |
Implementation of the forward substitution loop called by vmult() and vmult_add().
If a permutation is set by set_permutation(), it will automatically be honored by this function.
The parameter adding does not have any function, yet.
|
protected |
Implementation of the backward substitution loop called by Tvmult() and Tvmult_add().
If a permutation is set by set_permutation(), it will automatically be honored by this function.
The parameter adding does not have any function, yet.
| PreconditionBlockSSOR< MatrixType, inverse_type >::PreconditionBlockSSOR | ( | ) |
Constructor.
| template void PreconditionBlockSSOR< MatrixType, inverse_type >::vmult< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Execute block SSOR preconditioning.
This function will automatically use the inverse matrices if they exist, if not then BlockSOR will waste much time inverting the diagonal block matrices in each preconditioning step.
| template void PreconditionBlockSSOR< MatrixType, inverse_type >::Tvmult< double > | ( | Vector< number2 > & | , |
| const Vector< number2 > & | |||
| ) | const |
Same as vmult()
| void PreconditionBlockSSOR< MatrixType, inverse_type >::step | ( | Vector< number2 > & | dst, |
| const Vector< number2 > & | rhs | ||
| ) | const |
Perform one step of the SOR iteration.
| void PreconditionBlockSSOR< MatrixType, inverse_type >::Tstep | ( | Vector< number2 > & | dst, |
| const Vector< number2 > & | rhs | ||
| ) | const |
Perform one step of the transposed SOR iteration.
|
static |
You are trying to access a diagonal block (not its inverse), but you decided not to store the diagonal blocks.
|
static |
You are accessing a diagonal block, assuming that it has a certain type. But, the method used for inverting the diagonal blocks does not use this type
|
static |
Exception.
|
static |
Exception. Standard exception.
|
static |
Exception. SLEPc error with error number.
|
static |
Exception. Convergence failure on the number of eigenvectors.
|
static |
This exception is thrown if a function operating on the vector of history data of a SolverControl object id called, but storage of history data was not enabled by enable_history_data().
|
static |
|
static |
Exception
|
protectedvirtual |
Implementation of the computation of the norm of the residual.
|
protectedvirtual |
Interface for derived class. This function gets the current iteration vector, the residual and the update vector in each step. It can be used for graphical output of the convergence history.
|
static |
Exception.
| SparseLUDecomposition< number >::AdditionalData::AdditionalData | ( | const double | strengthen_diagonal = 0, |
| const unsigned int | extra_off_diagonals = 0, |
||
| const bool | use_previous_sparsity = false, |
||
| const SparsityPattern * | use_this_sparsity = nullptr |
||
| ) |
Constructor. For the parameters' description, see below.
|
static |
Exception
|
protected |
Copies the passed SparseMatrix onto this object. This object's sparsity pattern remains unchanged.
|
protectedvirtual |
Performs the strengthening loop. For each row calculates the sum of absolute values of its elements, determines the strengthening factor (through get_strengthen_diagonal()) sf and multiplies the diagonal entry with sf+1.
|
protectedvirtual |
In the decomposition phase, computes a strengthening factor for the diagonal entry in row row with sum of absolute values of its elements rowsum.
strengthen_diagonal's value. This variable is set to a nonzero value in several of the derived classes.
|
protected |
Fills the prebuilt_lower_bound array.
|
static |
One of the UMFPack routines threw an error. The error code is included in the output and can be looked up in the UMFPack user manual. The name of the routine is included for reference.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
protected |
For some matrix storage formats, in particular for the PETSc distributed blockmatrices, set and add operations on individual elements can not be freely mixed. Rather, one has to synchronize operations when one wants to switch from setting elements to adding to elements. BlockMatrixBase automatically synchronizes the access by calling this helper function for each block. This function ensures that the matrix is in a state that allows adding elements; if it previously already was in this state, the function does nothing.
|
protected |
Same as prepare_add() but prepare the matrix for setting elements if the representation of elements in this class requires such an operation.
|
inline |
Standard constructor. Sets column to invalid.
Definition at line 927 of file sparse_matrix_ez.h.
|
inline |
Constructor. Fills column and value.
Definition at line 918 of file sparse_matrix_ez.h.
|
inline |
Constructor.
Definition at line 934 of file sparse_matrix_ez.h.
|
inline |
Constructor. Since we use accessors only for read access, a const matrix pointer is sufficient.
Definition at line 943 of file sparse_matrix_ez.h.
|
inline |
Row number of the element represented by this object.
Definition at line 955 of file sparse_matrix_ez.h.
|
inline |
Index in row of the element represented by this object.
Definition at line 971 of file sparse_matrix_ez.h.
|
inline |
Column number of the element represented by this object.
Definition at line 963 of file sparse_matrix_ez.h.
|
inline |
Value of this matrix entry.
Definition at line 980 of file sparse_matrix_ez.h.
|
inline |
Constructor.
Definition at line 987 of file sparse_matrix_ez.h.
|
inline |
Prefix increment. This always returns a valid entry or end().
Definition at line 1022 of file sparse_matrix_ez.h.
|
inline |
Dereferencing operator.
Definition at line 1049 of file sparse_matrix_ez.h.
|
inline |
Dereferencing operator.
Definition at line 1057 of file sparse_matrix_ez.h.
|
inline |
Comparison. True, if both iterators point to the same matrix position.
Definition at line 1066 of file sparse_matrix_ez.h.
|
inline |
Inverse of ==.
Definition at line 1076 of file sparse_matrix_ez.h.
|
inline |
Comparison operator. Result is true if either the first row number is smaller or if the row numbers are equal and the first index is smaller.
Definition at line 1085 of file sparse_matrix_ez.h.
|
static |
Exception for missing diagonal entry.
|
static |
Exception
|
static |
|
inlineprivate |
Find an entry and return a const pointer. Return a zero-pointer if the entry does not exist.
Definition at line 1134 of file sparse_matrix_ez.h.
|
inlineprivate |
Find an entry and return a writable pointer. Return a zero-pointer if the entry does not exist.
Definition at line 1112 of file sparse_matrix_ez.h.
|
inlineprivate |
Find an entry or generate it.
Definition at line 1143 of file sparse_matrix_ez.h.
|
private |
Version of vmult which only performs its actions on the region defined by [begin_row,end_row). This function is called by vmult in the case of enabled multithreading.
|
private |
Version of matrix_norm_square which only performs its actions on the region defined by [begin_row,end_row). This function is called by matrix_norm_square in the case of enabled multithreading.
|
private |
Version of matrix_scalar_product which only performs its actions on the region defined by [begin_row,end_row). This function is called by matrix_scalar_product in the case of enabled multithreading.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
private |
Compute the row-th "inner sum".
|
staticprotected |
|
static |
The operation is only allowed after the SparsityPattern has been set up and compress() was called.
|
static |
You tried to add an element to a row, but there was no space left.
|
static |
This operation changes the structure of the SparsityPattern and is not possible after compress() has been called.
| SparsityPattern::SparsityPattern | ( | ) |
Initialize the matrix empty, that is with no memory allocated. This is useful if you want such objects as member variables in other classes. You can make the structure usable by calling the reinit() function.
Definition at line 50 of file sparsity_pattern.cc.
| SparsityPattern::SparsityPattern | ( | const SparsityPattern & | s | ) |
Copy constructor. This constructor is only allowed to be called if the matrix structure to be copied is empty. This is so in order to prevent involuntary copies of objects for temporaries, which can use large amounts of computing time. However, copy constructors are needed if one wants to place a SparsityPattern in a container, e.g., to write such statements like v.push_back (SparsityPattern());, with v a std::vector of SparsityPattern objects.
Usually, it is sufficient to use the explicit keyword to disallow unwanted temporaries, but this does not work for std::vectors. Since copying a structure like this is not useful anyway because multiple matrices can use the same sparsity structure, copies are only allowed for empty objects, as described above.
Definition at line 59 of file sparsity_pattern.cc.
| SparsityPattern::SparsityPattern | ( | const size_type | m, |
| const size_type | n, | ||
| const unsigned int | max_per_row | ||
| ) |
Initialize a rectangular pattern of size m x n.
| [in] | m | The number of rows. |
| [in] | n | The number of columns. |
| [in] | max_per_row | Maximum number of nonzero entries per row. |
Definition at line 75 of file sparsity_pattern.cc.
| SparsityPattern::SparsityPattern | ( | const size_type | m, |
| const size_type | n, | ||
| const std::vector< unsigned int > & | row_lengths | ||
| ) |
Initialize a rectangular pattern of size m x n.
| [in] | m | The number of rows. |
| [in] | n | The number of columns. |
| [in] | row_lengths | Possible number of nonzero entries for each row. This vector must have one entry for each row. |
Definition at line 86 of file sparsity_pattern.cc.
| SparsityPattern::SparsityPattern | ( | const size_type | m, |
| const unsigned int | max_per_row | ||
| ) |
Initialize a quadratic pattern of dimension m with at most max_per_row nonzero entries per row.
This constructor automatically enables optimized storage of diagonal elements. To avoid this, use the constructor taking row and column numbers separately.
Definition at line 97 of file sparsity_pattern.cc.
| SparsityPattern::SparsityPattern | ( | const size_type | m, |
| const std::vector< unsigned int > & | row_lengths | ||
| ) |
Initialize a quadratic pattern of size m x m.
| [in] | m | The number of rows and columns. |
| [in] | row_lengths | Maximum number of nonzero entries for each row. This vector must have one entry for each row. |
Definition at line 106 of file sparsity_pattern.cc.
| SparsityPattern::SparsityPattern | ( | const SparsityPattern & | original, |
| const unsigned int | max_per_row, | ||
| const size_type | extra_off_diagonals | ||
| ) |
Make a copy with extra off-diagonals.
This constructs objects intended for the application of the ILU(n)-method or other incomplete decompositions. Therefore, additional to the original entry structure, space for extra_off_diagonals side- diagonals is provided on both sides of the main diagonal.
max_per_row is the maximum number of nonzero elements per row which this structure is to hold. It is assumed that this number is sufficiently large to accommodate both the elements in original as well as the new off-diagonal elements created by this constructor. You will usually want to give the same number as you gave for original plus the number of side diagonals times two. You may however give a larger value if you wish to add further nonzero entries for the decomposition based on other criteria than their being on side- diagonals.
This function requires that original refers to a quadratic matrix structure. It must be compressed. The matrix structure is not compressed after this function finishes.
Definition at line 115 of file sparsity_pattern.cc.
|
overridedefault |
Destructor.
| SparsityPattern & SparsityPattern::operator= | ( | const SparsityPattern & | s | ) |
Copy operator. For this the same holds as for the copy constructor: it is declared, defined and fine to be called, but the latter only for empty objects.
Definition at line 195 of file sparsity_pattern.cc.
|
overridevirtual |
Reallocate memory for a matrix of size m times n. The number of entries for each row is taken from the ArrayView row_lengths which has to give this number of each row 
.
Implements SparsityPatternBase.
Definition at line 226 of file sparsity_pattern.cc.
| void SparsityPattern::compress | ( | ) |
This function compresses the sparsity structure that this object represents. It does so by eliminating unused entries and sorting the remaining ones to allow faster access by usage of binary search algorithms. A special sorting scheme is used for the diagonal entry of quadratic matrices, which is always the first entry of each row.
The memory which is no more needed is released.
SparseMatrix objects require the SparsityPattern objects they are initialized with to be compressed, to reduce memory requirements.
Definition at line 335 of file sparsity_pattern.cc.
| void SparsityPattern::copy_from | ( | const size_type | n_rows, |
| const size_type | n_cols, | ||
| const ForwardIterator | begin, | ||
| const ForwardIterator | end | ||
| ) |
This function can be used as a replacement for reinit(), subsequent calls to add() and a final call to close() if you know exactly in advance the entries that will form the matrix sparsity pattern.
The first two parameters determine the size of the matrix. For the two last ones, note that a sparse matrix can be described by a sequence of rows, each of which is represented by a sequence of pairs of column indices and values. In the present context, the begin() and end() parameters designate iterators (of forward iterator type) into a container, one representing one row. The distance between begin() and end() should therefore be equal to n_rows(). These iterators may be iterators of std::vector, std::list, pointers into a C-style array, or any other iterator satisfying the requirements of a forward iterator. The objects pointed to by these iterators (i.e. what we get after applying operator* or operator-> to one of these iterators) must be a container itself that provides functions begin and end designating a range of iterators that describe the contents of one line. Dereferencing these inner iterators must either yield a pair of an unsigned integer as column index and a value of arbitrary type (such a type would be used if we wanted to describe a sparse matrix with one such object), or simply an unsigned integer (of we only wanted to describe a sparsity pattern). The function is able to determine itself whether an unsigned integer or a pair is what we get after dereferencing the inner iterators, through some template magic.
While the order of the outer iterators denotes the different rows of the matrix, the order of the inner iterator denoting the columns does not matter, as they are sorted internal to this function anyway.
Since that all sounds very complicated, consider the following example code, which may be used to fill a sparsity pattern:
Note that this example works since the iterators dereferenced yield containers with functions begin and end (namely std::vectors), and the inner iterators dereferenced yield unsigned integers as column indices. Note that we could have replaced each of the two std::vector occurrences by std::list, and the inner one by std::set as well.
Another example would be as follows, where we initialize a whole matrix, not only a sparsity pattern:
This example works because dereferencing iterators of the inner type yields a pair of unsigned integers and a value, the first of which we take as column index. As previously, the outer std::vector could be replaced by std::list, and the inner std::map<unsigned int,double> could be replaced by std::vector<std::pair<unsigned int,double> >, or a list or set of such pairs, as they all return iterators that point to such pairs.
| void SparsityPattern::copy_from | ( | const DynamicSparsityPattern & | dsp | ) |
Copy data from a DynamicSparsityPattern. Previous content of this object is lost, and the sparsity pattern is in compressed mode afterwards.
Definition at line 489 of file sparsity_pattern.cc.
| void SparsityPattern::copy_from | ( | const SparsityPattern & | sp | ) |
Copy data from a SparsityPattern. Previous content of this object is lost, and the sparsity pattern is in compressed mode afterwards.
Definition at line 441 of file sparsity_pattern.cc.
| void SparsityPattern::copy_from | ( | const FullMatrix< number > & | matrix | ) |
Take a full matrix and use its nonzero entries to generate a sparse matrix entry pattern for this object.
Previous content of this object is lost, and the sparsity pattern is in compressed mode afterwards.
Definition at line 550 of file sparsity_pattern.cc.
| void SparsityPattern::add_entries | ( | const size_type | row, |
| ForwardIterator | begin, | ||
| ForwardIterator | end, | ||
| const bool | indices_are_sorted = false |
||
| ) |
Add several nonzero entries to the specified matrix row. This function may only be called for non-compressed sparsity patterns.
If some of the entries already exist, nothing bad happens.
Definition at line 732 of file sparsity_pattern.cc.
| bool SparsityPattern::operator== | ( | const SparsityPattern & | ) | const |
Test for equality of two SparsityPatterns.
| bool SparsityPattern::stores_only_added_elements | ( | ) | const |
Return whether this object stores only those entries that have been added explicitly, or if the sparsity pattern contains elements that have been added through other means (implicitly) while building it. For the current class, the result is false if and only if it is square because it then unconditionally stores the diagonal entries whether they have been added explicitly or not.
This function mainly serves the purpose of describing the current class in cases where several kinds of sparsity patterns can be passed as template arguments.
| std::size_t SparsityPattern::memory_consumption | ( | ) | const |
Determine an estimate for the memory consumption (in bytes) of this object. See MemoryConsumption.
Definition at line 1039 of file sparsity_pattern.cc.
| SparsityPattern::size_type SparsityPattern::operator() | ( | const size_type | i, |
| const size_type | j | ||
| ) | const |
Return the index of the matrix element with row number i and column number j. If the matrix element is not a nonzero one, return SparsityPattern::invalid_entry.
This function is usually called by the SparseMatrix::operator()(). It may only be called for compressed sparsity patterns, since in this case searching whether the entry exists can be done quite fast with a binary sort algorithm because the column numbers are sorted.
If m is the number of entries in row, then the complexity of this function is log(m) if the sparsity pattern is compressed.
i to find whether index j exists. Thus, it is more expensive than necessary in cases where you want to loop over all of the nonzero elements of this sparsity pattern (or of a sparse matrix associated with it) or of a single row. In such cases, it is more efficient to use iterators over the elements of the sparsity pattern or of the sparse matrix. Definition at line 665 of file sparsity_pattern.cc.
| void SparsityPattern::block_write | ( | std::ostream & | out | ) | const |
Write the data of this object en bloc to a file. This is done in a binary mode, so the output is neither readable by humans nor (probably) by other computers using a different operating system or number format.
The purpose of this function is that you can swap out matrices and sparsity pattern if you are short of memory, want to communicate between different programs, or allow objects to be persistent across different runs of the program.
Definition at line 968 of file sparsity_pattern.cc.
| void SparsityPattern::block_read | ( | std::istream & | in | ) |
Read data that has previously been written by block_write() from a file. This is done using the inverse operations to the above function, so it is reasonably fast because the bitstream is not interpreted except for a few numbers up front.
The object is resized on this operation, and all previous contents are lost.
A primitive form of error checking is performed which will recognize the bluntest attempts to interpret some data as a vector stored bitwise to a file, but not more.
Definition at line 992 of file sparsity_pattern.cc.
| void SparsityPattern::save | ( | Archive & | ar, |
| const unsigned int | version | ||
| ) | const |
Write the data of this object to a stream for the purpose of serialization
| void SparsityPattern::load | ( | Archive & | ar, |
| const unsigned int | version | ||
| ) |
Read the data of this object from a stream for the purpose of serialization
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception.
|
static |
Exception.
|
static |
Exception.
|
static |
Exception.
|
private |
Internal function that actually reloads the vector. Called from reload and alert.
The parameter specifies whether the function shall set data_is_preloaded or not. The calling functions can't sometimes do this themselves, since they call this function detached, so this function has to signal success itself if this is required.
|
static |
Exception
|
static |
Exception
|
static |
The vectors have different partitioning, i.e. their IndexSet objects don't represent the same indices.
|
static |
Attempt to perform an operation between two incompatible vector types.
|
static |
Exception thrown by an error in Trilinos.
|
static |
Exception
|
static |
Exception
|
static |
Exception.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Vector was not allocated from this memory pool.
|
default |
Default constructor. This constructor corresponds to a nullptr object that does not own a vector. It can, however, later be assigned another Pointer object via move assignment in which case it will steal the vector owned by the other object (as std::unique_ptr does).
|
defaultnoexcept |
Move constructor: this creates a new Pointer by stealing the internal data owned by p.
|
defaultnoexcept |
Move operator: this releases the vector owned by the current Pointer and then steals the internal data owned by p.
| VectorMemory< VectorType >::Pointer::Pointer | ( | VectorMemory< VectorType > & | mem | ) |
Constructor. This constructor automatically allocates a vector from the given vector memory object mem.
|
default |
Destructor, automatically releasing the vector from the memory #pool.
|
overridevirtual |
Return a pointer to a new vector. The number of elements or their subdivision into blocks (if applicable) is unspecified and users of this function should reset vectors to their proper size. The same holds for the contents of vectors: they are unspecified. In other words, the place that calls this function will need to resize or reinitialize it appropriately.
For the present class, calling this function will allocate a new vector on the heap and returning a pointer to it. Later calling free() then returns the memory to the global heap managed by the operating system.
new and delete explicitly in code invites bugs where memory is leaked (either because the corresponding delete is forgotten altogether, or because of exception safety issues), using the alloc() and free() functions explicitly invites writing code that accidentally leaks memory. You should consider using the VectorMemory::Pointer class instead, which provides the same kind of service that std::unique provides for arbitrary memory allocated on the heap. Implements VectorMemory< VectorType >.
|
overridevirtual |
Return a vector and indicate that it is not going to be used any further by the instance that called alloc() to get a pointer to it.
For the present class, this means that the vector is returned to the global heap.
new and delete explicitly in code invites bugs where memory is leaked (either because the corresponding delete is forgotten altogether, or because of exception safety issues), using the alloc() and free() functions explicitly invites writing code that accidentally leaks memory. You should consider using the VectorMemory::Pointer class instead, which provides the same kind of service that std::unique provides for arbitrary memory allocated on the heap. Implements VectorMemory< VectorType >.
| GrowingVectorMemory< VectorType >::GrowingVectorMemory | ( | const size_type | initial_size = 0, |
| const bool | log_statistics = false |
||
| ) |
Constructor. The argument allows to preallocate a certain number of vectors. The default is not to do this.
|
overridevirtual |
Destructor. The destructor also checks that all vectors that have been allocated through the current object have all been released again. However, as discussed in the class documentation, this does not imply that their memory is returned to the operating system.
|
overridevirtual |
Return a pointer to a new vector. The number of elements or their subdivision into blocks (if applicable) is unspecified and users of this function should reset vectors to their proper size. The same holds for the contents of vectors: they are unspecified. In other words, the place that calls this function will need to resize or reinitialize it appropriately.
new and delete explicitly in code invites bugs where memory is leaked (either because the corresponding delete is forgotten altogether, or because of exception safety issues), using the alloc() and free() functions explicitly invites writing code that accidentally leaks memory. You should consider using the VectorMemory::Pointer class instead, which provides the same kind of service that std::unique provides for arbitrary memory allocated on the heap. Implements VectorMemory< VectorType >.
|
overridevirtual |
Return a vector and indicate that it is not going to be used any further by the instance that called alloc() to get a pointer to it.
For the present class, this means retaining the vector for later reuse by the alloc() method.
new and delete explicitly in code invites bugs where memory is leaked (either because the corresponding delete is forgotten altogether, or because of exception safety issues), using the alloc() and free() functions explicitly invites writing code that accidentally leaks memory. You should consider using the VectorMemory::Pointer class instead, which provides the same kind of service that std::unique provides for arbitrary memory allocated on the heap. Implements VectorMemory< VectorType >.
|
static |
Release all vectors that are not currently in use.
|
virtual |
Memory consumed by this class and all currently allocated vectors.
| GrowingVectorMemory< VectorType >::Pool::Pool | ( | ) |
Standard constructor creating an empty pool
| GrowingVectorMemory< VectorType >::Pool::~Pool | ( | ) |
Destructor.
| void GrowingVectorMemory< VectorType >::Pool::initialize | ( | const size_type | size | ) |
Create data vector; does nothing after first initialization
|
staticprivate |
Return an array of allocated vectors.
|
static |
This error is thrown if one of the virtual functions cell(), boundary(), or face() is called without being overloaded in a derived class. Consider setting use_cell, use_boundary, and use_face to false, respectively.
|
static |
Finite element does not provide prolongation matrices.
|
static |
You have to call build_matrices() before using this object.
|
staticprotected |
Call build_matrices() function first.
|
staticprotected |
Call build_matrices() function first.
|
static |
Finite element does not provide prolongation matrices.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
|
static |
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception.
|
static |
Exception.
|
static |
Exception.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception thrown when the point specified as argument does not lie between tolerance from the given TopoDS_Shape.
|
static |
Exception thrown when the point specified as argument cannot be projected to the manifold.
|
static |
Thrown when internal OpenCASCADE utilities fail to return the OK status.
|
static |
Trying to make curve operations on a degenerate edge.
|
static |
Trying to make operations on the wrong type of shapes.
|
static |
Input matrix has incorrect number of rows.
|
static |
Input matrix has incorrect number of rows.
|
static |
Input matrix has incorrect number of columns.
|
static |
Input matrix has incorrect number of columns.
|
static |
Handle KINSOL exceptions.
|
staticprivate |
Throw an exception when a function with the given name is not implemented.
|
static |
|
static |
|
static |
|
static |
|
static |
|
static |
|
static |
Exception
|
static |
Exception
|
static |
A cell was entered which has negative measure. In most cases, this is due to a wrong order of the vertices of the cell.
|
static |
A cell is created with a vertex number exceeding the vertex array.
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
|
static |
Exception
| internal::TableEntry::TableEntry | ( | const T & | t | ) |
Constructor. Initialize this table element with the value t.
Definition at line 772 of file table_handler.h.
| T internal::TableEntry::get | ( | ) | const |
Return the value stored by this object. The template type T must be one of int,unsigned int,double,std::string and it must match the data type of the object originally stored in this TableEntry object.
Definition at line 779 of file table_handler.h.
| void internal::TableEntry::save | ( | Archive & | ar, |
| const unsigned int | version | ||
| ) | const |
Write the data of this object to a stream for the purpose of serialization.
Definition at line 804 of file table_handler.h.
| void internal::TableEntry::load | ( | Archive & | ar, |
| const unsigned int | version | ||
| ) |
Read the data of this object from a stream for the purpose of serialization.
Definition at line 843 of file table_handler.h.
| void BlockSparseMatrix< number >::print_formatted | ( | std::ostream & | out, |
| const unsigned int | precision = 3, |
||
| const bool | scientific = true, |
||
| const unsigned int | width = 0, |
||
| const char * | zero_string = " ", |
||
| const double | denominator = 1. |
||
| ) | const |
Print the matrix in the usual format, i.e. as a matrix and not as a list of nonzero elements. For better readability, elements not in the matrix are displayed as empty space, while matrix elements which are explicitly set to zero are displayed as such.
The parameters allow for a flexible setting of the output format: precision and scientific are used to determine the number format, where scientific = false means fixed point notation. A zero entry for width makes the function compute a width, but it may be changed to a positive value, if output is crude.
Additionally, a character for an empty value may be specified.
Finally, the whole matrix can be multiplied with a common denominator to produce more readable output, even integers.
| void ChunkSparseMatrix< number >::print | ( | std::ostream & | out | ) | const |
Print the matrix to the given stream, using the format (line,col) value, i.e. one nonzero entry of the matrix per line.
| void ChunkSparseMatrix< number >::print_formatted | ( | std::ostream & | out, |
| const unsigned int | precision = 3, |
||
| const bool | scientific = true, |
||
| const unsigned int | width = 0, |
||
| const char * | zero_string = " ", |
||
| const double | denominator = 1. |
||
| ) | const |
Print the matrix in the usual format, i.e. as a matrix and not as a list of nonzero elements. For better readability, elements not in the matrix are displayed as empty space, while matrix elements which are explicitly set to zero are displayed as such.
The parameters allow for a flexible setting of the output format: precision and scientific are used to determine the number format, where scientific = false means fixed point notation. A zero entry for width makes the function compute a width, but it may be changed to a positive value, if output is crude.
Additionally, a character for an empty value may be specified.
Finally, the whole matrix can be multiplied with a common denominator to produce more readable output, even integers.
| void ChunkSparseMatrix< number >::print_pattern | ( | std::ostream & | out, |
| const double | threshold = 0. |
||
| ) | const |
Print the actual pattern of the matrix. For each entry with an absolute value larger than threshold, a '*' is printed, a ':' for every value smaller and a '.' for every entry not allocated.
| void ChunkSparseMatrix< number >::block_write | ( | std::ostream & | out | ) | const |
Write the data of this object en bloc to a file. This is done in a binary mode, so the output is neither readable by humans nor (probably) by other computers using a different operating system or number format.
The purpose of this function is that you can swap out matrices and sparsity pattern if you are short of memory, want to communicate between different programs, or allow objects to be persistent across different runs of the program.
| void ChunkSparseMatrix< number >::block_read | ( | std::istream & | in | ) |
Read data that has previously been written by block_write() from a file. This is done using the inverse operations to the above function, so it is reasonably fast because the bitstream is not interpreted except for a few numbers up front.
The object is resized on this operation, and all previous contents are lost. Note, however, that no checks are performed whether new data and the underlying ChunkSparsityPattern object fit together. It is your responsibility to make sure that the sparsity pattern and the data to be read match.
A primitive form of error checking is performed which will recognize the bluntest attempts to interpret some data as a matrix stored bitwise to a file that wasn't actually created that way, but not more.
| void SparseMatrix< number >::print | ( | StreamType & | out, |
| const bool | across = false, |
||
| const bool | diagonal_first = true |
||
| ) | const |
Print the matrix to the given stream, using the format (row,column) value, i.e. one nonzero entry of the matrix per line. If across is true, print all entries on a single line, using the format row,column:value.
If the argument diagonal_first is true, diagonal elements of quadratic matrices are printed first in their row, corresponding to the internal storage scheme. If it is false, the elements in a row are written in ascending column order.
| void SparseMatrix< number >::print_formatted | ( | std::ostream & | out, |
| const unsigned int | precision = 3, |
||
| const bool | scientific = true, |
||
| const unsigned int | width = 0, |
||
| const char * | zero_string = " ", |
||
| const double | denominator = 1. |
||
| ) | const |
Print the matrix in the usual format, i.e. as a matrix and not as a list of nonzero elements. For better readability, elements not in the matrix are displayed as empty space, while matrix elements which are explicitly set to zero are displayed as such.
The parameters allow for a flexible setting of the output format: precision and scientific are used to determine the number format, where scientific = false means fixed point notation. A zero entry for width makes the function compute a width, but it may be changed to a positive value, if output is crude.
Additionally, a character for an empty value may be specified.
Finally, the whole matrix can be multiplied with a common denominator to produce more readable output, even integers.
| void SparseMatrix< number >::print_pattern | ( | std::ostream & | out, |
| const double | threshold = 0. |
||
| ) | const |
Print the actual pattern of the matrix. For each entry with an absolute value larger than threshold, a '*' is printed, a ':' for every value smaller and a '.' for every entry not allocated.
| void SparseMatrix< number >::block_write | ( | std::ostream & | out | ) | const |
Write the data of this object en bloc to a file. This is done in a binary mode, so the output is neither readable by humans nor (probably) by other computers using a different operating system of number format.
The purpose of this function is that you can swap out matrices and sparsity pattern if you are short of memory, want to communicate between different programs, or allow objects to be persistent across different runs of the program.
| void SparseMatrix< number >::block_read | ( | std::istream & | in | ) |
Read data that has previously been written by block_write() from a file. This is done using the inverse operations to the above function, so it is reasonably fast because the bitstream is not interpreted except for a few numbers up front.
The object is resized on this operation, and all previous contents are lost. Note, however, that no checks are performed whether new data and the underlying SparsityPattern object fit together. It is your responsibility to make sure that the sparsity pattern and the data to be read match.
A primitive form of error checking is performed which will recognize the bluntest attempts to interpret some data as a matrix stored bitwise to a file that wasn't actually created that way, but not more.
| void SparseMatrixEZ< number >::print | ( | std::ostream & | out | ) | const |
Print the matrix to the given stream, using the format (line,col) value, i.e. one nonzero entry of the matrix per line.
| void SparseMatrixEZ< number >::print_formatted | ( | std::ostream & | out, |
| const unsigned int | precision = 3, |
||
| const bool | scientific = true, |
||
| const unsigned int | width = 0, |
||
| const char * | zero_string = " ", |
||
| const double | denominator = 1. |
||
| ) | const |
Print the matrix in the usual format, i.e. as a matrix and not as a list of nonzero elements. For better readability, elements not in the matrix are displayed as empty space, while matrix elements which are explicitly set to zero are displayed as such.
The parameters allow for a flexible setting of the output format: precision and scientific are used to determine the number format, where scientific = false means fixed point notation. A zero entry for width makes the function compute a width, but it may be changed to a positive value, if output is crude.
Additionally, a character for an empty value may be specified.
Finally, the whole matrix can be multiplied with a common denominator to produce more readable output, even integers.
This function may produce large amounts of output if applied to a large matrix!
| void SparseMatrixEZ< number >::block_write | ( | std::ostream & | out | ) | const |
Write the data of this object in binary mode to a file.
Note that this binary format is platform dependent.
| void SparseMatrixEZ< number >::block_read | ( | std::istream & | in | ) |
Read data that has previously been written by block_write.
The object is resized on this operation, and all previous contents are lost.
A primitive form of error checking is performed which will recognize the bluntest attempts to interpret some data as a vector stored bitwise to a file, but not more.
| void SparsityPattern::write_ascii | ( | ) |
Abstract Trilinos object that helps view in ASCII other Trilinos objects. Currently this function is not implemented. TODO: Not implemented.
Definition at line 1117 of file trilinos_sparsity_pattern.cc.
| void SparsityPattern::print | ( | std::ostream & | out, |
| const bool | write_extended_trilinos_info = false |
||
| ) | const |
Print (the locally owned part of) the sparsity pattern to the given stream, using the format (line,col). The optional flag outputs the sparsity pattern in Trilinos style, where even the according processor number is printed to the stream, as well as a summary before actually writing the entries.
Definition at line 1128 of file trilinos_sparsity_pattern.cc.
| void SparsityPattern::print_gnuplot | ( | std::ostream & | out | ) | const |
Print the sparsity of the matrix in a format that gnuplot understands and which can be used to plot the sparsity pattern in a graphical way. The format consists of pairs i j of nonzero elements, each representing one entry of this matrix, one per line of the output file. Indices are counted from zero on, as usual. Since sparsity patterns are printed in the same way as matrices are displayed, we print the negative of the column index, which means that the (0,0) element is in the top left rather than in the bottom left corner.
Print the sparsity pattern in gnuplot by setting the data style to dots or points and use the plot command.
Definition at line 1155 of file trilinos_sparsity_pattern.cc.
| void SparsityPatternBase::print | ( | std::ostream & | out | ) | const |
Print the sparsity of the matrix. The output consists of one line per row of the format [i,j1,j2,j3,...]. i is the row number and jn are the allocated columns in this row.
Definition at line 875 of file sparsity_pattern.cc.
| void SparsityPatternBase::print_gnuplot | ( | std::ostream & | out | ) | const |
Print the sparsity of the matrix in a format that gnuplot understands and which can be used to plot the sparsity pattern in a graphical way. The format consists of pairs i j of nonzero elements, each representing one entry of this matrix, one per line of the output file. Indices are counted from zero on, as usual. Since sparsity patterns are printed in the same way as matrices are displayed, we print the negative of the column index, which means that the (0,0) element is in the top left rather than in the bottom left corner.
Print the sparsity pattern in gnuplot by setting the data style to dots or points and use the plot command.
Definition at line 896 of file sparsity_pattern.cc.
| void SparsityPatternBase::print_svg | ( | std::ostream & | out | ) | const |
Prints the sparsity of the matrix in a .svg file which can be opened in a web browser. The .svg file contains squares which correspond to the entries in the matrix. An entry in the matrix which contains a non-zero value corresponds with a red square while a zero-valued entry in the matrix correspond with a white square.
Definition at line 914 of file sparsity_pattern.cc.
| void SparsityPatternBase::save | ( | Archive & | ar, |
| const unsigned int | version | ||
| ) | const |
Write the data of this object to a stream for the purpose of serialization
| void SparsityPatternBase::load | ( | Archive & | ar, |
| const unsigned int | version | ||
| ) |
Read the data of this object from a stream for the purpose of serialization
|
inline |
Double contract two tensors of rank 2, thus computing the Frobenius inner product sumi,j src1[i][j]*src2[i][j].
Definition at line 228 of file tensor_deprecated.h.
|
inline |
Contract the last two indices of src1 with the two indices src2, creating a rank-2 tensor. This is the matrix-vector product analog operation between tensors of rank 4 and rank 2.
Definition at line 239 of file tensor_deprecated.h.
|
inline |
Contract a tensor of rank 2 with a tensor of rank 2. The contraction is performed over index index1 of the first tensor, and index2 of the second tensor. Note that the number of the index is counted from 1 on, not from zero as usual.
Definition at line 252 of file tensor_deprecated.h.
|
inline |
Contract a tensor of rank 3 with a tensor of rank 1. The contraction is performed over index index1 of the first tensor. Note that the number of the index is counted from 1 on, not from zero as usual.
Definition at line 309 of file tensor_deprecated.h.
|
inline |
Contract a tensor of rank 3 with a tensor of rank 2. The contraction is performed over index index1 of the first tensor, and index2 of the second tensor. Note that the number of the index is counted from 1 on, not from zero as usual.
Definition at line 345 of file tensor_deprecated.h.
|
inline |
Single contraction for tensors: contract the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2.
Definition at line 427 of file tensor_deprecated.h.
|
inline |
Contract a tensor of rank 1 with a tensor of rank 1 and return the result.
Definition at line 439 of file tensor_deprecated.h.
|
inline |
The cross product of one vector in 2d. This is just a rotation by 90 degrees.
Definition at line 451 of file tensor_deprecated.h.
|
inline |
The cross product of 2 vectors in 3d.
Definition at line 458 of file tensor_deprecated.h.
|
inline |
Form the outer product of two tensors.
Definition at line 467 of file tensor_deprecated.h.
|
inline |
Multiply a Tensor<1,dim,Number> with a Number.
Definition at line 475 of file tensor_deprecated.h.
|
inline |
Multiply a Tensor<1,dim,Number> with a Number.
Definition at line 484 of file tensor_deprecated.h.
|
inline |
Definition at line 494 of file tensor_deprecated.h.
|
inline |
Definition at line 501 of file tensor_deprecated.h.
|
static |
Make the spacedim template parameter available.
Definition at line 251 of file data_out_base.h.
| Point<spacedim> DataOutBase::Patch< dim, spacedim >::vertices[GeometryInfo< dim >::vertices_per_cell] |
Corner points of a patch. Interior points are computed by a multilinear transformation of the unit cell to the cell specified by these corner points, if points_are_available==false.
On the other hand, if points_are_available==true, then the coordinates of the points at which output is to be generated is attached in additional rows to the data table.
The order of points is the same as for cells in the triangulation.
Definition at line 265 of file data_out_base.h.
| unsigned int DataOutBase::Patch< dim, spacedim >::neighbors[dim > 0 ? GeometryInfo< dim >::faces_per_cell :1] |
Patch indices of neighbors of the current patch. This is made available for the OpenDX format that requires neighbor information for advanced output. For dim==0 we still allow one neighbor, to avoid compiler warnings about zero-sized arrays.
Definition at line 273 of file data_out_base.h.
| unsigned int DataOutBase::Patch< dim, spacedim >::patch_index |
Number of this patch. Since we are not sure patches are always handled in the same order, we better store this.
Definition at line 279 of file data_out_base.h.
| unsigned int DataOutBase::Patch< dim, spacedim >::n_subdivisions |
Number of subdivisions with which this patch is to be written. 1 means no subdivision, 2 means bisection, 3 trisection, etc.
Definition at line 286 of file data_out_base.h.
| Table<2, float> DataOutBase::Patch< dim, spacedim >::data |
Data vectors. The format is as follows: data(i,.) denotes the data belonging to the ith data vector. data.n_cols() therefore equals the number of output points; this number is (subdivisions+1)^{dim}. data.n_rows() equals the number of data vectors. For the current purpose, a data vector equals one scalar, even if multiple scalars may later be interpreted as vectors.
Within each column, data(.,j) are the data values at the output point j, where j denotes the usual lexicographic ordering in deal.II. This is also the order of points as provided by the QIterated class when used with the QTrapez class as subquadrature.
Since the number of data vectors is usually the same for all patches to be printed, data.size() should yield the same value for all patches provided. The exception are patches for which points_are_available are set, where the actual coordinates of the point are appended to the 'data' field, see the documentation of the points_are_available flag.
Definition at line 309 of file data_out_base.h.
| bool DataOutBase::Patch< dim, spacedim >::points_are_available |
A flag indicating whether the coordinates of the interior patch points (assuming that the patch is supposed to be subdivided further) are appended to the data table (true) or not (false). The latter is the default and in this case the locations of the points interior to this patch are computed by (bi-, tri-)linear interpolation from the vertices of the patch.
This option exists since patch points may be evaluated using a Mapping (rather than by a linear interpolation) and therefore have to be stored in the Patch structure.
Definition at line 323 of file data_out_base.h.
|
static |
Value to be used if this patch has no neighbor on one side.
Definition at line 356 of file data_out_base.h.
|
static |
Make the spacedim template parameter available.
Definition at line 401 of file data_out_base.h.
| Point<spacedim> DataOutBase::Patch< 0, spacedim >::vertices[1] |
Corner points of a patch. For the current class of zero-dimensional patches, there is of course only a single vertex.
If points_are_available==true, then the coordinates of the point at which output is to be generated is attached as an additional row to the data table.
Definition at line 411 of file data_out_base.h.
|
static |
An unused, static variable that exists only to allow access from general code in a generic fashion.
Definition at line 417 of file data_out_base.h.
| unsigned int DataOutBase::Patch< 0, spacedim >::patch_index |
Number of this patch. Since we are not sure patches are always handled in the same order, we better store this.
Definition at line 423 of file data_out_base.h.
|
static |
Number of subdivisions with which this patch is to be written. 1 means no subdivision, 2 means bisection, 3 trisection, etc.
Since subdivision makes no sense for zero-dimensional patches, this variable is not used but exists only to allow access from general code in a generic fashion.
Definition at line 434 of file data_out_base.h.
| Table<2, float> DataOutBase::Patch< 0, spacedim >::data |
Data vectors. The format is as follows: data(i,.) denotes the data belonging to the ith data vector. data.n_cols() therefore equals the number of output points; this number is of course one for the current class, given that we produce output on points. data.n_rows() equals the number of data vectors. For the current purpose, a data vector equals one scalar, even if multiple scalars may later be interpreted as vectors.
Within each column, data(.,j) are the data values at the output point j; for the current class, j can only be zero.
Since the number of data vectors is usually the same for all patches to be printed, data.size() should yield the same value for all patches provided. The exception are patches for which points_are_available are set, where the actual coordinates of the point are appended to the 'data' field, see the documentation of the points_are_available flag.
Definition at line 456 of file data_out_base.h.
| bool DataOutBase::Patch< 0, spacedim >::points_are_available |
A flag indicating whether the coordinates of the interior patch points (assuming that the patch is supposed to be subdivided further) are appended to the data table (true) or not (false). The latter is the default and in this case the locations of the points interior to this patch are computed by (bi-, tri-)linear interpolation from the vertices of the patch.
This option exists since patch points may be evaluated using a Mapping (rather than by a linear interpolation) and therefore have to be stored in the Patch structure.
Definition at line 470 of file data_out_base.h.
|
static |
Value to be used if this patch has no neighbor on one side.
Definition at line 502 of file data_out_base.h.
| bool DataOutBase::DXFlags::write_neighbors |
Write neighbor information. This information is necessary for instance, if OpenDX is supposed to compute integral curves (streamlines). If it is not present, streamlines end at cell boundaries.
Definition at line 600 of file data_out_base.h.
| bool DataOutBase::DXFlags::int_binary |
Write integer values of the Triangulation in binary format.
Definition at line 604 of file data_out_base.h.
| bool DataOutBase::DXFlags::coordinates_binary |
Write coordinate vectors in binary format.
Definition at line 608 of file data_out_base.h.
| bool DataOutBase::DXFlags::data_binary |
Write data vectors in binary format.
Definition at line 613 of file data_out_base.h.
| bool DataOutBase::DXFlags::data_double |
Write binary coordinate vectors as double (64 bit) numbers instead of float (32 bit).
Definition at line 619 of file data_out_base.h.
| bool DataOutBase::UcdFlags::write_preamble |
Write a comment at the beginning of the file stating the date of creation and some other data. While this is supported by the UCD format and AVS, some other programs get confused by this, so the default is to not write a preamble. However, a preamble can be written using this flag.
Default: false.
Definition at line 662 of file data_out_base.h.
| std::vector<std::string> DataOutBase::GnuplotFlags::space_dimension_labels |
Labels to use in each spatial dimension. These default to "x", "y", and "z". Labels are printed to the Gnuplot file surrounded by angle brackets: For example, if the space dimension is 2 and the labels are "x" and "t", then the relevant line will start with
* # <x> <t> *
Any extra labels will be ignored.
If you specify these labels yourself then there should be at least spacedim labels, where spacedim is the spatial dimension of the output data.
Definition at line 719 of file data_out_base.h.
| bool DataOutBase::PovrayFlags::smooth |
Normal vector interpolation, if set to true
default = false
Definition at line 750 of file data_out_base.h.
| bool DataOutBase::PovrayFlags::bicubic_patch |
Use bicubic patches (b-splines) instead of triangles.
default = false
Definition at line 757 of file data_out_base.h.
| bool DataOutBase::PovrayFlags::external_data |
include external "data.inc" with camera, light and texture definition for the scene.
default = false
Definition at line 765 of file data_out_base.h.
| unsigned int DataOutBase::EpsFlags::height_vector |
This denotes the number of the data vector which shall be used for generating the height information. By default, the first data vector is taken, i.e. height_vector==0, if there is any data vector. If there is no data vector, no height information is generated.
Definition at line 806 of file data_out_base.h.
| unsigned int DataOutBase::EpsFlags::color_vector |
Number of the vector which is to be taken to colorize cells. The same applies as for height_vector.
Definition at line 812 of file data_out_base.h.
| SizeType DataOutBase::EpsFlags::size_type |
See above. Default is width.
Definition at line 830 of file data_out_base.h.
| unsigned int DataOutBase::EpsFlags::size |
Width or height of the output as given in postscript units This usually is given by the strange unit 1/72 inch. Whether this is height or width is specified by the flag size_type.
Default is 300, which represents a size of roughly 10 cm.
Definition at line 839 of file data_out_base.h.
| double DataOutBase::EpsFlags::line_width |
Width of a line in postscript units. Default is 0.5.
Definition at line 844 of file data_out_base.h.
| double DataOutBase::EpsFlags::azimut_angle |
Angle of the line origin-viewer against the z-axis in degrees.
Default is the Gnuplot-default of 60.
Definition at line 851 of file data_out_base.h.
| double DataOutBase::EpsFlags::turn_angle |
Angle by which the viewers position projected onto the x-y-plane is rotated around the z-axis, in positive sense when viewed from above. The unit are degrees, and zero equals a position above or below the negative y-axis.
Default is the Gnuplot-default of 30. An example of a Gnuplot-default of 0 is the following:
* * 3________7 * / /| * / / | * 2/______6/ | * | | | | * O--> | 0___|___4 * | / | / * | / | / * 1|/______5/ * *
Definition at line 876 of file data_out_base.h.
| double DataOutBase::EpsFlags::z_scaling |
Factor by which the z-axis is to be stretched as compared to the x- and y-axes. This is to compensate for the different sizes that coordinate and solution values may have and to prevent that the plot looks to much out-of-place (no elevation at all if solution values are much smaller than coordinate values, or the common "extremely mountainous area" in the opposite case.
Default is 1.0.
Definition at line 888 of file data_out_base.h.
| bool DataOutBase::EpsFlags::draw_mesh |
Flag the determines whether the lines bounding the cells (or the parts of each patch) are to be plotted.
Default: true.
Definition at line 896 of file data_out_base.h.
| bool DataOutBase::EpsFlags::draw_cells |
Flag whether to fill the regions between the lines bounding the cells or not. If not, no hidden line removal is performed, which in this crude implementation is done through writing the cells in a back-to- front order, thereby hiding the cells in the background by cells in the foreground.
If this flag is false and draw_mesh is false as well, nothing will be printed.
If this flag is true, then the cells will be drawn either colored by one of the data sets (if shade_cells is true), or pure white (if shade_cells is false or if there are no data sets).
Default is true.
Definition at line 914 of file data_out_base.h.
| bool DataOutBase::EpsFlags::shade_cells |
Flag to determine whether the cells shall be colorized by the data set denoted by color_vector, or simply be painted in white. This flag only makes sense if draw_cells==true. Colorization is done through color_function.
Default is true.
Definition at line 924 of file data_out_base.h.
| ColorFunction DataOutBase::EpsFlags::color_function |
This is a pointer to the function which is used to colorize the cells. By default, it points to the static function default_color_function() which is a member of this class.
Definition at line 959 of file data_out_base.h.
| const char* DataOutBase::TecplotFlags::tecplot_binary_file_name |
This variable is needed to hold the output file name when using the Tecplot API to write binary files. If the user doesn't set the file name with this variable only ASCII Tecplot output will be produced.
Definition at line 1055 of file data_out_base.h.
| const char* DataOutBase::TecplotFlags::zone_name |
Tecplot allows to assign names to zones. This variable stores this name.
Definition at line 1061 of file data_out_base.h.
| double DataOutBase::TecplotFlags::solution_time |
Solution time for each zone in a strand. This value must be non- negative, otherwise it will not be written to file. Do not assign any value for this in case of a static zone.
Definition at line 1068 of file data_out_base.h.
| double DataOutBase::VtkFlags::time |
The time of the time step if this file is part of a time dependent simulation.
The value of this variable is written into the output file according to the instructions provided in http://www.visitusers.org/index.php?title=Time_and_Cycle_in_VTK_files unless it is at its default value of
std::numeric_limits<unsigned int>::min()
.
Definition at line 1106 of file data_out_base.h.
| unsigned int DataOutBase::VtkFlags::cycle |
The number of the time step if this file is part of a time dependent simulation, or the cycle within a nonlinear or other iteration.
The value of this variable is written into the output file according to the instructions provided in http://www.visitusers.org/index.php?title=Time_and_Cycle_in_VTK_files unless it is at its default value of
std::numeric_limits<unsigned int>::min()
.
Definition at line 1118 of file data_out_base.h.
| bool DataOutBase::VtkFlags::print_date_and_time |
Flag to determine whether the current date and time shall be printed as a comment in the file's second line.
Default is true.
Definition at line 1126 of file data_out_base.h.
| ZlibCompressionLevel DataOutBase::VtkFlags::compression_level |
Flag determining the compression level at which zlib, if available, is run. The default is best_compression.
Definition at line 1158 of file data_out_base.h.
| bool DataOutBase::VtkFlags::write_higher_order_cells |
Flag determining whether to write patches as linear cells or as a high-order Lagrange cell.
Default is false.
true. Experience with these programs shows that these error messages are likely going to be rather less descriptive and more obscure. Definition at line 1177 of file data_out_base.h.
| unsigned int DataOutBase::SvgFlags::height |
Height of the image in SVG units. Default value is 4000.
Definition at line 1201 of file data_out_base.h.
| unsigned int DataOutBase::SvgFlags::width |
Width of the image in SVG units. If left zero, the width is computed from the height.
Definition at line 1207 of file data_out_base.h.
| unsigned int DataOutBase::SvgFlags::height_vector |
This denotes the number of the data vector which shall be used for generating the height information. By default, the first data vector is taken, i.e. height_vector==0, if there is any data vector. If there is no data vector, no height information is generated.
Definition at line 1215 of file data_out_base.h.
| int DataOutBase::SvgFlags::azimuth_angle |
Angles for the perspective view
Definition at line 1220 of file data_out_base.h.
| bool DataOutBase::SvgFlags::margin |
Draw a margin of 5% around the plotted area
Definition at line 1227 of file data_out_base.h.
| bool DataOutBase::SvgFlags::draw_colorbar |
Draw a colorbar encoding the cell coloring
Definition at line 1232 of file data_out_base.h.
|
static |
An indicator of the current file format version used to write intermediate format. We do not attempt to be backward compatible, so this number is used only to verify that the format we are writing is what the current readers and writers understand.
Definition at line 1261 of file data_out_base.h.
| bool DataOutBase::DataOutFilterFlags::filter_duplicate_vertices |
Filter duplicate vertices and associated values. This will drastically reduce the output data size but will result in an output file that does not faithfully represent the actual data if the data corresponds to discontinuous fields. In particular, along subdomain boundaries the data will still be discontinuous, while it will look like a continuous field inside of the subdomain.
Definition at line 1279 of file data_out_base.h.
| bool DataOutBase::DataOutFilterFlags::xdmf_hdf5_output |
Whether the XDMF output refers to HDF5 files. This affects how output is structured.
Definition at line 1285 of file data_out_base.h.
|
private |
Flags used to specify filtering behavior.
Definition at line 1486 of file data_out_base.h.
|
private |
The number of space dimensions in which the vertices represented by the current object live. This corresponds to the usual dim argument, but since this class is not templated on the dimension, we need to store it here.
Definition at line 1494 of file data_out_base.h.
|
private |
The number of vertices per cell. Equal to GeometryInfo<node_dim>::vertices_per_cell. We need to store it as a run-time variable here because the dimension node_dim is also a run-time variable.
Definition at line 1502 of file data_out_base.h.
|
private |
Map of points to an internal index.
Definition at line 1507 of file data_out_base.h.
|
private |
Map of actual point index to internal point index.
Definition at line 1512 of file data_out_base.h.
|
private |
Map of cells to the filtered points.
Definition at line 1517 of file data_out_base.h.
|
private |
Data set names.
Definition at line 1522 of file data_out_base.h.
|
private |
Data set dimensions.
Definition at line 1527 of file data_out_base.h.
|
private |
Data set data.
Definition at line 1532 of file data_out_base.h.
|
protected |
The default number of subdivisions for patches. This is filled by parse_parameters() and should be obeyed by build_patches() in derived classes.
Definition at line 3291 of file data_out_base.h.
|
private |
Standard output format. Use this format, if output format default_format is requested. It can be changed by the set_format function or in a parameter file.
Definition at line 3299 of file data_out_base.h.
|
private |
Flags to be used upon output of OpenDX data. Can be changed by using the set_flags function.
Definition at line 3305 of file data_out_base.h.
|
private |
Flags to be used upon output of UCD data. Can be changed by using the set_flags function.
Definition at line 3311 of file data_out_base.h.
|
private |
Flags to be used upon output of GNUPLOT data. Can be changed by using the set_flags function.
Definition at line 3317 of file data_out_base.h.
|
private |
Flags to be used upon output of POVRAY data. Can be changed by using the set_flags function.
Definition at line 3323 of file data_out_base.h.
|
private |
Flags to be used upon output of EPS data in one space dimension. Can be changed by using the set_flags function.
Definition at line 3329 of file data_out_base.h.
|
private |
Flags to be used upon output of gmv data in one space dimension. Can be changed by using the set_flags function.
Definition at line 3335 of file data_out_base.h.
|
private |
Flags to be used upon output of Tecplot data in one space dimension. Can be changed by using the set_flags function.
Definition at line 3341 of file data_out_base.h.
|
private |
Flags to be used upon output of vtk data in one space dimension. Can be changed by using the set_flags function.
Definition at line 3347 of file data_out_base.h.
|
private |
Flags to be used upon output of svg data in one space dimension. Can be changed by using the set_flags function.
Definition at line 3353 of file data_out_base.h.
|
private |
Flags to be used upon output of deal.II intermediate data in one space dimension. Can be changed by using the set_flags function.
Definition at line 3359 of file data_out_base.h.
|
private |
Arrays holding the set of patches as well as the names of output variables, all of which we read from an input stream.
Definition at line 3526 of file data_out_base.h.
|
private |
Information about whether certain components of the output field are to be considered vectors.
Definition at line 3538 of file data_out_base.h.
|
private |
Whether this entry is valid and contains data to be written.
Definition at line 3619 of file data_out_base.h.
|
private |
The name of the HDF5 heavy data solution file this entry references.
Definition at line 3624 of file data_out_base.h.
|
private |
The name of the HDF5 mesh file this entry references.
Definition at line 3629 of file data_out_base.h.
|
private |
The simulation time associated with this entry.
Definition at line 3634 of file data_out_base.h.
|
private |
The number of data nodes.
Definition at line 3639 of file data_out_base.h.
|
private |
The number of data cells.
Definition at line 3644 of file data_out_base.h.
|
private |
The dimension associated with the data.
Definition at line 3649 of file data_out_base.h.
|
private |
The dimension of the space the data lives in. Note that dimension <= space_dimension.
Definition at line 3655 of file data_out_base.h.
|
private |
The attributes associated with this entry and their dimension.
Definition at line 3660 of file data_out_base.h.
|
mutableprivate |
Place for the variables for each thread
Definition at line 375 of file function_parser.h.
|
mutableprivate |
The muParser objects for each thread (and one for each component). We are storing a unique_ptr so that we don't need to include the definition of mu::Parser in this header.
Definition at line 383 of file function_parser.h.
|
private |
An array to keep track of all the constants, required to initialize fp in each thread.
Definition at line 389 of file function_parser.h.
|
private |
An array for the variable names, required to initialize fp in each thread.
Definition at line 395 of file function_parser.h.
|
private |
An array of function expressions (one per component), required to initialize fp in each thread.
Definition at line 411 of file function_parser.h.
|
private |
State of usability. This variable is checked every time the function is called for evaluation. It's set to true in the initialize() methods.
Definition at line 417 of file function_parser.h.
|
private |
Number of variables. If this is also a function of time, then the number of variables is dim+1, otherwise it is dim. In the case that this is a time dependent function, the time is supposed to be the last variable. If n_vars is not identical to the number of the variables parsed by the initialize() method, then an exception is thrown.
Definition at line 426 of file function_parser.h.
|
staticprivate |
The separator used when accessing elements of a path into the parameter tree.
Definition at line 1610 of file parameter_handler.h.
|
private |
Path of presently selected subsections; empty list means top level
Definition at line 1615 of file parameter_handler.h.
|
private |
The complete tree of sections and entries. See the general documentation of this class for a description how data is stored in this variable.
The variable is a pointer so that we can use an incomplete type, rather than having to include all of the property_tree stuff from boost. This works around a problem with gcc 4.5.
Definition at line 1625 of file parameter_handler.h.
|
private |
A list of patterns that are used to describe the parameters of this object. Every nodes in the property tree corresponding to a parameter stores an index into this array.
Definition at line 1632 of file parameter_handler.h.
|
private |
A list of actions that are associated with parameters. These are added by the add_action() function. Nodes in the property tree corresponding to individual parameters store indices into this array in order to reference specific actions.
Definition at line 1640 of file parameter_handler.h.
| std::vector<std::string> MultipleParameterLoop::Entry::subsection_path |
Path to variant entry.
Definition at line 2079 of file parameter_handler.h.
| std::string MultipleParameterLoop::Entry::entry_name |
Name of entry.
Definition at line 2084 of file parameter_handler.h.
| std::string MultipleParameterLoop::Entry::entry_value |
Original variant value.
Definition at line 2089 of file parameter_handler.h.
| std::vector<std::string> MultipleParameterLoop::Entry::different_values |
List of entry values constructed out of what was given in the input file.
Definition at line 2095 of file parameter_handler.h.
| MultipleEntryType MultipleParameterLoop::Entry::type |
Store whether this entry is a variant entry or an array.
Definition at line 2100 of file parameter_handler.h.
|
private |
List of variant entry values.
Definition at line 2113 of file parameter_handler.h.
|
private |
Number of branches constructed from the different combinations of the variants. This obviously equals the number of runs to be performed.
Definition at line 2119 of file parameter_handler.h.
|
private |
Copy of the pattern that each element of the list has to satisfy.
Definition at line 545 of file patterns.h.
|
private |
Minimum number of elements the list must have.
Definition at line 550 of file patterns.h.
|
private |
Maximum number of elements the list must have.
Definition at line 555 of file patterns.h.
|
private |
Separator between elements of the list.
Definition at line 560 of file patterns.h.
|
staticprivate |
Initial part of description
Definition at line 565 of file patterns.h.
|
static |
Maximal integer value. If the numeric_limits class is available use this information to obtain the extremal values, otherwise set it so that this class understands that all values are allowed.
Definition at line 591 of file patterns.h.
|
private |
Copy of the patterns that each key and each value of the map has to satisfy.
Definition at line 693 of file patterns.h.
|
private |
Minimum number of elements the list must have.
Definition at line 699 of file patterns.h.
|
private |
Maximum number of elements the list must have.
Definition at line 704 of file patterns.h.
|
private |
Separator between elements of the list.
Definition at line 709 of file patterns.h.
|
private |
Separator between keys and values.
Definition at line 715 of file patterns.h.
|
staticprivate |
Initial part of description
Definition at line 720 of file patterns.h.
|
private |
Copy of the patterns stored in the Tuple.
Definition at line 881 of file patterns.h.
|
private |
Separator between elements of the list.
Definition at line 886 of file patterns.h.
|
staticprivate |
Initial part of description.
Definition at line 891 of file patterns.h.
|
private |
List of valid strings as passed to the constructor. We don't make this string constant, as we process it somewhat in the constructor.
Definition at line 970 of file patterns.h.
|
staticprivate |
Initial part of description
Definition at line 975 of file patterns.h.
|
staticprivate |
Initial part of description
Definition at line 1017 of file patterns.h.
|
staticprivate |
Initial part of description
Definition at line 1066 of file patterns.h.
| FileType Patterns::FileName::file_type |
file type flag
Definition at line 1134 of file patterns.h.
|
staticprivate |
Initial part of description
Definition at line 1148 of file patterns.h.
|
staticprivate |
Initial part of description
Definition at line 1206 of file patterns.h.
|
mutableprivate |
Store the number of objects which subscribed to this object. Initially, this number is zero, and upon destruction it shall be zero again (i.e. all objects which subscribed should have unsubscribed again).
The creator (and owner) of an object is counted in the map below if HE manages to supply identification.
We use the mutable keyword in order to allow subscription to constant objects also.
This counter may be read from and written to concurrently in multithreaded code: hence we use the std::atomic class template.
Definition at line 211 of file subscriptor.h.
|
mutableprivate |
In this map, we count subscriptions for each different identification string supplied to subscribe().
Definition at line 217 of file subscriptor.h.
|
mutableprivate |
In this vector, we store pointers to the validity bool in the SmartPointer objects that subscribe to this class.
Definition at line 233 of file subscriptor.h.
|
mutableprivate |
Pointer to the typeinfo object of this object, from which we can later deduce the class name. Since this information on the derived class is neither available in the destructor, nor in the constructor, we obtain it in between and store it here.
Definition at line 241 of file subscriptor.h.
|
staticprivate |
A mutex used to ensure data consistency when printing out the list of subscribers.
Definition at line 263 of file subscriptor.h.
| std::vector<internal::TableEntry> TableHandler::Column::entries |
List of entries within this column. Values are always immediately converted to strings to provide a uniform method of lookup.
Definition at line 653 of file table_handler.h.
| std::string TableHandler::Column::tex_caption |
The caption of the column in tex output. By default, this is the key string that is given to the TableHandler by TableHandler::add_value(...). This may be changed by calling TableHandler::set_tex_caption(...).
Definition at line 661 of file table_handler.h.
| std::string TableHandler::Column::tex_format |
The column format in tex output. By default, this is "c", meaning ‘centered’. This may be changed by calling TableHandler::set_tex_format(...) with "c", "r", "l" for centered, right or left.
Definition at line 670 of file table_handler.h.
| unsigned int TableHandler::Column::precision |
Double or float entries are written with this precision (set by the user). The default is 4.
Definition at line 676 of file table_handler.h.
| bool TableHandler::Column::scientific |
scientific=false means fixed point notation.
Definition at line 681 of file table_handler.h.
| unsigned int TableHandler::Column::flag |
Flag that may be used by derived classes for arbitrary purposes.
In particular, the ConvergenceTable class uses the flag to denote columns for which convergence information has already been computed, or should not be computed at all.
Definition at line 690 of file table_handler.h.
| unsigned int TableHandler::Column::max_length |
This entry caches the maximum length in characters for all entries in this table.
Definition at line 696 of file table_handler.h.
|
protected |
A variable storing the column and supercolumn keys in the order desired by the user. By default this is the order of adding the columns. This order may be changed by set_column_order().
Definition at line 723 of file table_handler.h.
|
mutableprotected |
A map from the column keys to the columns (not supercolumns).
The field is declared mutable so that the write_text() and write_tex() functions can be const, even though they may pad columns below if 'auto_fill_mode' is on.
Definition at line 732 of file table_handler.h.
|
protected |
A map from each supercolumn key to the keys of its subcolumns in the right order. It is allowed that a supercolumn has got the same key as a column.
Note that we do not use a multimap here since the order of column keys for each supercolumn key is relevant.
Definition at line 742 of file table_handler.h.
|
protected |
A map from the supercolumn keys to the captions of the supercolumns that are used in tex output.
By default these are just the supercolumn keys but they may be changed by set_tex_supercaptions(...).
Definition at line 751 of file table_handler.h.
|
protected |
The caption of the table itself.
Definition at line 756 of file table_handler.h.
|
protected |
The label of the table.
Definition at line 760 of file table_handler.h.
|
protected |
Flag indicating whether auto-fill mode should be used.
Definition at line 765 of file table_handler.h.
|
private |
Shared pointer to the object representing the task. This makes sure that the object lives as long as there is at least one subscriber to it.
Definition at line 1648 of file thread_management.h.
|
private |
List of task objects.
Definition at line 1843 of file thread_management.h.
|
private |
The value or expression that this instance of this class is to represent.
Definition at line 800 of file symengine_number_types.h.
|
private |
Flag for backward insertion.
Definition at line 536 of file block_matrix_array.h.
|
protected |
Index arrays for rows and columns.
Definition at line 843 of file block_matrix_base.h.
|
protected |
Array of sub-matrices.
Definition at line 849 of file block_matrix_base.h.
| std::vector<size_type> BlockMatrixBase< MatrixType >::TemporaryData::counter_within_block |
Temporary vector for counting the elements written into the individual blocks when doing a collective add or set.
Definition at line 1019 of file block_matrix_base.h.
| std::vector<std::vector<size_type> > BlockMatrixBase< MatrixType >::TemporaryData::column_indices |
Temporary vector for column indices on each block when writing local to global data on each sparse matrix.
Definition at line 1025 of file block_matrix_base.h.
| std::vector<std::vector<value_type> > BlockMatrixBase< MatrixType >::TemporaryData::column_values |
Temporary vector for storing the local values (they need to be reordered when writing local to global).
Definition at line 1031 of file block_matrix_base.h.
| Threads::Mutex BlockMatrixBase< MatrixType >::TemporaryData::mutex |
A mutex variable used to guard access to the member variables of this structure;
Definition at line 1037 of file block_matrix_base.h.
|
private |
A set of scratch arrays that can be used by the add() and set() functions that take pointers to data to pre-sort indices before use. Access from multiple threads is synchronized via the mutex variable that is part of the structure.
Definition at line 1061 of file block_matrix_base.h.
|
private |
Pointer to the block sparsity pattern used for this matrix. In order to guarantee that it is not deleted while still in use, we subscribe to it using the SmartPointer class.
Definition at line 368 of file block_sparse_matrix.h.
|
protected |
Number of block rows.
Definition at line 340 of file block_sparsity_pattern.h.
|
protected |
Number of block columns.
Definition at line 345 of file block_sparsity_pattern.h.
|
protected |
Array of sparsity patterns.
Definition at line 353 of file block_sparsity_pattern.h.
|
protected |
Object storing and managing the transformation of row indices to indices of the sub-objects.
Definition at line 359 of file block_sparsity_pattern.h.
|
protected |
Object storing and managing the transformation of column indices to indices of the sub-objects.
Definition at line 365 of file block_sparsity_pattern.h.
|
private |
Temporary vector for counting the elements written into the individual blocks when doing a collective add or set.
Definition at line 372 of file block_sparsity_pattern.h.
|
private |
Temporary vector for column indices on each block when writing local to global data on each sparse matrix.
Definition at line 378 of file block_sparsity_pattern.h.
|
private |
Pointer to the block vector object to which this iterator points. Depending on the value of the Constness template argument of this class, this is a const or non-const pointer.
Definition at line 366 of file block_vector_base.h.
|
private |
Global index of the element to which we presently point.
Definition at line 371 of file block_vector_base.h.
|
private |
Current block and index within this block of the element presently pointed to.
Definition at line 377 of file block_vector_base.h.
|
private |
Indices of the global element address at which we have to move on to another block when moving forward and backward. These indices are kept as a cache since this is much more efficient than always asking the parent object.
Definition at line 386 of file block_vector_base.h.
|
protected |
Pointer to the array of components.
Definition at line 966 of file block_vector_base.h.
|
protected |
Object managing the transformation between global indices and indices within the different blocks.
Definition at line 972 of file block_vector_base.h.
|
static |
It is safe to elide additions of zeros to individual elements of this matrix.
Definition at line 475 of file chunk_sparse_matrix.h.
|
private |
Pointer to the sparsity pattern used for this matrix. In order to guarantee that it is not deleted while still in use, we subscribe to it using the SmartPointer class.
Definition at line 1383 of file chunk_sparse_matrix.h.
|
private |
Array of values for all the nonzero entries. The position of an entry within the matrix, i.e., the row and column number for a given value in this array can only be deduced using the sparsity pattern. The same holds for the more common operation of finding an entry by its coordinates.
Definition at line 1392 of file chunk_sparse_matrix.h.
|
private |
Allocated size of val. This can be larger than the actually used part if the size of the matrix was reduced sometime in the past by associating a sparsity pattern with a smaller size to this object, using the reinit() function.
Definition at line 1400 of file chunk_sparse_matrix.h.
|
private |
Number of rows that this sparsity structure shall represent.
Definition at line 837 of file chunk_sparsity_pattern.h.
|
private |
Number of columns that this sparsity structure shall represent.
Definition at line 842 of file chunk_sparsity_pattern.h.
|
private |
The size of chunks.
Definition at line 847 of file chunk_sparsity_pattern.h.
|
private |
The reduced sparsity pattern. We store only which chunks exist, with each chunk a block in the matrix of size chunk_size by chunk_size.
Definition at line 853 of file chunk_sparsity_pattern.h.
|
static |
It is not safe to elide additions of zeros to individual elements of this matrix. The reason is that additions to the matrix may trigger collective operations synchronizing buffers on multiple processes. If an addition is elided on one process, this may lead to other processes hanging in an infinite waiting loop.
Definition at line 392 of file petsc_sparse_matrix.h.
|
private |
Copy of the communicator object to be used for this parallel vector.
Definition at line 702 of file petsc_sparse_matrix.h.
| double PreconditionBlock< MatrixType, inverse_type >::AdditionalData::relaxation |
Relaxation parameter.
Definition at line 122 of file precondition_block.h.
| size_type PreconditionBlock< MatrixType, inverse_type >::AdditionalData::block_size |
Block size.
Definition at line 127 of file precondition_block.h.
| bool PreconditionBlock< MatrixType, inverse_type >::AdditionalData::invert_diagonal |
Invert diagonal during initialization.
Definition at line 132 of file precondition_block.h.
| bool PreconditionBlock< MatrixType, inverse_type >::AdditionalData::same_diagonal |
Assume all diagonal blocks are equal to save memory.
Definition at line 137 of file precondition_block.h.
| PreconditionBlockBase<inverse_type>::Inversion PreconditionBlock< MatrixType, inverse_type >::AdditionalData::inversion |
Choose the inversion method for the blocks.
Definition at line 141 of file precondition_block.h.
| double PreconditionBlock< MatrixType, inverse_type >::AdditionalData::threshold |
The if inversion is SVD, the threshold below which a singular value will be considered zero and thus not inverted. This parameter is used in the call to LAPACKFullMatrix::compute_inverse_svd().
Definition at line 148 of file precondition_block.h.
|
protected |
Size of the blocks. Each diagonal block is assumed to be of the same size.
Definition at line 340 of file precondition_block.h.
|
protected |
Pointer to the matrix. Make sure that the matrix exists as long as this class needs it, i.e. until calling invert_diagblocks, or (if the inverse matrices should not be stored) until the last call of the preconditoining vmult function of the derived classes.
Definition at line 348 of file precondition_block.h.
|
protected |
Relaxation parameter to be used by derived classes.
Definition at line 352 of file precondition_block.h.
|
protected |
The permutation vector
Definition at line 357 of file precondition_block.h.
|
protected |
The inverse permutation vector
Definition at line 362 of file precondition_block.h.
|
protected |
The matrix accessed.
Definition at line 439 of file precondition_block.h.
|
protected |
Save block size here for further reference.
Definition at line 444 of file precondition_block.h.
|
protected |
Current block number.
Definition at line 449 of file precondition_block.h.
|
protected |
Iterator inside block.
Definition at line 454 of file precondition_block.h.
|
protected |
End of current block.
Definition at line 459 of file precondition_block.h.
|
private |
Store an object of the accessor class.
Definition at line 513 of file precondition_block.h.
|
protected |
Stores the name of the preconditioning.
Definition at line 184 of file precondition_selector.h.
|
private |
Matrix that is used for the matrix-builtin preconditioning function. cf. also PreconditionUseMatrix.
Definition at line 192 of file precondition_selector.h.
|
private |
Stores the damping parameter of the preconditioner.
Definition at line 197 of file precondition_selector.h.
|
protected |
Within the iteration loop, the square of the residual vector is stored in this variable. The function criterion uses this variable to compute the convergence value, which in this class is the norm of the residual vector and thus the square root of the res2 value.
Definition at line 146 of file solver_minres.h.
| double SparseLUDecomposition< number >::AdditionalData::strengthen_diagonal |
strengthen_diag times the sum of absolute row entries is added to the diagonal entries.
Per default, this value is zero, i.e. the diagonal is not strengthened.
Definition at line 161 of file sparse_decomposition.h.
| unsigned int SparseLUDecomposition< number >::AdditionalData::extra_off_diagonals |
By default, the initialize(matrix, data) function creates its own sparsity. This sparsity has the same SparsityPattern as matrix with some extra off diagonals the number of which is specified by extra_off_diagonals.
The user can give a SparsityPattern to use_this_sparsity. Then this sparsity is used and the extra_off_diagonals argument is ignored.
Definition at line 173 of file sparse_decomposition.h.
| bool SparseLUDecomposition< number >::AdditionalData::use_previous_sparsity |
If this flag is true the initialize() function uses the same sparsity that was used during the previous initialize() call.
This might be useful when several linear problems on the same sparsity need to solved, as for example several Newton iteration steps on the same triangulation.
Definition at line 183 of file sparse_decomposition.h.
| const SparsityPattern* SparseLUDecomposition< number >::AdditionalData::use_this_sparsity |
When a SparsityPattern is given to this argument, the initialize() function calls reinit(*use_this_sparsity) causing this sparsity to be used.
Note that the sparsity structures of *use_this_sparsity and the matrix passed to the initialize function need not be equal. Fill-in is allowed, as well as filtering out some elements in the matrix.
Definition at line 195 of file sparse_decomposition.h.
|
protected |
The default strengthening value, returned by get_strengthen_diagonal().
Definition at line 316 of file sparse_decomposition.h.
|
protected |
For every row in the underlying SparsityPattern, this array contains a pointer to the row's first afterdiagonal entry. Becomes available after invocation of prebuild_lower_bound().
Definition at line 323 of file sparse_decomposition.h.
|
private |
In general this pointer is zero except for the case that no SparsityPattern is given to this class. Then, a SparsityPattern is created and is passed down to the SparseMatrix base class.
Nevertheless, the SparseLUDecomposition needs to keep ownership of this sparsity. It keeps this pointer to it enabling it to delete this sparsity at destruction time.
Definition at line 341 of file sparse_decomposition.h.
|
static |
It is safe to elide additions of zeros to individual elements of this matrix.
Definition at line 549 of file sparse_matrix.h.
|
private |
Pointer to the sparsity pattern used for this matrix. In order to guarantee that it is not deleted while still in use, we subscribe to it using the SmartPointer class.
Definition at line 1697 of file sparse_matrix.h.
|
private |
Array of values for all the nonzero entries. The position of an entry within the matrix, i.e., the row and column number for a given value in this array can only be deduced using the sparsity pattern. The same holds for the more common operation of finding an entry by its coordinates.
Definition at line 1706 of file sparse_matrix.h.
|
private |
Allocated size of val. This can be larger than the actually used part if the size of the matrix was reduced sometime in the past by associating a sparsity pattern with a smaller size to this object, using the reinit() function.
Definition at line 1714 of file sparse_matrix.h.
| size_type SparseMatrixEZ< number >::Entry::column |
The column number.
Definition at line 131 of file sparse_matrix_ez.h.
| number SparseMatrixEZ< number >::Entry::value |
The value there.
Definition at line 136 of file sparse_matrix_ez.h.
|
static |
Non-existent column number.
Definition at line 141 of file sparse_matrix_ez.h.
| size_type SparseMatrixEZ< number >::RowInfo::start |
Index of first entry of the row in the data field.
Definition at line 158 of file sparse_matrix_ez.h.
| unsigned short SparseMatrixEZ< number >::RowInfo::length |
Number of entries in this row.
Definition at line 162 of file sparse_matrix_ez.h.
| unsigned short SparseMatrixEZ< number >::RowInfo::diagonal |
Position of the diagonal element relative tor the start index.
Definition at line 166 of file sparse_matrix_ez.h.
|
static |
Value for non-existing diagonal.
Definition at line 170 of file sparse_matrix_ez.h.
|
protected |
The matrix accessed.
Definition at line 223 of file sparse_matrix_ez.h.
|
protected |
Current row number.
Definition at line 228 of file sparse_matrix_ez.h.
|
protected |
Current index in row.
Definition at line 233 of file sparse_matrix_ez.h.
|
private |
Store an object of the accessor class.
Definition at line 287 of file sparse_matrix_ez.h.
|
private |
Number of columns. This is used to check vector dimensions only.
Definition at line 889 of file sparse_matrix_ez.h.
|
private |
Info structure for each row.
Definition at line 894 of file sparse_matrix_ez.h.
|
private |
Data storage.
Definition at line 899 of file sparse_matrix_ez.h.
|
private |
Increment when a row grows.
Definition at line 904 of file sparse_matrix_ez.h.
|
private |
Remember the user provided default row length.
Definition at line 909 of file sparse_matrix_ez.h.
|
private |
Values of the computed diagonal.
Definition at line 161 of file sparse_mic.h.
|
private |
Inverses of the diagonal: precomputed for faster vmult.
Definition at line 166 of file sparse_mic.h.
|
private |
Values of the computed "inner sums", i.e. per-row sums of the elements laying on the right side of the diagonal.
Definition at line 172 of file sparse_mic.h.
|
protected |
Maximum number of rows that can be stored in the rowstart array. Since reallocation of that array only happens if the present one is too small, but never when the size of this matrix structure shrinks, max_dim might be larger than rows and in this case rowstart has more elements than are used.
Definition at line 734 of file sparsity_pattern.h.
|
protected |
Number of rows that this sparsity structure shall represent.
Definition at line 739 of file sparsity_pattern.h.
|
protected |
Number of columns that this sparsity structure shall represent.
Definition at line 744 of file sparsity_pattern.h.
|
protected |
Size of the actually allocated array colnums. Here, the same applies as for the rowstart array, i.e. it may be larger than the actually used part of the array.
Definition at line 751 of file sparsity_pattern.h.
|
protected |
Maximum number of elements per row. This is set to the value given to the reinit() function (or to the constructor), or to the maximum row length computed from the vectors in case the more flexible constructors or reinit versions are called. Its value is more or less meaningless after compress() has been called.
Definition at line 760 of file sparsity_pattern.h.
|
protected |
Array which hold for each row which is the first element in colnums belonging to that row. Note that the size of the array is one larger than the number of rows, because the last element is used for row=rows, i.e. the row past the last used one. The value of rowstart[rows]} equals the index of the element past the end in colnums; this way, we are able to write loops like for (i=rowstart[k]; i<rowstart[k+1]; ++i) also for the last row.
Note that the actual size of the allocated memory may be larger than the region that is used. The actual number of elements that was allocated is stored in max_dim.
Definition at line 775 of file sparsity_pattern.h.
|
protected |
Array of column numbers. In this array, we store for each non-zero element its column number. The column numbers for the elements in row r are stored within the index range rowstart[r]...rowstart[r+1]. Therefore to find out whether a given element (r,c) exists, we have to check whether the column number c exists in the above-mentioned range within this array. If it exists, say at position p within this array, the value of the respective element in the sparse matrix will also be at position p of the values array of that class.
At the beginning, all elements of this array are set to -1 indicating invalid (unused) column numbers (diagonal elements are preset if optimized storage is requested, though). Now, if nonzero elements are added, one column number in the row's respective range after the other is set to the column number of the added element. When compress is called, unused elements (indicated by column numbers -1) are eliminated by copying the column number of subsequent rows and the column numbers within each row (with possible exception of the diagonal element) are sorted, such that finding whether an element exists and determining its position can be done by a binary search.
Definition at line 799 of file sparsity_pattern.h.
|
protected |
Store whether the compress() function was called for this object.
Definition at line 804 of file sparsity_pattern.h.
|
private |
Is special treatment of diagonals enabled?
Definition at line 1294 of file sparsity_pattern.h.
|
private |
Name of the file to which data was swapped out. If no data is presently swapped out (i.e. before calling swap_out and after kill_file), the string is empty, indicating no ownership of files.
Definition at line 196 of file swappable_vector.h.
|
private |
If in multithread mode, then the alert function has functionality, but needs to coordinate with the reload function. This is done through the following lock.
If not in MT mode, then the class used here is empty, and we can as well get away with it.
Definition at line 206 of file swappable_vector.h.
|
private |
Flag by which the alert function signifies that the data has been preloaded already. This flag is always false in non-MT mode.
Definition at line 212 of file swappable_vector.h.
|
private |
Pointer to the user-supplied Epetra Trilinos mapping of the matrix columns that assigns parts of the matrix to the individual processes.
Definition at line 1223 of file trilinos_sparsity_pattern.h.
|
private |
A sparsity pattern object in Trilinos to be used for finite element based problems which allows for adding non-local elements to the pattern.
Definition at line 1230 of file trilinos_sparsity_pattern.h.
|
private |
A sparsity pattern object for the non-local part of the sparsity pattern that is going to be sent to the owning processor. Only used when the particular constructor or reinit method with writable_rows argument is set
Definition at line 1238 of file trilinos_sparsity_pattern.h.
| std::vector<entry_type>* GrowingVectorMemory< VectorType >::Pool::data |
Pointer to the storage object
Definition at line 435 of file vector_memory.h.
|
private |
Overall number of allocations. Only used for bookkeeping and to generate output at the end of an object's lifetime.
Definition at line 448 of file vector_memory.h.
|
private |
Number of vectors currently allocated in this object; used for detecting memory leaks.
Definition at line 454 of file vector_memory.h.
|
private |
A flag controlling the logging of statistics by the destructor.
Definition at line 459 of file vector_memory.h.
|
staticprivate |
Mutex to synchronize access to internal data of this object from multiple threads.
Definition at line 465 of file vector_memory.h.
|
friend |
Make the iterator class a friend. We have to work around a compiler bug here again.
Definition at line 1068 of file block_matrix_base.h.
|
friend |
Make the block sparse matrix a friend, so that it can use our row_indices and column_indices objects.
Typedef for the type used to describe sparse matrices that consist of multiple blocks.
Definition at line 385 of file block_sparsity_pattern.h.
|
friend |
Mark all other instances of this template as friends.
Definition at line 406 of file block_vector_base.h.
|
friend |
Make the iterator class a friend.
Definition at line 978 of file block_vector_base.h.
|
friend |
Also give access to internal details to the iterator/accessor classes.
Definition at line 1416 of file chunk_sparse_matrix.h.
|
friend |
Make all the chunk sparse matrix kinds friends.
Definition at line 859 of file chunk_sparsity_pattern.h.
|
friend |
Make the accessor class a friend.
Definition at line 864 of file chunk_sparsity_pattern.h.
|
friend |
To allow calling protected prepare_add() and prepare_set().
Definition at line 762 of file petsc_sparse_matrix.h.
|
friend |
Make enclosing class a friend.
Definition at line 464 of file precondition_block.h.
Typedef for sparse matrix type used
Typedef for the sparse matrix type used.
Definition at line 1718 of file sparse_matrix.h.
To allow it calling private prepare_add() and prepare_set().
Definition at line 1728 of file sparse_matrix.h.
|
friend |
Also give access to internal details to the iterator/accessor classes.
Definition at line 1734 of file sparse_matrix.h.
|
friend |
Make enclosing class a friend.
Definition at line 238 of file sparse_matrix_ez.h.
|
friend |
Make all sparse matrices friends of this class.
Typedef for sparse matrix type used
Typedef for the sparse matrix type used.
Definition at line 810 of file sparsity_pattern.h.
|
friend |
Also give access to internal details to the iterator/accessor classes.
Definition at line 824 of file sparsity_pattern.h.
|
friend |
Make all sparse matrices friends of this class.
Typedef for sparse matrix type used
Typedef for the sparse matrix type used.
Definition at line 1300 of file sparsity_pattern.h.
|
friend |
Also give access to internal details to the iterator/accessor classes.
Definition at line 1314 of file sparsity_pattern.h.
|
friend |
Give access to internal datastructures to perform MPI operations.
1.8.16