Reference documentation for deal.II version GIT dad323def1 2022-06-25 19:00:02+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Modules | Classes | Macros | Typedefs | Enumerations | Enumerator | Functions | Variables | Friends
Collaboration diagram for Exceptions and assertions:

Modules

 TrilinosWrappers
 

Classes

struct  DataOutBase::EpsFlags::RgbValues
 
struct  DataOutBase::DataOutFilter::Point3Comp
 
class  ExceptionBase
 
class  StandardExceptions::ExcMPI
 
class  internal::FunctionParser::muParserBase
 
struct  internal::FunctionParser::ParserData
 
class  internal::FunctionParser::ParserImplementation< dim, Number >
 
class  MultipleParameterLoop::UserClass
 
class  MultipleParameterLoop::Entry
 
struct  Patterns::Tools::Convert< T, Enable >
 
struct  Patterns::Tools::internal::RankInfo< T, Enable >
 
struct  Patterns::Tools::Convert< T, typename std::enable_if< std::is_arithmetic< T >::value >::type >
 
struct  Patterns::Tools::internal::is_list_compatible< T >
 
struct  Patterns::Tools::internal::is_list_compatible< std::vector< Args... > >
 
struct  Patterns::Tools::internal::is_list_compatible< std::deque< Args... > >
 
struct  Patterns::Tools::internal::is_list_compatible< std::list< Args... > >
 
struct  Patterns::Tools::internal::is_list_compatible< std::set< Args... > >
 
struct  Patterns::Tools::internal::is_list_compatible< std::multiset< Args... > >
 
struct  Patterns::Tools::internal::is_list_compatible< std::unordered_set< Args... > >
 
struct  Patterns::Tools::internal::is_list_compatible< std::unordered_multiset< Args... > >
 
struct  Patterns::Tools::internal::is_map_compatible< T >
 
struct  Patterns::Tools::internal::is_map_compatible< std::map< Key, T, Compare, Allocator > >
 
struct  Patterns::Tools::internal::is_map_compatible< std::multimap< Key, T, Compare, Allocator > >
 
struct  Patterns::Tools::internal::is_map_compatible< std::unordered_map< Key, T, Hash, KeyEqual, Allocator > >
 
struct  Patterns::Tools::internal::is_map_compatible< std::unordered_multimap< Key, T, Hash, KeyEqual, Allocator > >
 
struct  Patterns::Tools::is_list_compatible< T >
 
struct  Patterns::Tools::is_map_compatible< T >
 
struct  Patterns::Tools::internal::RankInfo< T, typename std::enable_if< is_list_compatible< T >::value >::type >
 
struct  Patterns::Tools::internal::RankInfo< T, typename std::enable_if< is_map_compatible< T >::value >::type >
 
struct  Patterns::Tools::internal::RankInfo< Tensor< rank, dim, Number > >
 
struct  Patterns::Tools::internal::RankInfo< Point< dim, Number > >
 
struct  Patterns::Tools::internal::RankInfo< std::complex< Number > >
 
struct  Patterns::Tools::internal::RankInfo< std::unique_ptr< FunctionParser< dim > > >
 
struct  Patterns::Tools::internal::RankInfo< ComponentMask >
 
struct  Patterns::Tools::internal::RankInfo< std::pair< Key, Value > >
 
struct  Patterns::Tools::internal::RankInfo< std::tuple< Types... > >
 
struct  Patterns::Tools::internal::RankInfo< std::array< T, N > >
 
struct  Patterns::Tools::Convert< T, typename std::enable_if< is_list_compatible< T >::value >::type >
 
struct  Patterns::Tools::Convert< T, typename std::enable_if< is_map_compatible< T >::value >::type >
 
struct  Patterns::Tools::Convert< std::array< ValueType, N > >
 
struct  Patterns::Tools::Convert< Tensor< rank, dim, Number > >
 
struct  Patterns::Tools::Convert< Point< dim, Number > >
 
struct  Patterns::Tools::Convert< std::unique_ptr< FunctionParser< dim > > >
 
struct  Patterns::Tools::Convert< ComponentMask >
 
struct  Patterns::Tools::Convert< std::complex< Number > >
 
struct  Patterns::Tools::Convert< std::string >
 
struct  Patterns::Tools::Convert< std::pair< Key, Value > >
 
struct  Patterns::Tools::Convert< std::tuple< Args... > >
 
struct  TableHandler::Column
 
class  Threads::Task< RT >::TaskData
 
class  Differentiation::SD::Expression
 
struct  Differentiation::SD::is_symengine_number< Expression >
 
struct  Differentiation::SD::is_sd_number< Expression >
 
class  Differentiation::SD::BatchOptimizer< ReturnType >
 
struct  Differentiation::SD::internal::DictionaryOptimizer< ReturnType, T >
 
struct  Differentiation::SD::internal::LambdaOptimizer< ReturnType, T >
 
struct  Differentiation::SD::internal::OptimizerHelper< ReturnType, Optimizer, T >
 
struct  BlockMatrixBase< MatrixType >::TemporaryData
 
class  internal::LinearOperatorImplementation::ReinitHelper< Vector >
 
class  internal::LinearOperatorImplementation::ReinitHelper< BlockVector< number > >
 
class  PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator
 
class  PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor
 
class  SparseMatrixEZ< number >::const_iterator::Accessor
 
class  VectorMemory< VectorType >::Pointer
 
struct  GrowingVectorMemory< VectorType >::Pool
 

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 AssertCudaKernel()
 
#define AssertCusparse(error_code)
 
#define AssertNothrowCusparse(error_code)
 
#define AssertCusolver(error_code)
 

Typedefs

using DataOutBase::EpsFlags::ColorFunction = RgbValues(*)(const double value, const double min_value, const double max_value)
 
using DataOutBase::DataOutFilter::Map3DPoint = std::multimap< Point< 3 >, unsigned int, Point3Comp >
 
using Patterns::Tools::Convert< std::array< ValueType, N > >::T = std::array< ValueType, N >
 
using Patterns::Tools::Convert< Tensor< rank, dim, Number > >::T = Tensor< rank, dim, Number >
 
using Patterns::Tools::Convert< Point< dim, Number > >::T = Point< dim, Number >
 
using Patterns::Tools::Convert< std::unique_ptr< FunctionParser< dim > > >::T = std::unique_ptr< FunctionParser< dim > >
 
using Patterns::Tools::Convert< ComponentMask >::T = ComponentMask
 
using Patterns::Tools::Convert< std::complex< Number > >::T = std::complex< Number >
 
using Patterns::Tools::Convert< std::string >::T = std::string
 
using Patterns::Tools::Convert< std::pair< Key, Value > >::T = std::pair< Key, Value >
 
using Patterns::Tools::Convert< std::tuple< Args... > >::T = std::tuple< Args... >
 
using BlockVectorBase< VectorType >::BlockType = VectorType
 
using BlockVectorBase< VectorType >::value_type = typename BlockType::value_type
 
using BlockVectorBase< VectorType >::pointer = value_type *
 
using BlockVectorBase< VectorType >::const_pointer = const value_type *
 
using BlockVectorBase< VectorType >::iterator = ::internal::BlockVectorIterators::Iterator< BlockVectorBase, false >
 
using BlockVectorBase< VectorType >::const_iterator = ::internal::BlockVectorIterators::Iterator< BlockVectorBase, true >
 
using BlockVectorBase< VectorType >::reference = typename BlockType::reference
 
using BlockVectorBase< VectorType >::const_reference = typename BlockType::const_reference
 
using BlockVectorBase< VectorType >::size_type = types::global_dof_index
 
using BlockVectorBase< VectorType >::real_type = typename BlockType::real_type
 
using PreconditionBlockJacobi< MatrixType, inverse_type >::number = typename MatrixType::value_type
 
using PreconditionBlockJacobi< MatrixType, inverse_type >::size_type = types::global_dof_index
 
using PreconditionBlockSOR< MatrixType, inverse_type >::size_type = types::global_dof_index
 
using PreconditionBlockSOR< MatrixType, inverse_type >::number = typename MatrixType::value_type
 
using PreconditionBlockSSOR< MatrixType, inverse_type >::size_type = types::global_dof_index
 
using PreconditionBlockSSOR< MatrixType, inverse_type >::number = typename MatrixType::value_type
 
using GrowingVectorMemory< VectorType >::size_type = types::global_dof_index
 
using GrowingVectorMemory< VectorType >::entry_type = std::pair< bool, std::unique_ptr< VectorType > >
 

Enumerations

enum  DataOutBase::EpsFlags::SizeType { DataOutBase::EpsFlags::width , DataOutBase::EpsFlags::height }
 
enum  DataOutBase::VtkFlags::ZlibCompressionLevel { DataOutBase::VtkFlags::no_compression , DataOutBase::VtkFlags::best_speed , DataOutBase::VtkFlags::best_compression , DataOutBase::VtkFlags::default_compression }
 
enum  MultipleParameterLoop::Entry::MultipleEntryType { MultipleParameterLoop::Entry::variant , MultipleParameterLoop::Entry::array }
 
enum  Patterns::FileName::FileType { Patterns::FileName::input = 0 , Patterns::FileName::output = 1 }
 
enum class  Differentiation::SD::OptimizerType { Differentiation::SD::dictionary , Differentiation::SD::lambda , Differentiation::SD::llvm }
 
enum class  Differentiation::SD::OptimizationFlags : unsigned char { Differentiation::SD::optimize_default = 0 , Differentiation::SD::optimize_cse = 0x0001 , Differentiation::SD::optimize_aggressive = 0x0002 , Differentiation::SD::optimize_all = optimize_cse | optimize_aggressive }
 

Functions

static ::ExceptionBaseAnyData::ExcNameNotFound (std::string arg1)
 An entry with this name does not exist in the AnyData object. More...
 
static ::ExceptionBaseAnyData::ExcTypeMismatch (std::string arg1, std::string arg2)
 The requested type and the stored type are different. More...
 
static ::ExceptionBaseAnyData::ExcNameMismatch (int arg1, std::string arg2)
 
static ::ExceptionBaseConvergenceTable::ExcRateColumnAlreadyExists (std::string arg1)
 
 DataOutBase::Patch< dim, spacedim >::Patch ()
 
bool DataOutBase::Patch< dim, spacedim >::operator== (const Patch &patch) const
 
std::size_t DataOutBase::Patch< dim, spacedim >::memory_consumption () const
 
void DataOutBase::Patch< dim, spacedim >::swap (Patch< dim, spacedim > &other_patch)
 
static ::ExceptionBaseDataOutBase::Patch< dim, spacedim >::ExcInvalidCombinationOfDimensions (int arg1, int arg2)
 
 DataOutBase::Patch< 0, spacedim >::Patch ()
 
bool DataOutBase::Patch< 0, spacedim >::operator== (const Patch &patch) const
 
std::size_t DataOutBase::Patch< 0, spacedim >::memory_consumption () const
 
void DataOutBase::Patch< 0, spacedim >::swap (Patch< 0, spacedim > &other_patch)
 
static ::ExceptionBaseDataOutBase::Patch< 0, spacedim >::ExcInvalidCombinationOfDimensions (int arg1, int arg2)
 
static void DataOutBase::OutputFlagsBase< FlagsType >::declare_parameters (ParameterHandler &prm)
 
void DataOutBase::OutputFlagsBase< FlagsType >::parse_parameters (const ParameterHandler &prm)
 
std::size_t DataOutBase::OutputFlagsBase< FlagsType >::memory_consumption () const
 
 DataOutBase::DXFlags::DXFlags (const bool write_neighbors=false, const bool int_binary=false, const bool coordinates_binary=false, const bool data_binary=false)
 
static void DataOutBase::DXFlags::declare_parameters (ParameterHandler &prm)
 
void DataOutBase::DXFlags::parse_parameters (const ParameterHandler &prm)
 
 DataOutBase::UcdFlags::UcdFlags (const bool write_preamble=false)
 
static void DataOutBase::UcdFlags::declare_parameters (ParameterHandler &prm)
 
void DataOutBase::UcdFlags::parse_parameters (const ParameterHandler &prm)
 
 DataOutBase::GnuplotFlags::GnuplotFlags ()
 
 DataOutBase::GnuplotFlags::GnuplotFlags (const std::vector< std::string > &space_dimension_labels)
 
std::size_t DataOutBase::GnuplotFlags::memory_consumption () const
 
static ::ExceptionBaseDataOutBase::GnuplotFlags::ExcNotEnoughSpaceDimensionLabels ()
 
 DataOutBase::PovrayFlags::PovrayFlags (const bool smooth=false, const bool bicubic_patch=false, const bool external_data=false)
 
static void DataOutBase::PovrayFlags::declare_parameters (ParameterHandler &prm)
 
void DataOutBase::PovrayFlags::parse_parameters (const ParameterHandler &prm)
 
bool DataOutBase::EpsFlags::RgbValues::is_grey () const
 
static RgbValues DataOutBase::EpsFlags::default_color_function (const double value, const double min_value, const double max_value)
 
static RgbValues DataOutBase::EpsFlags::grey_scale_color_function (const double value, const double min_value, const double max_value)
 
static RgbValues DataOutBase::EpsFlags::reverse_grey_scale_color_function (const double value, const double min_value, const double max_value)
 
 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)
 
static void DataOutBase::EpsFlags::declare_parameters (ParameterHandler &prm)
 
void DataOutBase::EpsFlags::parse_parameters (const ParameterHandler &prm)
 
 DataOutBase::TecplotFlags::TecplotFlags (const char *zone_name=nullptr, const double solution_time=-1.0)
 
std::size_t DataOutBase::TecplotFlags::memory_consumption () const
 
 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, const std::map< std::string, std::string > &physical_units={})
 
 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)
 
 DataOutBase::DataOutFilterFlags::DataOutFilterFlags (const bool filter_duplicate_vertices=false, const bool xdmf_hdf5_output=false)
 
static void DataOutBase::DataOutFilterFlags::declare_parameters (ParameterHandler &prm)
 
void DataOutBase::DataOutFilterFlags::parse_parameters (const ParameterHandler &prm)
 
std::size_t DataOutBase::DataOutFilterFlags::memory_consumption () const
 
 DataOutBase::DataOutFilter::DataOutFilter ()
 
 DataOutBase::DataOutFilter::DataOutFilter (const DataOutBase::DataOutFilterFlags &flags)
 
template<int dim>
void DataOutBase::DataOutFilter::write_point (const unsigned int index, const Point< dim > &p)
 
template<int dim>
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)
 
void DataOutBase::DataOutFilter::write_cell_single (const unsigned int index, const unsigned int start, const unsigned int n_points, const ReferenceCell &reference_cell)
 
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)
 
void DataOutBase::DataOutFilter::fill_node_data (std::vector< double > &node_data) const
 
void DataOutBase::DataOutFilter::fill_cell_data (const unsigned int local_node_offset, std::vector< unsigned int > &cell_data) const
 
std::string DataOutBase::DataOutFilter::get_data_set_name (const unsigned int set_num) const
 
unsigned int DataOutBase::DataOutFilter::get_data_set_dim (const unsigned int set_num) const
 
const doubleDataOutBase::DataOutFilter::get_data_set (const unsigned int set_num) const
 
unsigned int DataOutBase::DataOutFilter::n_nodes () const
 
unsigned int DataOutBase::DataOutFilter::n_cells () const
 
unsigned int DataOutBase::DataOutFilter::n_data_sets () const
 
void DataOutBase::DataOutFilter::flush_points ()
 
void DataOutBase::DataOutFilter::flush_cells ()
 
bool DataOutBase::DataOutFilter::Point3Comp::operator() (const Point< 3 > &one, const Point< 3 > &two) const
 
void DataOutBase::DataOutFilter::internal_add_cell (const unsigned int cell_index, const unsigned int pt_index)
 
static ::ExceptionBaseDataOutBase::ExcInvalidDatasetSize (int arg1, int arg2)
 
static ::ExceptionBaseDataOutBase::ExcNoPatches ()
 
static ::ExceptionBaseDataOutBase::ExcTecplotAPIError ()
 
static ::ExceptionBaseDataOutBase::ExcErrorOpeningTecplotFile (char *arg1)
 
 DataOutInterface< dim, spacedim >::DataOutInterface ()
 
virtual DataOutInterface< dim, spacedim >::~DataOutInterface ()=default
 
void DataOutInterface< dim, spacedim >::write_dx (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_eps (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_gmv (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_gnuplot (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_povray (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_tecplot (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_ucd (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_vtk (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_vtu (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_vtu_in_parallel (const std::string &filename, const MPI_Comm &comm) const
 
void DataOutInterface< dim, spacedim >::write_pvtu_record (std::ostream &out, const std::vector< std::string > &piece_names) const
 
std::string DataOutInterface< dim, spacedim >::write_vtu_with_pvtu_record (const std::string &directory, const std::string &filename_without_extension, const unsigned int counter, const MPI_Comm &mpi_communicator, const unsigned int n_digits_for_counter=numbers::invalid_unsigned_int, const unsigned int n_groups=0) const
 
void DataOutInterface< dim, spacedim >::write_svg (std::ostream &out) const
 
void DataOutInterface< dim, spacedim >::write_deal_II_intermediate (std::ostream &out) const
 
XDMFEntry DataOutInterface< dim, spacedim >::create_xdmf_entry (const DataOutBase::DataOutFilter &data_filter, const std::string &h5_filename, const double cur_time, const MPI_Comm &comm) const
 
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, const MPI_Comm &comm) const
 
void DataOutInterface< dim, spacedim >::write_xdmf_file (const std::vector< XDMFEntry > &entries, const std::string &filename, const MPI_Comm &comm) const
 
void DataOutInterface< dim, spacedim >::write_hdf5_parallel (const DataOutBase::DataOutFilter &data_filter, const std::string &filename, const MPI_Comm &comm) const
 
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, const MPI_Comm &comm) const
 
void DataOutInterface< dim, spacedim >::write_filtered_data (DataOutBase::DataOutFilter &filtered_data) const
 
void DataOutInterface< dim, spacedim >::write (std::ostream &out, const DataOutBase::OutputFormat output_format=DataOutBase::default_format) const
 
void DataOutInterface< dim, spacedim >::set_default_format (const DataOutBase::OutputFormat default_format)
 
template<typename FlagType >
void DataOutInterface< dim, spacedim >::set_flags (const FlagType &flags)
 
std::string DataOutInterface< dim, spacedim >::default_suffix (const DataOutBase::OutputFormat output_format=DataOutBase::default_format) const
 
static void DataOutInterface< dim, spacedim >::declare_parameters (ParameterHandler &prm)
 
void DataOutInterface< dim, spacedim >::parse_parameters (ParameterHandler &prm)
 
std::size_t DataOutInterface< dim, spacedim >::memory_consumption () const
 
virtual const std::vector< DataOutBase::Patch< dim, spacedim > > & DataOutInterface< dim, spacedim >::get_patches () const =0
 
virtual std::vector< std::string > DataOutInterface< dim, spacedim >::get_dataset_names () const =0
 
virtual std::vector< std::tuple< unsigned int, unsigned int, std::string, DataComponentInterpretation::DataComponentInterpretation > > DataOutInterface< dim, spacedim >::get_nonscalar_data_ranges () const
 
void DataOutInterface< dim, spacedim >::validate_dataset_names () const
 
void DataOutReader< dim, spacedim >::read (std::istream &in)
 
void DataOutReader< dim, spacedim >::merge (const DataOutReader< dim, spacedim > &other)
 
static ::ExceptionBaseDataOutReader< dim, spacedim >::ExcIncompatibleDatasetNames ()
 
static ::ExceptionBaseDataOutReader< dim, spacedim >::ExcIncompatiblePatchLists ()
 
static ::ExceptionBaseDataOutReader< dim, spacedim >::ExcIncompatibleDimensions (int arg1, int arg2, int arg3, int arg4)
 
virtual const std::vector<::DataOutBase::Patch< dim, spacedim > > & DataOutReader< dim, spacedim >::get_patches () const override
 
virtual std::vector< std::string > DataOutReader< dim, spacedim >::get_dataset_names () const override
 
virtual std::vector< std::tuple< unsigned int, unsigned int, std::string, DataComponentInterpretation::DataComponentInterpretation > > DataOutReader< dim, spacedim >::get_nonscalar_data_ranges () const override
 
 XDMFEntry::XDMFEntry ()
 
 XDMFEntry::XDMFEntry (const std::string &filename, const double time, const std::uint64_t nodes, const std::uint64_t cells, const unsigned int dim)
 
 XDMFEntry::XDMFEntry (const std::string &mesh_filename, const std::string &solution_filename, const double time, const std::uint64_t nodes, const std::uint64_t cells, const unsigned int dim)
 
 XDMFEntry::XDMFEntry (const std::string &mesh_filename, const std::string &solution_filename, const double time, const std::uint64_t nodes, const std::uint64_t cells, const unsigned int dim, const unsigned int spacedim)
 
void XDMFEntry::add_attribute (const std::string &attr_name, const unsigned int dimension)
 
template<class Archive >
void XDMFEntry::serialize (Archive &ar, const unsigned int)
 
std::string XDMFEntry::get_xdmf_content (const unsigned int indent_level) const
 
std::string XDMFEntry::get_xdmf_content (const unsigned int indent_level, const ReferenceCell &reference_cell) const
 
template<int dim, int spacedim>
std::ostream & DataOutBase::operator<< (std::ostream &out, const Patch< dim, spacedim > &patch)
 
template<int dim, int spacedim>
std::istream & DataOutBase::operator>> (std::istream &in, Patch< dim, spacedim > &patch)
 
static ::ExceptionBaseDerivativeForm< order, dim, spacedim, Number >::ExcInvalidTensorIndex (int arg1)
 
static ::ExceptionBaseStandardExceptions::ExcDivideByZero ()
 
static ::ExceptionBaseStandardExceptions::ExcNumberNotFinite (std::complex< double > arg1)
 
static ::ExceptionBaseStandardExceptions::ExcOutOfMemory (std::size_t arg1)
 
static ::ExceptionBaseStandardExceptions::ExcMemoryLeak (int arg1)
 
static ::ExceptionBaseStandardExceptions::ExcIO ()
 
static ::ExceptionBaseStandardExceptions::ExcFileNotOpen (std::string arg1)
 
static ::ExceptionBaseStandardExceptions::ExcNotImplemented ()
 
static ::ExceptionBaseStandardExceptions::ExcInternalError ()
 
static ::ExceptionBaseStandardExceptions::ExcPureFunctionCalled ()
 
static ::ExceptionBaseStandardExceptions::ExcNotInitialized ()
 
static ::ExceptionBaseStandardExceptions::ExcInvalidState ()
 
static ::ExceptionBaseStandardExceptions::ExcImpossibleInDim (int arg1)
 
static ::ExceptionBaseStandardExceptions::ExcImpossibleInDimSpacedim (int arg1, int arg2)
 
static ::ExceptionBaseStandardExceptions::ExcZero ()
 
static ::ExceptionBaseStandardExceptions::ExcEmptyObject ()
 
static ::ExceptionBaseStandardExceptions::ExcDimensionMismatch (std::size_t arg1, std::size_t arg2)
 
static ::ExceptionBaseStandardExceptions::ExcDimensionMismatch2 (std::size_t arg1, std::size_t arg2, std::size_t arg3)
 
static ::ExceptionBaseStandardExceptions::ExcIndexRange (std::size_t arg1, std::size_t arg2, std::size_t arg3)
 
template<typename T >
static ::ExceptionBaseStandardExceptions::ExcIndexRangeType (T arg1, T arg2, T arg3)
 
static ::ExceptionBaseStandardExceptions::ExcLowerRange (int arg1, int arg2)
 
template<typename T >
static ::ExceptionBaseStandardExceptions::ExcLowerRangeType (T arg1, T arg2)
 
static ::ExceptionBaseStandardExceptions::ExcNotMultiple (int arg1, int arg2)
 
static ::ExceptionBaseStandardExceptions::ExcInvalidIterator ()
 
static ::ExceptionBaseStandardExceptions::ExcIteratorPastEnd ()
 
static ::ExceptionBaseStandardExceptions::ExcMessage (std::string arg1)
 
static ::ExceptionBaseStandardExceptions::ExcGhostsPresent ()
 
static ::ExceptionBaseStandardExceptions::ExcScalarAssignmentOnlyForZeroValue ()
 
static ::ExceptionBaseStandardExceptions::ExcNeedsLAPACK ()
 
static ::ExceptionBaseStandardExceptions::ExcNeedsMPI ()
 
static ::ExceptionBaseStandardExceptions::ExcNeedsFunctionparser ()
 
static ::ExceptionBaseStandardExceptions::ExcNeedsAssimp ()
 
static ::ExceptionBaseStandardExceptions::ExcCudaError (const char *arg1)
 
static ::ExceptionBaseStandardExceptions::ExcCusparseError (std::string arg1)
 
static ::ExceptionBaseStandardExceptions::ExcNeedsExodusII ()
 
static ::ExceptionBaseFunctions::ExcCSplineEmpty (int arg1)
 
static ::ExceptionBaseFunctions::ExcCSplineSizeMismatch (int arg1, int arg2)
 
static ::ExceptionBaseFunctions::ExcCSplineOrder (int arg1, double arg2, double arg3)
 
static ::ExceptionBaseFunctions::ExcCSplineRange (double arg1, double arg2, double arg3)
 
static ::ExceptionBaseFunctionParser< dim >::ExcParseError (int arg1, std::string arg2)
 
static ::ExceptionBaseFunctionParser< dim >::ExcInvalidExpressionSize (int arg1, int arg2)
 
static ::ExceptionBaseRefinementCase< dim >::ExcInvalidRefinementCase (int arg1)
 
static ::ExceptionBaseinternal::SubfaceCase< dim >::ExcInvalidSubfaceCase (int arg1)
 
static ::ExceptionBaseGeometryInfo< dim >::ExcInvalidCoordinate (double arg1)
 
static ::ExceptionBaseGeometryInfo< dim >::ExcInvalidSubface (int arg1, int arg2, int arg3)
 
static ::ExceptionBaseIndexSet::ExcIndexNotPresent (size_type arg1)
 
static ::ExceptionBaseinternal::FunctionParser::ExcParseError (int arg1, std::string arg2)
 
virtual internal::FunctionParser::muParserBase::~muParserBase ()=default
 
 internal::FunctionParser::ParserData::ParserData ()=default
 
 internal::FunctionParser::ParserData::ParserData (const ParserData &)=delete
 
 internal::FunctionParser::ParserImplementation< dim, Number >::ParserImplementation ()
 
virtual internal::FunctionParser::ParserImplementation< dim, Number >::~ParserImplementation ()=default
 
virtual void internal::FunctionParser::ParserImplementation< dim, Number >::initialize (const std::string &vars, const std::vector< std::string > &expressions, const std::map< std::string, double > &constants, const bool time_dependent=false)
 
void internal::FunctionParser::ParserImplementation< dim, Number >::init_muparser () const
 
Number internal::FunctionParser::ParserImplementation< dim, Number >::do_value (const Point< dim > &p, const double time, unsigned int component) const
 
void internal::FunctionParser::ParserImplementation< dim, Number >::do_all_values (const Point< dim > &p, const double time, ArrayView< Number > &values) const
 
static ::ExceptionBaseParameterHandler::ExcEntryAlreadyExists (std::string arg1)
 
static ::ExceptionBaseParameterHandler::ExcValueDoesNotMatchPattern (std::string arg1, std::string arg2)
 
static ::ExceptionBaseParameterHandler::ExcAlreadyAtTopLevel ()
 
static ::ExceptionBaseParameterHandler::ExcEntryUndeclared (std::string arg1)
 
static ::ExceptionBaseParameterHandler::ExcUnbalancedSubsections (std::string arg1, std::string arg2)
 
static ::ExceptionBaseParameterHandler::ExcNoSubsection (int arg1, std::string arg2, std::string arg3)
 
static ::ExceptionBaseParameterHandler::ExcCannotParseLine (int arg1, std::string arg2, std::string arg3)
 
static ::ExceptionBaseParameterHandler::ExcInvalidEntryForPattern (int arg1, std::string arg2, std::string arg3, std::string arg4, std::string arg5)
 
static ::ExceptionBaseParameterHandler::ExcInvalidXMLParameterFile ()
 
static ::ExceptionBaseParameterHandler::ExcCannotOpenIncludeStatementFile (int arg1, std::string arg2, std::string arg3)
 
std::string ParameterHandler::get_current_path () const
 
std::string ParameterHandler::get_current_full_path (const std::string &name) const
 
std::string ParameterHandler::get_current_full_path (const std::vector< std::string > &sub_path, const std::string &name) const
 
void ParameterHandler::scan_line (std::string line, const std::string &input_filename, const unsigned int current_line_n, const bool skip_undefined)
 
void ParameterHandler::recursively_print_parameters (const boost::property_tree::ptree &tree, const std::vector< std::string > &target_subsection_path, const ParameterHandler::OutputStyle style, const unsigned int indent_level, std::ostream &out) const
 
virtual MultipleParameterLoop::UserClass::~UserClass ()=default
 
virtual void MultipleParameterLoop::UserClass::create_new (const unsigned int run_no)=0
 
virtual void MultipleParameterLoop::UserClass::run (ParameterHandler &prm)=0
 
 MultipleParameterLoop::MultipleParameterLoop ()
 
virtual MultipleParameterLoop::~MultipleParameterLoop () override=default
 
virtual void MultipleParameterLoop::parse_input (std::istream &input, const std::string &filename="input file", const std::string &last_line="", const bool skip_undefined=false) override
 
void MultipleParameterLoop::loop (UserClass &uc)
 
std::size_t MultipleParameterLoop::memory_consumption () const
 
 MultipleParameterLoop::Entry::Entry ()
 
 MultipleParameterLoop::Entry::Entry (const std::vector< std::string > &Path, const std::string &Name, const std::string &Value)
 
void MultipleParameterLoop::Entry::split_different_values ()
 
std::size_t MultipleParameterLoop::Entry::memory_consumption () const
 
void MultipleParameterLoop::init_branches ()
 
void MultipleParameterLoop::init_branches_current_section ()
 
void MultipleParameterLoop::fill_entry_values (const unsigned int run_no)
 
static ::ExceptionBaseUtilities::MPI::Partitioner::ExcIndexNotPresent (types::global_dof_index arg1, unsigned int arg2)
 
static ::ExceptionBaseUtilities::MPI::Partitioner::ExcGhostIndexArrayHasWrongSize (unsigned int arg1, unsigned int arg2, unsigned int arg3)
 
static ::ExceptionBasePathSearch::ExcNoClass (std::string arg1)
 
static ::ExceptionBasePathSearch::ExcFileNotFound (std::string arg1, std::string arg2)
 
static ::ExceptionBasePatterns::List::ExcInvalidRange (int arg1, int arg2)
 
 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=":")
 
 Patterns::Map::Map (const Map &other)
 
virtual bool Patterns::Map::match (const std::string &test_string) const override
 
virtual std::string Patterns::Map::description (const OutputStyle style=Machine) const override
 
virtual std::unique_ptr< PatternBasePatterns::Map::clone () const override
 
static std::unique_ptr< MapPatterns::Map::create (const std::string &description)
 
std::size_t Patterns::Map::memory_consumption () const override
 
const PatternBasePatterns::Map::get_key_pattern () const
 
const PatternBasePatterns::Map::get_value_pattern () const
 
const std::string & Patterns::Map::get_separator () const
 
const std::string & Patterns::Map::get_key_value_separator () const
 
static ::ExceptionBasePatterns::Map::ExcInvalidRange (int arg1, int arg2)
 
 Patterns::Tuple::Tuple (const std::vector< std::unique_ptr< PatternBase >> &patterns, const std::string &separator=":")
 
 Patterns::Tuple::Tuple (const std::vector< std::unique_ptr< PatternBase >> &patterns, const char *separator)
 
template<class... PatternTypes>
 Patterns::Tuple::Tuple (const std::string &separator, const PatternTypes &...patterns)
 
template<class... PatternTypes>
 Patterns::Tuple::Tuple (const char *separator, const PatternTypes &...patterns)
 
template<typename... Patterns>
 Patterns::Tuple::Tuple (const Patterns &...patterns)
 
 Patterns::Tuple::Tuple (const Tuple &other)
 
virtual bool Patterns::Tuple::match (const std::string &test_string) const override
 
virtual std::string Patterns::Tuple::description (const OutputStyle style=Machine) const override
 
virtual std::unique_ptr< PatternBasePatterns::Tuple::clone () const override
 
static std::unique_ptr< TuplePatterns::Tuple::create (const std::string &description)
 
std::size_t Patterns::Tuple::memory_consumption () const override
 
const PatternBasePatterns::Tuple::get_pattern (const unsigned int i) const
 
const std::string & Patterns::Tuple::get_separator () const
 
 Patterns::MultipleSelection::MultipleSelection (const std::string &seq)
 
virtual bool Patterns::MultipleSelection::match (const std::string &test_string) const override
 
virtual std::string Patterns::MultipleSelection::description (const OutputStyle style=Machine) const override
 
virtual std::unique_ptr< PatternBasePatterns::MultipleSelection::clone () const override
 
static std::unique_ptr< MultipleSelectionPatterns::MultipleSelection::create (const std::string &description)
 
std::size_t Patterns::MultipleSelection::memory_consumption () const override
 
static ::ExceptionBasePatterns::MultipleSelection::ExcCommasNotAllowed (int arg1)
 
 Patterns::Bool::Bool ()
 
virtual std::string Patterns::Bool::description (const OutputStyle style=Machine) const override
 
virtual std::unique_ptr< PatternBasePatterns::Bool::clone () const override
 
static std::unique_ptr< BoolPatterns::Bool::create (const std::string &description)
 
 Patterns::Anything::Anything ()=default
 
virtual bool Patterns::Anything::match (const std::string &test_string) const override
 
virtual std::string Patterns::Anything::description (const OutputStyle style=Machine) const override
 
virtual std::unique_ptr< PatternBasePatterns::Anything::clone () const override
 
static std::unique_ptr< AnythingPatterns::Anything::create (const std::string &description)
 
 Patterns::FileName::FileName (const FileType type=input)
 
virtual bool Patterns::FileName::match (const std::string &test_string) const override
 
virtual std::string Patterns::FileName::description (const OutputStyle style=Machine) const override
 
virtual std::unique_ptr< PatternBasePatterns::FileName::clone () const override
 
static std::unique_ptr< FileNamePatterns::FileName::create (const std::string &description)
 
 Patterns::DirectoryName::DirectoryName ()=default
 
virtual bool Patterns::DirectoryName::match (const std::string &test_string) const override
 
virtual std::string Patterns::DirectoryName::description (const OutputStyle style=Machine) const override
 
virtual std::unique_ptr< PatternBasePatterns::DirectoryName::clone () const override
 
static std::unique_ptr< DirectoryNamePatterns::DirectoryName::create (const std::string &description)
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< T, Enable >::to_pattern ()=delete
 
static std::string Patterns::Tools::Convert< T, Enable >::to_string (const T &s, const Patterns::PatternBase &p= *Convert< T >::to_pattern())=delete
 
static T Patterns::Tools::Convert< T, Enable >::to_value (const std::string &s, const Patterns::PatternBase &p= *Convert< T >::to_pattern())=delete
 
template<typename T >
std::string Patterns::Tools::to_string (const T &t)
 
template<typename T >
void Patterns::Tools::to_value (const std::string &s, T &t)
 
static ::ExceptionBasePatterns::Tools::ExcNoMatch (std::string arg1, std::string arg2)
 
template<typename Dummy = T>
static std::enable_if< std::is_same< Dummy, T >::value &&std::is_same< T, bool >::value, std::unique_ptr< Patterns::PatternBase > >::type Patterns::Tools::Convert< T, typename std::enable_if< std::is_arithmetic< T >::value >::type >::to_pattern ()
 
static std::string Patterns::Tools::Convert< T, typename std::enable_if< std::is_arithmetic< T >::value >::type >::to_string (const T &value, const Patterns::PatternBase &p= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< T, typename std::enable_if< std::is_arithmetic< T >::value >::type >::to_value (const std::string &s, const Patterns::PatternBase &p= *Convert< T >::to_pattern())
 
template<class T >
constexpr int Patterns::Tools::internal::max_list_rank ()
 
template<class T1 , class T2 , class... Types>
constexpr int Patterns::Tools::internal::max_list_rank ()
 
template<class T >
constexpr int Patterns::Tools::internal::max_map_rank ()
 
template<class T1 , class T2 , class... Types>
constexpr int Patterns::Tools::internal::max_map_rank ()
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< T, typename std::enable_if< is_list_compatible< T >::value >::type >::to_pattern ()
 
static std::string Patterns::Tools::Convert< T, typename std::enable_if< is_list_compatible< T >::value >::type >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< T, typename std::enable_if< is_list_compatible< T >::value >::type >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< T, typename std::enable_if< is_map_compatible< T >::value >::type >::to_pattern ()
 
static std::string Patterns::Tools::Convert< T, typename std::enable_if< is_map_compatible< T >::value >::type >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< T, typename std::enable_if< is_map_compatible< T >::value >::type >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< std::array< ValueType, N > >::to_pattern ()
 
static std::string Patterns::Tools::Convert< std::array< ValueType, N > >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< std::array< ValueType, N > >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< Tensor< rank, dim, Number > >::to_pattern ()
 
static std::string Patterns::Tools::Convert< Tensor< rank, dim, Number > >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< Tensor< rank, dim, Number > >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< Point< dim, Number > >::to_pattern ()
 
static std::string Patterns::Tools::Convert< Point< dim, Number > >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< Point< dim, Number > >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< std::unique_ptr< FunctionParser< dim > > >::to_pattern ()
 
static std::string Patterns::Tools::Convert< std::unique_ptr< FunctionParser< dim > > >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< std::unique_ptr< FunctionParser< dim > > >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< ComponentMask >::to_pattern ()
 
static std::string Patterns::Tools::Convert< ComponentMask >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< ComponentMask >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< std::complex< Number > >::to_pattern ()
 
static std::string Patterns::Tools::Convert< std::complex< Number > >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< std::complex< Number > >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< std::string >::to_pattern ()
 
static std::string Patterns::Tools::Convert< std::string >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< std::string >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< std::pair< Key, Value > >::to_pattern ()
 
static std::string Patterns::Tools::Convert< std::pair< Key, Value > >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< std::pair< Key, Value > >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static std::unique_ptr< Patterns::PatternBasePatterns::Tools::Convert< std::tuple< Args... > >::to_pattern ()
 
static std::string Patterns::Tools::Convert< std::tuple< Args... > >::to_string (const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
static T Patterns::Tools::Convert< std::tuple< Args... > >::to_value (const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
 
template<std::size_t... U>
static std::array< std::string, std::tuple_size< T >::value > Patterns::Tools::Convert< std::tuple< Args... > >::to_string_internal_1 (const T &t, const Patterns::Tuple &pattern, std::index_sequence< U... >)
 
static std::array< std::string, std::tuple_size< T >::value > Patterns::Tools::Convert< std::tuple< Args... > >::to_string_internal_2 (const T &t, const Patterns::Tuple &pattern)
 
template<std::size_t... U>
static T Patterns::Tools::Convert< std::tuple< Args... > >::to_value_internal_1 (const std::vector< std::string > &s, const Patterns::Tuple &pattern, std::index_sequence< U... >)
 
static T Patterns::Tools::Convert< std::tuple< Args... > >::to_value_internal_2 (const std::vector< std::string > &s, const Patterns::Tuple &pattern)
 
static ::ExceptionBaseQIterated< dim >::ExcInvalidQuadratureFormula ()
 
static ::ExceptionBaseCellDataStorage< CellIteratorType, DataType >::ExcCellDataTypeMismatch ()
 
static ::ExceptionBaseCellDataStorage< CellIteratorType, DataType >::ExcTriangulationMismatch ()
 
static ::ExceptionBaseQuadratureSelector< dim >::ExcInvalidQGaussOrder (int arg1)
 
static ::ExceptionBaseQuadratureSelector< dim >::ExcInvalidOrder (std::string arg1, unsigned int arg2)
 
static ::ExceptionBaseQuadratureSelector< dim >::ExcInvalidQuadrature (std::string arg1)
 
static Quadrature< dim > QuadratureSelector< dim >::create_quadrature (const std::string &s, const unsigned int order)
 
static ::ExceptionBaseinternal::TableBaseAccessors::Accessor< N, T, C, P >::ExcIndexRange (size_type arg1, size_type arg2, size_type arg3)
 
static ::ExceptionBaseTableHandler::ExcColumnNotExistent (std::string arg1)
 
static ::ExceptionBaseTableHandler::ExcSuperColumnNotExistent (std::string arg1)
 
static ::ExceptionBaseTableHandler::ExcColumnOrSuperColumnNotExistent (std::string arg1)
 
static ::ExceptionBaseTableHandler::ExcWrongNumberOfDataEntries (std::string arg1, int arg2, std::string arg3, int arg4)
 
static ::ExceptionBaseTableHandler::ExcUndefinedTexFormat (std::string arg1)
 
 TableHandler::Column::Column ()
 
 TableHandler::Column::Column (const std::string &tex_caption)
 
void TableHandler::Column::pad_column_below (const unsigned int length)
 
template<class Archive >
void TableHandler::Column::save (Archive &ar, const unsigned int version) const
 
template<class Archive >
void TableHandler::Column::load (Archive &ar, const unsigned int version)
 
template<class Archive >
void TableHandler::Column::serialize (Archive &archive, const unsigned int version)
 
void TableHandler::Column::invalidate_cache ()
 
void TableHandler::get_selected_columns (std::vector< std::string > &sel_columns) const
 
unsigned int TableHandler::n_rows () const
 
static ::ExceptionBaseTensorFunctionParser< rank, dim, Number >::ExcParseError (int arg1, std::string arg2)
 
static ::ExceptionBaseTensorFunctionParser< rank, dim, Number >::ExcInvalidExpressionSize (int arg1, int arg2)
 
static ::ExceptionBaseThreads::Task< RT >::ExcNoTask ()
 
 Threads::Task< RT >::TaskData::TaskData (std::future< RT > &&future) noexcept
 
 Threads::Task< RT >::TaskData::TaskData (const TaskData &)=delete
 
 Threads::Task< RT >::TaskData::TaskData (TaskData &&)=delete
 
TaskDataThreads::Task< RT >::TaskData::operator= (const TaskData &)=delete
 
TaskDataThreads::Task< RT >::TaskData::operator= (TaskData &&)=delete
 
 Threads::Task< RT >::TaskData::~TaskData () noexcept
 
void Threads::Task< RT >::TaskData::wait ()
 
internal::return_value< RT >::reference_type Threads::Task< RT >::TaskData::get ()
 
TaskGroupThreads::TaskGroup< RT >::operator+= (const Task< RT > &t)
 
std::size_t Threads::TaskGroup< RT >::size () const
 
void Threads::TaskGroup< RT >::join_all () const
 
static ::ExceptionBaseDifferentiation::AD::ExcRequiresADNumberSpecialization ()
 
static ::ExceptionBaseDifferentiation::AD::ExcRequiresADOLC ()
 
static ::ExceptionBaseDifferentiation::AD::ExcSupportedDerivativeLevels (std::size_t arg1, std::size_t arg2)
 
static ::ExceptionBaseExcADOLCAdvancedBranching ()
 
static ::ExceptionBaseDifferentiation::SD::ExcSymEngineParserError (std::string arg1)
 
static ::ExceptionBaseDifferentiation::SD::ExcSymEngineLLVMNotAvailable ()
 
static ::ExceptionBaseDifferentiation::SD::ExcSymEngineLLVMReturnTypeNotSupported ()
 
template<class StreamType >
StreamType & Differentiation::SD::operator<< (StreamType &s, OptimizerType o)
 
OptimizationFlags Differentiation::SD::operator| (const OptimizationFlags f1, const OptimizationFlags f2)
 
OptimizationFlagsDifferentiation::SD::operator|= (OptimizationFlags &f1, const OptimizationFlags f2)
 
OptimizationFlags Differentiation::SD::operator& (const OptimizationFlags f1, const OptimizationFlags f2)
 
OptimizationFlagsDifferentiation::SD::operator&= (OptimizationFlags &f1, const OptimizationFlags f2)
 
bool Differentiation::SD::internal::use_symbolic_CSE (const enum OptimizationFlags &flags)
 
int Differentiation::SD::internal::get_LLVM_optimization_level (const enum OptimizationFlags &flags)
 
template<class StreamType >
StreamType & Differentiation::SD::operator<< (StreamType &s, OptimizationFlags o)
 
template<typename NumberType , int rank, int dim, template< int, int, typename > class TensorType>
TensorType< rank, dim, NumberType > Differentiation::SD::internal::tensor_evaluate_optimized (const TensorType< rank, dim, Expression > &symbol_tensor, const std::vector< NumberType > &cached_evaluation, const BatchOptimizer< NumberType > &optimizer)
 
template<typename NumberType , int dim>
SymmetricTensor< 4, dim, NumberType > Differentiation::SD::internal::tensor_evaluate_optimized (const SymmetricTensor< 4, dim, Expression > &symbol_tensor, const std::vector< NumberType > &cached_evaluation, const BatchOptimizer< NumberType > &optimizer)
 
template<typename NumberType , typename T >
void Differentiation::SD::internal::register_functions (BatchOptimizer< NumberType > &optimizer, const T &function)
 
template<typename NumberType , typename T >
void Differentiation::SD::internal::register_functions (BatchOptimizer< NumberType > &optimizer, const std::vector< T > &functions)
 
template<typename NumberType , typename T , typename... Args>
void Differentiation::SD::internal::register_functions (BatchOptimizer< NumberType > &optimizer, const T &function, const Args &...other_functions)
 
template<int rank, int dim, template< int, int, typename > class TensorType>
types::symbol_vector Differentiation::SD::internal::unroll_to_expression_vector (const TensorType< rank, dim, Expression > &symbol_tensor)
 
template<int dim>
types::symbol_vector Differentiation::SD::internal::unroll_to_expression_vector (const SymmetricTensor< 4, dim, Expression > &symbol_tensor)
 
 Differentiation::SD::BatchOptimizer< ReturnType >::BatchOptimizer ()
 
 Differentiation::SD::BatchOptimizer< ReturnType >::BatchOptimizer (const enum OptimizerType &optimization_method, const enum OptimizationFlags &optimization_flags=OptimizationFlags::optimize_all)
 
 Differentiation::SD::BatchOptimizer< ReturnType >::BatchOptimizer (const BatchOptimizer &other)
 
 Differentiation::SD::BatchOptimizer< ReturnType >::BatchOptimizer (BatchOptimizer &&)=default
 
 Differentiation::SD::BatchOptimizer< ReturnType >::~BatchOptimizer ()=default
 
void Differentiation::SD::BatchOptimizer< ReturnType >::copy_from (const BatchOptimizer &other)
 
template<typename Stream >
void Differentiation::SD::BatchOptimizer< ReturnType >::print (Stream &stream, const bool print_cse=false) const
 
template<class Archive >
void Differentiation::SD::BatchOptimizer< ReturnType >::save (Archive &archive, const unsigned int version) const
 
template<class Archive >
void Differentiation::SD::BatchOptimizer< ReturnType >::load (Archive &archive, const unsigned int version)
 
template<class Archive >
void Differentiation::SD::BatchOptimizer< ReturnType >::serialize (Archive &archive, const unsigned int version)
 
static ::ExceptionBaseDoFAccessor< structdim, dim, spacedim, level_dof_access >::ExcInvalidObject ()
 
static ::ExceptionBaseDoFAccessor< structdim, dim, spacedim, level_dof_access >::ExcVectorNotEmpty ()
 
static ::ExceptionBaseDoFAccessor< structdim, dim, spacedim, level_dof_access >::ExcVectorDoesNotMatch ()
 
static ::ExceptionBaseDoFAccessor< structdim, dim, spacedim, level_dof_access >::ExcMatrixDoesNotMatch ()
 
static ::ExceptionBaseDoFAccessor< structdim, dim, spacedim, level_dof_access >::ExcNotActive ()
 
static ::ExceptionBaseDoFAccessor< structdim, dim, spacedim, level_dof_access >::ExcCantCompareIterators ()
 
static ::ExceptionBaseDoFAccessor< 0, 1, spacedim, level_dof_access >::ExcInvalidObject ()
 
static ::ExceptionBaseDoFAccessor< 0, 1, spacedim, level_dof_access >::ExcVectorNotEmpty ()
 
static ::ExceptionBaseDoFAccessor< 0, 1, spacedim, level_dof_access >::ExcVectorDoesNotMatch ()
 
static ::ExceptionBaseDoFAccessor< 0, 1, spacedim, level_dof_access >::ExcMatrixDoesNotMatch ()
 
static ::ExceptionBaseDoFAccessor< 0, 1, spacedim, level_dof_access >::ExcNotActive ()
 
static ::ExceptionBaseDoFAccessor< 0, 1, spacedim, level_dof_access >::ExcCantCompareIterators ()
 
static ::ExceptionBaseinternal::hp::DoFHandlerImplementation::ExcNoDominatedFiniteElementOnChildren ()
 
static ::ExceptionBaseDoFRenumbering::ExcDoFHandlerNotInitialized ()
 
static ::ExceptionBaseDoFRenumbering::ExcInvalidComponentOrder ()
 
static ::ExceptionBaseDoFRenumbering::ExcNotDGFEM ()
 
static ::ExceptionBaseComponentMask::ExcNoComponentSelected ()
 
static ::ExceptionBaseFEValuesBase< dim, spacedim >::CellIteratorContainer::ExcNeedsDoFHandler ()
 
static ::ExceptionBaseFESubfaceValues< dim, spacedim >::ExcReinitCalledWithBoundaryFace ()
 
static ::ExceptionBaseFESubfaceValues< dim, spacedim >::ExcFaceHasNoSubfaces ()
 
static ::ExceptionBaseMappingFEField< dim, spacedim, VectorType >::ExcInactiveCell ()
 
static ::ExceptionBaseMappingQ1Eulerian< dim, VectorType, spacedim >::ExcInactiveCell ()
 
static ::ExceptionBaseMappingQEulerian< dim, VectorType, spacedim >::ExcInactiveCell ()
 
static ::ExceptionBaseFilteredIterator< BaseIterator >::ExcInvalidElement (BaseIterator arg1)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcUnknownSectionType (int arg1)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcUnknownElementType (int arg1)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcUnknownIdentifier (std::string arg1)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcNoTriangulationSelected ()
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcInvalidVertexIndex (int arg1, int arg2)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcInvalidVertexIndexGmsh (int arg1, int arg2, int arg3)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcInvalidDBMeshFormat ()
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcInvalidDBMESHInput (std::string arg1)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcDBMESHWrongDimension (int arg1)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcInvalidGMSHInput (std::string arg1)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcGmshUnsupportedGeometry (int arg1)
 
static ::ExceptionBaseGridIn< dim, spacedim >::ExcGmshNoCellInformation (unsigned int arg1, unsigned int arg2)
 
static ::ExceptionBaseGridOut::ExcInvalidState ()
 
static ::ExceptionBaseGridRefinement::ExcNegativeCriteria ()
 
static ::ExceptionBaseGridRefinement::ExcInvalidParameterValue ()
 
static ::ExceptionBaseExcMeshNotOrientable ()
 
static ::ExceptionBaseInterGridMap< MeshType >::ExcInvalidKey (cell_iterator arg1)
 
static ::ExceptionBaseInterGridMap< MeshType >::ExcIncompatibleGrids ()
 
static ::ExceptionBaseFlatManifold< dim, spacedim >::ExcPeriodicBox (int arg1, Point< spacedim > arg2, double arg3)
 
static ::ExceptionBasePersistentTriangulation< dim, spacedim >::ExcTriaNotEmpty ()
 
static ::ExceptionBasePersistentTriangulation< dim, spacedim >::ExcFlagsNotCleared ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcCellNotUsed ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcCellNotActive ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcCellHasNoChildren ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcCellHasNoParent ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcCantSetChildren (int arg1)
 
template<typename AccessorType >
static ::ExceptionBaseTriaAccessorExceptions::ExcDereferenceInvalidObject (AccessorType arg1)
 
static ::ExceptionBaseTriaAccessorExceptions::ExcCantCompareIterators ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcNeighborIsCoarser ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcNeighborIsNotCoarser ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcFacesHaveNoLevel ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcNoPeriodicNeighbor ()
 
static ::ExceptionBaseTriaAccessorExceptions::ExcSetOnlyEvenChildren (int arg1)
 
static ::ExceptionBaseCellAccessor< dim, spacedim >::ExcRefineCellNotActive ()
 
static ::ExceptionBaseCellAccessor< dim, spacedim >::ExcCellFlaggedForRefinement ()
 
static ::ExceptionBaseCellAccessor< dim, spacedim >::ExcCellFlaggedForCoarsening ()
 
static ::ExceptionBaseinternal::TriangulationImplementation::TriaObjects::ExcPointerIndexClash ()
 
static ::ExceptionBasehp::QCollection< dim >::ExcNoQuadrature ()
 
static ::ExceptionBaseAffineConstraints< number >::ExcMatrixIsClosed ()
 
static ::ExceptionBaseAffineConstraints< number >::ExcMatrixNotClosed ()
 
static ::ExceptionBaseAffineConstraints< number >::ExcLineInexistant (size_type arg1)
 
static ::ExceptionBaseAffineConstraints< number >::ExcEntryAlreadyExists (size_type arg1, size_type arg2, number arg3, number arg4)
 
static ::ExceptionBaseAffineConstraints< number >::ExcDoFConstrainedToConstrainedDoF (int arg1, int arg2)
 
static ::ExceptionBaseAffineConstraints< number >::ExcDoFIsConstrainedFromBothObjects (size_type arg1)
 
static ::ExceptionBaseAffineConstraints< number >::ExcDoFIsConstrainedToConstrainedDoF (size_type arg1)
 
static ::ExceptionBaseAffineConstraints< number >::ExcRowNotStoredHere (size_type arg1)
 
static ::ExceptionBaseAffineConstraints< number >::ExcColumnNotStoredHere (size_type arg1, size_type arg2)
 
static ::ExceptionBaseAffineConstraints< number >::ExcIncorrectConstraint (int arg1, int arg2)
 
static ::ExceptionBaseArpackSolver::ArpackExcInvalidNumberofEigenvalues (int arg1, int arg2)
 
static ::ExceptionBaseArpackSolver::ArpackExcInvalidEigenvectorSize (int arg1, int arg2)
 
static ::ExceptionBaseArpackSolver::ArpackExcInvalidEigenvectorSizeNonsymmetric (int arg1, int arg2)
 
static ::ExceptionBaseArpackSolver::ArpackExcInvalidEigenvalueSize (int arg1, int arg2)
 
static ::ExceptionBaseArpackSolver::ArpackExcInvalidNumberofArnoldiVectors (int arg1, int arg2)
 
static ::ExceptionBaseArpackSolver::ArpackExcSmallNumberofArnoldiVectors (int arg1, int arg2)
 
static ::ExceptionBaseArpackSolver::ArpackExcArpackIdo (int arg1)
 
static ::ExceptionBaseArpackSolver::ArpackExcArpackMode (int arg1)
 
static ::ExceptionBaseArpackSolver::ArpackExcArpackInfodsaupd (int arg1)
 
static ::ExceptionBaseArpackSolver::ArpackExcArpackInfodnaupd (int arg1)
 
static ::ExceptionBaseArpackSolver::ArpackExcArpackInfodseupd (int arg1)
 
static ::ExceptionBaseArpackSolver::ArpackExcArpackInfodneupd (int arg1)
 
static ::ExceptionBaseArpackSolver::ArpackExcArpackInfoMaxIt (int arg1)
 
static ::ExceptionBaseArpackSolver::ArpackExcArpackNoShifts ()
 
static ::ExceptionBaseBlockMatrixBase< MatrixType >::ExcIncompatibleRowNumbers (int arg1, int arg2, int arg3, int arg4)
 
static ::ExceptionBaseBlockMatrixBase< MatrixType >::ExcIncompatibleColNumbers (int arg1, int arg2, int arg3, int arg4)
 
void BlockMatrixBase< MatrixType >::clear ()
 
void BlockMatrixBase< MatrixType >::collect_sizes ()
 
template<class BlockVectorType >
void BlockMatrixBase< MatrixType >::vmult_block_block (BlockVectorType &dst, const BlockVectorType &src) const
 
template<class BlockVectorType , class VectorType >
void BlockMatrixBase< MatrixType >::vmult_block_nonblock (BlockVectorType &dst, const VectorType &src) const
 
template<class BlockVectorType , class VectorType >
void BlockMatrixBase< MatrixType >::vmult_nonblock_block (VectorType &dst, const BlockVectorType &src) const
 
template<class VectorType >
void BlockMatrixBase< MatrixType >::vmult_nonblock_nonblock (VectorType &dst, const VectorType &src) const
 
template<class BlockVectorType >
void BlockMatrixBase< MatrixType >::Tvmult_block_block (BlockVectorType &dst, const BlockVectorType &src) const
 
template<class BlockVectorType , class VectorType >
void BlockMatrixBase< MatrixType >::Tvmult_block_nonblock (BlockVectorType &dst, const VectorType &src) const
 
template<class BlockVectorType , class VectorType >
void BlockMatrixBase< MatrixType >::Tvmult_nonblock_block (VectorType &dst, const BlockVectorType &src) const
 
template<class VectorType >
void BlockMatrixBase< MatrixType >::Tvmult_nonblock_nonblock (VectorType &dst, const VectorType &src) const
 
void BlockMatrixBase< MatrixType >::prepare_add_operation ()
 
void BlockMatrixBase< MatrixType >::prepare_set_operation ()
 
TemporaryDataBlockMatrixBase< MatrixType >::TemporaryData::operator= (const TemporaryData &)
 
static ::ExceptionBaseBlockSparsityPatternBase< SparsityPatternType >::ExcIncompatibleRowNumbers (int arg1, int arg2, int arg3, int arg4)
 
static ::ExceptionBaseBlockSparsityPatternBase< SparsityPatternType >::ExcIncompatibleColNumbers (int arg1, int arg2, int arg3, int arg4)
 
 BlockSparsityPattern::BlockSparsityPattern ()=default
 
 BlockSparsityPattern::BlockSparsityPattern (const size_type n_rows, const size_type n_columns)
 
void BlockSparsityPattern::reinit (const size_type n_block_rows, const size_type n_block_columns)
 
void BlockSparsityPattern::reinit (const BlockIndices &row_indices, const BlockIndices &col_indices, const std::vector< std::vector< unsigned int >> &row_lengths)
 
bool BlockSparsityPattern::is_compressed () const
 
std::size_t BlockSparsityPattern::memory_consumption () const
 
void BlockSparsityPattern::copy_from (const BlockDynamicSparsityPattern &dsp)
 
 BlockDynamicSparsityPattern::BlockDynamicSparsityPattern ()=default
 
 BlockDynamicSparsityPattern::BlockDynamicSparsityPattern (const size_type n_rows, const size_type n_columns)
 
 BlockDynamicSparsityPattern::BlockDynamicSparsityPattern (const std::vector< size_type > &row_block_sizes, const std::vector< size_type > &col_block_sizes)
 
 BlockDynamicSparsityPattern::BlockDynamicSparsityPattern (const std::vector< IndexSet > &partitioning)
 
 BlockDynamicSparsityPattern::BlockDynamicSparsityPattern (const BlockIndices &row_indices, const BlockIndices &col_indices)
 
void BlockDynamicSparsityPattern::reinit (const std::vector< size_type > &row_block_sizes, const std::vector< size_type > &col_block_sizes)
 
void BlockDynamicSparsityPattern::reinit (const std::vector< IndexSet > &partitioning)
 
void BlockDynamicSparsityPattern::reinit (const BlockIndices &row_indices, const BlockIndices &col_indices)
 
size_type BlockDynamicSparsityPattern::column_number (const size_type row, const unsigned int index) const
 
static ::ExceptionBaseBlockVector< Number >::ExcIteratorRangeDoesNotMatchVectorSize ()
 
template<typename Matrix >
static void internal::LinearOperatorImplementation::ReinitHelper< BlockVector< number > >::reinit_range_vector (const Matrix &matrix, BlockVector< number > &v, bool omit_zeroing_entries)
 
template<typename Matrix >
static void internal::LinearOperatorImplementation::ReinitHelper< BlockVector< number > >::reinit_domain_vector (const Matrix &matrix, BlockVector< number > &v, bool omit_zeroing_entries)
 
static ::ExceptionBaseinternal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::ExcPointerToDifferentVectors ()
 
void internal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::move_forward ()
 
void internal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::move_backward ()
 
 BlockVectorBase< VectorType >::BlockVectorBase ()=default
 
 BlockVectorBase< VectorType >::BlockVectorBase (const BlockVectorBase &)=default
 
 BlockVectorBase< VectorType >::BlockVectorBase (BlockVectorBase &&) noexcept=default
 
void BlockVectorBase< VectorType >::collect_sizes ()
 
void BlockVectorBase< VectorType >::compress (::VectorOperation::values operation)
 
BlockTypeBlockVectorBase< VectorType >::block (const unsigned int i)
 
const BlockTypeBlockVectorBase< VectorType >::block (const unsigned int i) const
 
const BlockIndicesBlockVectorBase< VectorType >::get_block_indices () const
 
unsigned int BlockVectorBase< VectorType >::n_blocks () const
 
std::size_t BlockVectorBase< VectorType >::size () const
 
std::size_t BlockVectorBase< VectorType >::locally_owned_size () const
 
IndexSet BlockVectorBase< VectorType >::locally_owned_elements () const
 
iterator BlockVectorBase< VectorType >::begin ()
 
const_iterator BlockVectorBase< VectorType >::begin () const
 
iterator BlockVectorBase< VectorType >::end ()
 
const_iterator BlockVectorBase< VectorType >::end () const
 
value_type BlockVectorBase< VectorType >::operator() (const size_type i) const
 
reference BlockVectorBase< VectorType >::operator() (const size_type i)
 
value_type BlockVectorBase< VectorType >::operator[] (const size_type i) const
 
reference BlockVectorBase< VectorType >::operator[] (const size_type i)
 
template<typename OtherNumber >
void BlockVectorBase< VectorType >::extract_subvector_to (const std::vector< size_type > &indices, std::vector< OtherNumber > &values) const
 
template<typename ForwardIterator , typename OutputIterator >
void BlockVectorBase< VectorType >::extract_subvector_to (ForwardIterator indices_begin, const ForwardIterator indices_end, OutputIterator values_begin) const
 
BlockVectorBaseBlockVectorBase< VectorType >::operator= (const value_type s)
 
BlockVectorBaseBlockVectorBase< VectorType >::operator= (const BlockVectorBase &V)
 
BlockVectorBaseBlockVectorBase< VectorType >::operator= (BlockVectorBase &&)=default
 
template<class VectorType2 >
BlockVectorBaseBlockVectorBase< VectorType >::operator= (const BlockVectorBase< VectorType2 > &V)
 
BlockVectorBaseBlockVectorBase< VectorType >::operator= (const VectorType &v)
 
template<class VectorType2 >
bool BlockVectorBase< VectorType >::operator== (const BlockVectorBase< VectorType2 > &v) const
 
value_type BlockVectorBase< VectorType >::operator* (const BlockVectorBase &V) const
 
real_type BlockVectorBase< VectorType >::norm_sqr () const
 
value_type BlockVectorBase< VectorType >::mean_value () const
 
real_type BlockVectorBase< VectorType >::l1_norm () const
 
real_type BlockVectorBase< VectorType >::l2_norm () const
 
real_type BlockVectorBase< VectorType >::linfty_norm () const
 
value_type BlockVectorBase< VectorType >::add_and_dot (const value_type a, const BlockVectorBase &V, const BlockVectorBase &W)
 
bool BlockVectorBase< VectorType >::in_local_range (const size_type global_index) const
 
bool BlockVectorBase< VectorType >::all_zero () const
 
bool BlockVectorBase< VectorType >::is_non_negative () const
 
BlockVectorBaseBlockVectorBase< VectorType >::operator+= (const BlockVectorBase &V)
 
BlockVectorBaseBlockVectorBase< VectorType >::operator-= (const BlockVectorBase &V)
 
template<typename Number >
void BlockVectorBase< VectorType >::add (const std::vector< size_type > &indices, const std::vector< Number > &values)
 
template<typename Number >
void BlockVectorBase< VectorType >::add (const std::vector< size_type > &indices, const Vector< Number > &values)
 
template<typename Number >
void BlockVectorBase< VectorType >::add (const size_type n_elements, const size_type *indices, const Number *values)
 
void BlockVectorBase< VectorType >::add (const value_type s)
 
void BlockVectorBase< VectorType >::add (const value_type a, const BlockVectorBase &V)
 
void BlockVectorBase< VectorType >::add (const value_type a, const BlockVectorBase &V, const value_type b, const BlockVectorBase &W)
 
void BlockVectorBase< VectorType >::sadd (const value_type s, const BlockVectorBase &V)
 
void BlockVectorBase< VectorType >::sadd (const value_type s, const value_type a, const BlockVectorBase &V)
 
void BlockVectorBase< VectorType >::sadd (const value_type s, const value_type a, const BlockVectorBase &V, const value_type b, const BlockVectorBase &W)
 
void BlockVectorBase< VectorType >::sadd (const value_type s, const value_type a, const BlockVectorBase &V, const value_type b, const BlockVectorBase &W, const value_type c, const BlockVectorBase &X)
 
BlockVectorBaseBlockVectorBase< VectorType >::operator*= (const value_type factor)
 
BlockVectorBaseBlockVectorBase< VectorType >::operator/= (const value_type factor)
 
template<class BlockVector2 >
void BlockVectorBase< VectorType >::scale (const BlockVector2 &v)
 
template<class BlockVector2 >
void BlockVectorBase< VectorType >::equ (const value_type a, const BlockVector2 &V)
 
void BlockVectorBase< VectorType >::update_ghost_values () const
 
std::size_t BlockVectorBase< VectorType >::memory_consumption () const
 
static ::ExceptionBaseChunkSparsityPattern::ExcInvalidNumber (size_type arg1)
 
static ::ExceptionBaseChunkSparsityPattern::ExcInvalidIndex (size_type arg1, size_type arg2)
 
static ::ExceptionBaseChunkSparsityPattern::ExcNotEnoughSpace (size_type arg1, size_type arg2)
 
static ::ExceptionBaseChunkSparsityPattern::ExcNotCompressed ()
 
static ::ExceptionBaseChunkSparsityPattern::ExcMatrixIsCompressed ()
 
static ::ExceptionBaseChunkSparsityPattern::ExcEmptyObject ()
 
static ::ExceptionBaseChunkSparsityPattern::ExcIteratorRange (size_type arg1, size_type arg2)
 
static ::ExceptionBaseChunkSparsityPattern::ExcMETISNotInstalled ()
 
static ::ExceptionBaseChunkSparsityPattern::ExcInvalidNumberOfPartitions (size_type arg1)
 
static ::ExceptionBaseChunkSparsityPattern::ExcInvalidArraySize (size_type arg1, size_type arg2)
 
static ::ExceptionBaseLinearAlgebra::CUDAWrappers::Vector< Number >::ExcVectorTypeNotCompatible ()
 
static ::ExceptionBaseDynamicSparsityPatternIterators::Accessor::DummyAccessor ()
 
static ::ExceptionBaseLACExceptions::ExcNotQuadratic ()
 
static ::ExceptionBaseLACExceptions::ExcSingular ()
 
static ::ExceptionBaseLACExceptions::ExcDifferentBlockIndices ()
 
static ::ExceptionBaseLACExceptions::ExcNeedsSparsityPattern ()
 
static ::ExceptionBaseLACExceptions::ExcTrilinosError (int arg1)
 
static ::ExceptionBaseLinearAlgebra::Vector< Number >::ExcVectorTypeNotCompatible ()
 
static ::ExceptionBaseLAPACKSupport::ExcErrorCode (std::string arg1, types::blas_int arg2)
 
static ::ExceptionBaseLAPACKSupport::ExcState (State arg1)
 
static ::ExceptionBaseLAPACKSupport::ExcProperty (Property arg1)
 
static ::ExceptionBaseLAPACKSupport::ExcMissing (std::string arg1)
 
static ::ExceptionBaseMatrixBlock< MatrixType >::ExcBlockIndexMismatch (size_type arg1, size_type arg2)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcConvergedEigenvectors (int arg1, int arg2)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcInvalidNumberofEigenvalues (int arg1, int arg2)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcInvalidEigenvectorSize (int arg1, int arg2)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcInvalidEigenvectorSizeNonsymmetric (int arg1, int arg2)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcInvalidEigenvalueSize (int arg1, int arg2)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcInvalidNumberofArnoldiVectors (int arg1, int arg2)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcSmallNumberofArnoldiVectors (int arg1, int arg2)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcIdo (int arg1)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcMode (int arg1)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcInfoPdnaupd (int arg1)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcInfoPdneupd (int arg1)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcInfoMaxIt (int arg1)
 
static ::ExceptionBasePArpackSolver< VectorType >::PArpackExcNoShifts (int arg1)
 
static ::ExceptionBasePETScWrappers::MPI::BlockVector::ExcIteratorRangeDoesNotMatchVectorSize ()
 
static ::ExceptionBasePETScWrappers::MPI::BlockVector::ExcNonMatchingBlockVectors ()
 
static ::ExceptionBasePETScWrappers::MatrixIterators::const_iterator::Accessor::ExcBeyondEndOfMatrix ()
 
static ::ExceptionBasePETScWrappers::MatrixIterators::const_iterator::Accessor::ExcAccessToNonlocalRow (int arg1, int arg2, int arg3)
 
static ::ExceptionBasePETScWrappers::MatrixIterators::const_iterator::ExcInvalidIndexWithinRow (int arg1, int arg2)
 
static ::ExceptionBasePETScWrappers::MatrixBase::ExcSourceEqualsDestination ()
 
static ::ExceptionBasePETScWrappers::MatrixBase::ExcWrongMode (int arg1, int arg2)
 
static ::ExceptionBasePETScWrappers::MPI::SparseMatrix::ExcLocalRowsTooLarge (int arg1, int arg2)
 
PetscScalar PETScWrappers::MPI::SparseMatrix::matrix_norm_square (const Vector &v) const
 
PetscScalar PETScWrappers::MPI::SparseMatrix::matrix_scalar_product (const Vector &u, const Vector &v) const
 
IndexSet PETScWrappers::MPI::SparseMatrix::locally_owned_domain_indices () const
 
IndexSet PETScWrappers::MPI::SparseMatrix::locally_owned_range_indices () const
 
void PETScWrappers::MPI::SparseMatrix::mmult (SparseMatrix &C, const SparseMatrix &B, const MPI::Vector &V=MPI::Vector()) const
 
void PETScWrappers::MPI::SparseMatrix::Tmmult (SparseMatrix &C, const SparseMatrix &B, const MPI::Vector &V=MPI::Vector()) const
 
template<typename SparsityPatternType >
void PETScWrappers::MPI::SparseMatrix::do_reinit (const SparsityPatternType &sparsity_pattern, const std::vector< size_type > &local_rows_per_process, const std::vector< size_type > &local_columns_per_process, const unsigned int this_process, const bool preset_nonzero_locations)
 
template<typename SparsityPatternType >
void PETScWrappers::MPI::SparseMatrix::do_reinit (const IndexSet &local_rows, const IndexSet &local_columns, const SparsityPatternType &sparsity_pattern)
 
 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)
 
static ::ExceptionBasePreconditionBlock< MatrixType, inverse_type >::ExcWrongBlockSize (int arg1, int arg2)
 
static ::ExceptionBasePreconditionBlock< MatrixType, inverse_type >::ExcInverseMatricesAlreadyExist ()
 
 PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::Accessor (const PreconditionBlockJacobi< MatrixType, inverse_type > *matrix, const size_type row)
 
size_type PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::row () const
 
size_type PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::column () const
 
inverse_type PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::value () const
 
 PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::const_iterator (const PreconditionBlockJacobi< MatrixType, inverse_type > *matrix, const size_type row)
 
const_iteratorPreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator++ ()
 
const AccessorPreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator* () const
 
const AccessorPreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator-> () const
 
bool PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator== (const const_iterator &) const
 
bool PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator!= (const const_iterator &) const
 
bool PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::operator< (const const_iterator &) const
 
template<typename number2 >
void PreconditionBlockJacobi< MatrixType, inverse_type >::vmult (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockJacobi< MatrixType, inverse_type >::Tvmult (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockJacobi< MatrixType, inverse_type >::vmult_add (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockJacobi< MatrixType, inverse_type >::Tvmult_add (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockJacobi< MatrixType, inverse_type >::step (Vector< number2 > &dst, const Vector< number2 > &rhs) const
 
template<typename number2 >
void PreconditionBlockJacobi< MatrixType, inverse_type >::Tstep (Vector< number2 > &dst, const Vector< number2 > &rhs) const
 
const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::begin () const
 
const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::end () const
 
const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::begin (const size_type r) const
 
const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::end (const size_type r) const
 
template<typename number2 >
void PreconditionBlockJacobi< MatrixType, inverse_type >::do_vmult (Vector< number2 > &, const Vector< number2 > &, bool adding) const
 
 PreconditionBlockSOR< MatrixType, inverse_type >::PreconditionBlockSOR ()
 
template<typename number2 >
void PreconditionBlockSOR< MatrixType, inverse_type >::vmult (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockSOR< MatrixType, inverse_type >::vmult_add (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockSOR< MatrixType, inverse_type >::Tvmult (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockSOR< MatrixType, inverse_type >::Tvmult_add (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockSOR< MatrixType, inverse_type >::step (Vector< number2 > &dst, const Vector< number2 > &rhs) const
 
template<typename number2 >
void PreconditionBlockSOR< MatrixType, inverse_type >::Tstep (Vector< number2 > &dst, const Vector< number2 > &rhs) const
 
 PreconditionBlockSOR< MatrixType, inverse_type >::PreconditionBlockSOR (bool store)
 
template<typename number2 >
void PreconditionBlockSOR< MatrixType, inverse_type >::forward (Vector< number2 > &, const Vector< number2 > &, const bool transpose_diagonal, const bool adding) const
 
template<typename number2 >
void PreconditionBlockSOR< MatrixType, inverse_type >::backward (Vector< number2 > &, const Vector< number2 > &, const bool transpose_diagonal, const bool adding) const
 
 PreconditionBlockSSOR< MatrixType, inverse_type >::PreconditionBlockSSOR ()
 
template<typename number2 >
void PreconditionBlockSSOR< MatrixType, inverse_type >::vmult (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockSSOR< MatrixType, inverse_type >::Tvmult (Vector< number2 > &, const Vector< number2 > &) const
 
template<typename number2 >
void PreconditionBlockSSOR< MatrixType, inverse_type >::step (Vector< number2 > &dst, const Vector< number2 > &rhs) const
 
template<typename number2 >
void PreconditionBlockSSOR< MatrixType, inverse_type >::Tstep (Vector< number2 > &dst, const Vector< number2 > &rhs) const
 
static ::ExceptionBasePreconditionBlockBase< number >::ExcDiagonalsNotStored ()
 
static ::ExceptionBasePreconditionBlockBase< number >::ExcInverseNotAvailable ()
 
static ::ExceptionBasePreconditionSelector< MatrixType, VectorType >::ExcNoMatrixGivenToUse ()
 
static ::ExceptionBaseSLEPcWrappers::SolverBase::ExcSLEPcWrappersUsageError ()
 
static ::ExceptionBaseSLEPcWrappers::SolverBase::ExcSLEPcError (int arg1)
 
static ::ExceptionBaseSLEPcWrappers::SolverBase::ExcSLEPcEigenvectorConvergenceMismatchError (int arg1, int arg2)
 
static ::ExceptionBaseSolverControl::ExcHistoryDataRequired ()
 
static ::ExceptionBaseSolverGMRES< VectorType >::ExcTooFewTmpVectors (int arg1)
 
static ::ExceptionBaseSolverMinRes< VectorType >::ExcPreconditionerNotDefinite ()
 
virtual double SolverMinRes< VectorType >::criterion ()
 
virtual void SolverMinRes< VectorType >::print_vectors (const unsigned int step, const VectorType &x, const VectorType &r, const VectorType &d) const
 
static ::ExceptionBaseSolverSelector< VectorType >::ExcSolverDoesNotExist (std::string arg1)
 
 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)
 
static ::ExceptionBaseSparseLUDecomposition< number >::ExcInvalidStrengthening (double arg1)
 
template<typename somenumber >
void SparseLUDecomposition< number >::copy_from (const SparseMatrix< somenumber > &matrix)
 
virtual void SparseLUDecomposition< number >::strengthen_diagonal_impl ()
 
virtual number SparseLUDecomposition< number >::get_strengthen_diagonal (const number rowsum, const size_type row) const
 
void SparseLUDecomposition< number >::prebuild_lower_bound ()
 
static ::ExceptionBaseSparseDirectUMFPACK::ExcUMFPACKError (std::string arg1, int arg2)
 
static ::ExceptionBaseSparseILU< number >::ExcInvalidStrengthening (double arg1)
 
static ::ExceptionBaseSparseILU< number >::ExcZeroPivot (size_type arg1)
 
 SparseMatrixEZ< number >::Entry::Entry ()
 
 SparseMatrixEZ< number >::Entry::Entry (const size_type column, const number &value)
 
 SparseMatrixEZ< number >::RowInfo::RowInfo (const size_type start=Entry::invalid)
 
 SparseMatrixEZ< number >::const_iterator::Accessor::Accessor (const SparseMatrixEZ< number > *matrix, const size_type row, const unsigned short index)
 
size_type SparseMatrixEZ< number >::const_iterator::Accessor::row () const
 
unsigned short SparseMatrixEZ< number >::const_iterator::Accessor::index () const
 
size_type SparseMatrixEZ< number >::const_iterator::Accessor::column () const
 
number SparseMatrixEZ< number >::const_iterator::Accessor::value () const
 
 SparseMatrixEZ< number >::const_iterator::const_iterator (const SparseMatrixEZ< number > *matrix, const size_type row, const unsigned short index)
 
const_iteratorSparseMatrixEZ< number >::const_iterator::operator++ ()
 
const AccessorSparseMatrixEZ< number >::const_iterator::operator* () const
 
const AccessorSparseMatrixEZ< number >::const_iterator::operator-> () const
 
bool SparseMatrixEZ< number >::const_iterator::operator== (const const_iterator &) const
 
bool SparseMatrixEZ< number >::const_iterator::operator!= (const const_iterator &) const
 
bool SparseMatrixEZ< number >::const_iterator::operator< (const const_iterator &) const
 
static ::ExceptionBaseSparseMIC< number >::ExcStrengthenDiagonalTooSmall ()
 
static ::ExceptionBaseSparseMIC< number >::ExcInvalidStrengthening (double arg1)
 
static ::ExceptionBaseSparseMIC< number >::ExcDecompositionNotStable (int arg1, double arg2)
 
number SparseMIC< number >::get_rowsum (const size_type row) const
 
static ::ExceptionBaseSparsityPatternIterators::Accessor::DummyAccessor ()
 
static ::ExceptionBaseSparsityPatternBase::ExcNotCompressed ()
 
static ::ExceptionBaseSparsityPatternBase::ExcNotEnoughSpace (int arg1, int arg2)
 
static ::ExceptionBaseSparsityPatternBase::ExcMatrixIsCompressed ()
 
static ::ExceptionBaseSparsityPattern::ExcIteratorRange (int arg1, int arg2)
 
static ::ExceptionBaseSparsityPattern::ExcInvalidNumberOfPartitions (int arg1)
 
static ::ExceptionBaseSparsityTools::ExcMETISNotInstalled ()
 
static ::ExceptionBaseSparsityTools::ExcInvalidNumberOfPartitions (int arg1)
 
static ::ExceptionBaseSparsityTools::ExcMETISError (int arg1)
 
static ::ExceptionBaseSparsityTools::ExcInvalidArraySize (int arg1, int arg2)
 
static ::ExceptionBaseSparsityTools::ExcZOLTANNotInstalled ()
 
static ::ExceptionBaseTrilinosWrappers::BlockSparseMatrix::ExcIncompatibleRowNumbers (int arg1, int arg2, int arg3, int arg4)
 
static ::ExceptionBaseTrilinosWrappers::BlockSparseMatrix::ExcIncompatibleColNumbers (int arg1, int arg2, int arg3, int arg4)
 
static ::ExceptionBaseLinearAlgebra::EpetraWrappers::Vector::ExcDifferentParallelPartitioning ()
 
static ::ExceptionBaseLinearAlgebra::EpetraWrappers::Vector::ExcVectorTypeNotCompatible ()
 
static ::ExceptionBaseLinearAlgebra::EpetraWrappers::Vector::ExcTrilinosError (int arg1)
 
static ::ExceptionBaseTrilinosWrappers::MPI::BlockVector::ExcIteratorRangeDoesNotMatchVectorSize ()
 
static ::ExceptionBaseTrilinosWrappers::MPI::BlockVector::ExcNonMatchingBlockVectors ()
 
static ::ExceptionBaseTrilinosWrappers::SolverBase::ExcTrilinosError (int arg1)
 
static ::ExceptionBaseTrilinosWrappers::SolverDirect::ExcTrilinosError (int arg1)
 
static ::ExceptionBaseTrilinosWrappers::SparseMatrixIterators::ExcBeyondEndOfMatrix ()
 
static ::ExceptionBaseTrilinosWrappers::SparseMatrixIterators::ExcAccessToNonlocalRow (std::size_t arg1, std::size_t arg2, std::size_t arg3)
 
static ::ExceptionBaseTrilinosWrappers::SparseMatrixIterators::Iterator< Constness >::ExcInvalidIndexWithinRow (size_type arg1, size_type arg2)
 
static ::ExceptionBaseTrilinosWrappers::SparseMatrix::ExcAccessToNonlocalRow (std::size_t arg1)
 
static ::ExceptionBaseTrilinosWrappers::SparsityPatternIterators::Accessor::ExcBeyondEndOfSparsityPattern ()
 
static ::ExceptionBaseTrilinosWrappers::SparsityPatternIterators::Accessor::ExcAccessToNonlocalRow (size_type arg1, size_type arg2, size_type arg3)
 
static ::ExceptionBaseTrilinosWrappers::SparsityPatternIterators::Iterator::ExcInvalidIndexWithinRow (size_type arg1, size_type arg2)
 
static ::ExceptionBaseLinearAlgebra::TpetraWrappers::Vector< Number >::ExcDifferentParallelPartitioning ()
 
static ::ExceptionBaseLinearAlgebra::TpetraWrappers::Vector< Number >::ExcVectorTypeNotCompatible ()
 
static ::ExceptionBaseLinearAlgebra::TpetraWrappers::Vector< Number >::ExcTrilinosError (int arg1)
 
static ::ExceptionBaseVectorMemory< VectorType >::ExcNotAllocatedHere ()
 
 VectorMemory< VectorType >::Pointer::Pointer ()=default
 
 VectorMemory< VectorType >::Pointer::Pointer (Pointer &&p) noexcept=default
 
PointerVectorMemory< VectorType >::Pointer::operator= (Pointer &&p) noexcept=default
 
 VectorMemory< VectorType >::Pointer::Pointer (VectorMemory< VectorType > &mem)
 
 VectorMemory< VectorType >::Pointer::~Pointer ()=default
 
virtual VectorType * PrimitiveVectorMemory< VectorType >::alloc () override
 
virtual void PrimitiveVectorMemory< VectorType >::free (const VectorType *const v) override
 
 GrowingVectorMemory< VectorType >::GrowingVectorMemory (const size_type initial_size=0, const bool log_statistics=false)
 
virtual GrowingVectorMemory< VectorType >::~GrowingVectorMemory () override
 
virtual VectorType * GrowingVectorMemory< VectorType >::alloc () override
 
virtual void GrowingVectorMemory< VectorType >::free (const VectorType *const) override
 
static void GrowingVectorMemory< VectorType >::release_unused_memory ()
 
virtual std::size_t GrowingVectorMemory< VectorType >::memory_consumption () const
 
 GrowingVectorMemory< VectorType >::Pool::Pool ()
 
 GrowingVectorMemory< VectorType >::Pool::~Pool ()
 
void GrowingVectorMemory< VectorType >::Pool::initialize (const size_type size)
 
static PoolGrowingVectorMemory< VectorType >::get_pool ()
 
void internal::GrowingVectorMemoryImplementation::release_all_unused_memory ()
 
static ::ExceptionBaseinternal::ExcAccessToUninitializedField ()
 
static ::ExceptionBaseinternal::ExcMatrixFreeAccessToUninitializedMappingField (std::string arg1)
 
static ::ExceptionBaseMeshWorker::LocalIntegrator< dim, spacedim, number >::ExcPureFunction ()
 
static ::ExceptionBaseMGTransferPrebuilt< VectorType >::ExcNoProlongation ()
 
static ::ExceptionBaseMGTransferPrebuilt< VectorType >::ExcMatricesNotBuilt ()
 
static ::ExceptionBaseMGTransferBlockBase::ExcMatricesNotBuilt ()
 
static ::ExceptionBaseMGTransferComponentBase::ExcMatricesNotBuilt ()
 
static ::ExceptionBaseMGTransferMatrixFree< dim, Number >::ExcNoProlongation ()
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcInvalidNumberOfSubdivisions (int arg1)
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcNoTriangulationSelected ()
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcNoDoFHandlerSelected ()
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcInvalidVectorSize (int arg1, int arg2, int arg3)
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcInvalidCharacter (std::string arg1, size_t arg2)
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcOldDataStillPresent ()
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcInvalidNumberOfNames (int arg1, int arg2)
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcIncompatibleDatasetNames ()
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcIncompatiblePatchLists ()
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcInvalidVectorDeclaration (int arg1, std::string arg2)
 
static ::ExceptionBaseExceptions::DataOutImplementation::ExcInvalidTensorDeclaration (int arg1, std::string arg2)
 
static ::ExceptionBaseDataOutRotation< dim, spacedim >::ExcRadialVariableHasNegativeValues (double arg1)
 
static ::ExceptionBaseDataOutStack< dim, spacedim >::ExcVectorNotDeclared (std::string arg1)
 
static ::ExceptionBaseDataOutStack< dim, spacedim >::ExcDataNotCleared ()
 
static ::ExceptionBaseDataOutStack< dim, spacedim >::ExcDataAlreadyAdded ()
 
static ::ExceptionBaseDataOutStack< dim, spacedim >::ExcNameAlreadyUsed (std::string arg1)
 
static ::ExceptionBaseDerivativeApproximation::ExcVectorLengthVsNActiveCells (int arg1, int arg2)
 
static ::ExceptionBaseDerivativeApproximation::ExcInsufficientDirections ()
 
static ::ExceptionBaseKellyErrorEstimator< dim, spacedim >::ExcInvalidComponentMask ()
 
static ::ExceptionBaseKellyErrorEstimator< dim, spacedim >::ExcInvalidCoefficient ()
 
static ::ExceptionBaseKellyErrorEstimator< dim, spacedim >::ExcInvalidBoundaryFunction (types::boundary_id arg1, int arg2, int arg3)
 
static ::ExceptionBaseKellyErrorEstimator< dim, spacedim >::ExcIncompatibleNumberOfElements (int arg1, int arg2)
 
static ::ExceptionBaseKellyErrorEstimator< dim, spacedim >::ExcNoSolutions ()
 
static ::ExceptionBaseKellyErrorEstimator< 1, spacedim >::ExcInvalidComponentMask ()
 
static ::ExceptionBaseKellyErrorEstimator< 1, spacedim >::ExcInvalidCoefficient ()
 
static ::ExceptionBaseKellyErrorEstimator< 1, spacedim >::ExcInvalidBoundaryFunction (types::boundary_id arg1, int arg2, int arg3)
 
static ::ExceptionBaseKellyErrorEstimator< 1, spacedim >::ExcIncompatibleNumberOfElements (int arg1, int arg2)
 
static ::ExceptionBaseKellyErrorEstimator< 1, spacedim >::ExcNoSolutions ()
 
static ::ExceptionBaseHistogram::ExcEmptyData ()
 
static ::ExceptionBaseHistogram::ExcIncompatibleArraySize (int arg1, int arg2)
 
static ::ExceptionBaseHistogram::ExcInvalidName (std::string arg1)
 
static ::ExceptionBaseMatrixCreator::ExcComponentMismatch ()
 
static ::ExceptionBaseMatrixTools::ExcBlocksDontMatch ()
 
static ::ExceptionBasePointValueHistory< dim >::ExcNoIndependent ()
 
static ::ExceptionBasePointValueHistory< dim >::ExcDataLostSync ()
 
static ::ExceptionBasePointValueHistory< dim >::ExcDoFHandlerRequired ()
 
static ::ExceptionBasePointValueHistory< dim >::ExcDoFHandlerChanged ()
 
static ::ExceptionBaseSolutionTransfer< dim, VectorType, spacedim >::ExcNotPrepared ()
 
static ::ExceptionBaseSolutionTransfer< dim, VectorType, spacedim >::ExcAlreadyPrepForRef ()
 
static ::ExceptionBaseSolutionTransfer< dim, VectorType, spacedim >::ExcAlreadyPrepForCoarseAndRef ()
 
static ::ExceptionBaseTimeDependent::ExcInvalidPosition ()
 
static ::ExceptionBaseTimeStepBase_Tria_Flags::RefinementFlags< dim >::ExcInvalidValue (double arg1)
 
static ::ExceptionBaseTimeStepBase_Tria_Flags::RefinementData< dim >::ExcInvalidValue (double arg1)
 
static ::ExceptionBaseTimeStepBase_Tria< dim >::ExcGridNotDeleted ()
 
static ::ExceptionBaseVectorTools::ExcPointNotAvailableHere ()
 
template<int dim>
static ::ExceptionBaseOpenCASCADE::ExcPointNotOnManifold (Point< dim > arg1)
 
template<int dim>
static ::ExceptionBaseOpenCASCADE::ExcProjectionFailed (Point< dim > arg1)
 
static ::ExceptionBaseOpenCASCADE::ExcOCCError (IFSelect_ReturnStatus arg1)
 
static ::ExceptionBaseOpenCASCADE::ExcEdgeIsDegenerate ()
 
static ::ExceptionBaseOpenCASCADE::ExcUnsupportedShape ()
 
static ::ExceptionBasePhysics::Notation::Kelvin::ExcNotationExcFullMatrixToTensorRowSize2 (int arg1, int arg2, int arg3)
 
static ::ExceptionBasePhysics::Notation::Kelvin::ExcNotationExcFullMatrixToTensorRowSize3 (int arg1, int arg2, int arg3, int arg4)
 
static ::ExceptionBasePhysics::Notation::Kelvin::ExcNotationExcFullMatrixToTensorColSize2 (int arg1, int arg2, int arg3)
 
static ::ExceptionBasePhysics::Notation::Kelvin::ExcNotationExcFullMatrixToTensorColSize3 (int arg1, int arg2, int arg3, int arg4)
 
static ::ExceptionBaseSUNDIALS::KINSOL< VectorType >::ExcKINSOLError (int arg1)
 
static ::ExceptionBaseSUNDIALS::KINSOL< VectorType >::ExcFunctionNotProvided (std::string arg1)
 
static ::ExceptionBaseGeometricUtilities::Coordinates::NegativeRadius (double arg1)
 
static ::ExceptionBaseGeometricUtilities::Coordinates::SphericalAzimuth (double arg1)
 
static ::ExceptionBaseGeometricUtilities::Coordinates::SphericalPolar (double arg1)
 
static ::ExceptionBaseUtilities::ExcInvalidNumber2StringConversersion (unsigned int arg1, unsigned int arg2)
 
static ::ExceptionBaseUtilities::ExcInvalidNumber (unsigned int arg1)
 
static ::ExceptionBaseUtilities::ExcCantConvertString (std::string arg1)
 
template<typename Number >
static ::ExceptionBaseExcNonMatchingElementsSetDofValuesByInterpolation (Number arg1, Number arg2)
 
static ::ExceptionBaseExcCellNotCartesian ()
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcGridHasInvalidCell (int arg1)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcInternalErrorOnCell (int arg1)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcCellHasNegativeMeasure (int arg1)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcInvalidVertexIndex (int arg1, int arg2, int arg3)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcLineInexistant (int arg1, int arg2)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcQuadInexistant (int arg1, int arg2, int arg3, int arg4)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcInteriorLineCantBeBoundary (int arg1, int arg2, types::boundary_id arg3)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcInteriorQuadCantBeBoundary (int arg1, int arg2, int arg3, int arg4, types::boundary_id arg5)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcMultiplySetLineInfoOfLine (int arg1, int arg2)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcInconsistentLineInfoOfLine (int arg1, int arg2, std::string arg3)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcInconsistentQuadInfoOfQuad (int arg1, int arg2, int arg3, int arg4, std::string arg5)
 
static ::ExceptionBaseinternal::TriangulationImplementation::ExcMemoryInexact (int arg1, int arg2)
 
static ::ExceptionBaseNonMatching::internal::MeshClassifierImplementation::ExcReclassifyNotCalled ()
 
static ::ExceptionBaseNonMatching::internal::MeshClassifierImplementation::ExcTriangulationMismatch ()
 
static ::ExceptionBaseNonMatching::internal::DiscreteQuadratureGeneratorImplementation::ExcCellNotSet ()
 
static ::ExceptionBaseNonMatching::internal::DiscreteQuadratureGeneratorImplementation::ExcReferenceCellNotHypercube ()
 
static ::ExceptionBaseSUNDIALS::ExcSundialsSolverError (int arg1)
 
template<class... PatternTypes>
 Patterns::Tuple::Tuple (const PatternTypes &...ps)
 
template<typename T >
 internal::TableEntry::TableEntry (const T &t)
 
template<typename T >
internal::TableEntry::get () const
 
template<class Archive >
void internal::TableEntry::save (Archive &ar, const unsigned int version) const
 
template<class Archive >
void internal::TableEntry::load (Archive &ar, const unsigned int version)
 

Variables

static const unsigned int DataOutBase::Patch< dim, spacedim >::space_dim = spacedim
 
Point< spacedim > DataOutBase::Patch< dim, spacedim >::vertices [GeometryInfo< dim >::vertices_per_cell]
 
std::array< unsigned int, GeometryInfo< dim >::faces_per_cell > DataOutBase::Patch< dim, spacedim >::neighbors
 
unsigned int DataOutBase::Patch< dim, spacedim >::patch_index
 
unsigned int DataOutBase::Patch< dim, spacedim >::n_subdivisions
 
Table< 2, float > DataOutBase::Patch< dim, spacedim >::data
 
bool DataOutBase::Patch< dim, spacedim >::points_are_available
 
ReferenceCell DataOutBase::Patch< dim, spacedim >::reference_cell
 
static const unsigned int DataOutBase::Patch< dim, spacedim >::no_neighbor = numbers::invalid_unsigned_int
 
static const unsigned int DataOutBase::Patch< 0, spacedim >::space_dim = spacedim
 
Point< spacedim > DataOutBase::Patch< 0, spacedim >::vertices [1]
 
static unsigned int DataOutBase::Patch< 0, spacedim >::neighbors [1]
 
unsigned int DataOutBase::Patch< 0, spacedim >::patch_index
 
static const unsigned int DataOutBase::Patch< 0, spacedim >::n_subdivisions = 1
 
Table< 2, float > DataOutBase::Patch< 0, spacedim >::data
 
bool DataOutBase::Patch< 0, spacedim >::points_are_available
 
static const ReferenceCell DataOutBase::Patch< 0, spacedim >::reference_cell
 
static const unsigned int DataOutBase::Patch< 0, spacedim >::no_neighbor = numbers::invalid_unsigned_int
 
bool DataOutBase::DXFlags::write_neighbors
 
bool DataOutBase::DXFlags::int_binary
 
bool DataOutBase::DXFlags::coordinates_binary
 
bool DataOutBase::DXFlags::data_binary
 
bool DataOutBase::DXFlags::data_double
 
bool DataOutBase::UcdFlags::write_preamble
 
std::vector< std::string > DataOutBase::GnuplotFlags::space_dimension_labels
 
bool DataOutBase::PovrayFlags::smooth
 
bool DataOutBase::PovrayFlags::bicubic_patch
 
bool DataOutBase::PovrayFlags::external_data
 
unsigned int DataOutBase::EpsFlags::height_vector
 
unsigned int DataOutBase::EpsFlags::color_vector
 
SizeType DataOutBase::EpsFlags::size_type
 
unsigned int DataOutBase::EpsFlags::size
 
double DataOutBase::EpsFlags::line_width
 
double DataOutBase::EpsFlags::azimut_angle
 
double DataOutBase::EpsFlags::turn_angle
 
double DataOutBase::EpsFlags::z_scaling
 
bool DataOutBase::EpsFlags::draw_mesh
 
bool DataOutBase::EpsFlags::draw_cells
 
bool DataOutBase::EpsFlags::shade_cells
 
float DataOutBase::EpsFlags::RgbValues::red
 
float DataOutBase::EpsFlags::RgbValues::green
 
float DataOutBase::EpsFlags::RgbValues::blue
 
ColorFunction DataOutBase::EpsFlags::color_function
 
const char * DataOutBase::TecplotFlags::zone_name
 
double DataOutBase::TecplotFlags::solution_time
 
double DataOutBase::VtkFlags::time
 
unsigned int DataOutBase::VtkFlags::cycle
 
bool DataOutBase::VtkFlags::print_date_and_time
 
ZlibCompressionLevel DataOutBase::VtkFlags::compression_level
 
bool DataOutBase::VtkFlags::write_higher_order_cells
 
std::map< std::string, std::string > DataOutBase::VtkFlags::physical_units
 
unsigned int DataOutBase::SvgFlags::height
 
unsigned int DataOutBase::SvgFlags::width
 
unsigned int DataOutBase::SvgFlags::height_vector
 
int DataOutBase::SvgFlags::azimuth_angle
 
int DataOutBase::SvgFlags::polar_angle
 
unsigned int DataOutBase::SvgFlags::line_thickness
 
bool DataOutBase::SvgFlags::margin
 
bool DataOutBase::SvgFlags::draw_colorbar
 
static const unsigned int DataOutBase::Deal_II_IntermediateFlags::format_version = 4
 
bool DataOutBase::DataOutFilterFlags::filter_duplicate_vertices
 
bool DataOutBase::DataOutFilterFlags::xdmf_hdf5_output
 
DataOutBase::DataOutFilterFlags DataOutBase::DataOutFilter::flags
 
unsigned int DataOutBase::DataOutFilter::node_dim
 
unsigned int DataOutBase::DataOutFilter::num_cells
 
Map3DPoint DataOutBase::DataOutFilter::existing_points
 
std::map< unsigned int, unsigned int > DataOutBase::DataOutFilter::filtered_points
 
std::map< unsigned int, unsigned int > DataOutBase::DataOutFilter::filtered_cells
 
std::vector< std::string > DataOutBase::DataOutFilter::data_set_names
 
std::vector< unsigned int > DataOutBase::DataOutFilter::data_set_dims
 
std::vector< std::vector< double > > DataOutBase::DataOutFilter::data_sets
 
unsigned int DataOutInterface< dim, spacedim >::default_subdivisions
 
DataOutBase::OutputFormat DataOutInterface< dim, spacedim >::default_fmt
 
DataOutBase::DXFlags DataOutInterface< dim, spacedim >::dx_flags
 
DataOutBase::UcdFlags DataOutInterface< dim, spacedim >::ucd_flags
 
DataOutBase::GnuplotFlags DataOutInterface< dim, spacedim >::gnuplot_flags
 
DataOutBase::PovrayFlags DataOutInterface< dim, spacedim >::povray_flags
 
DataOutBase::EpsFlags DataOutInterface< dim, spacedim >::eps_flags
 
DataOutBase::GmvFlags DataOutInterface< dim, spacedim >::gmv_flags
 
DataOutBase::TecplotFlags DataOutInterface< dim, spacedim >::tecplot_flags
 
DataOutBase::VtkFlags DataOutInterface< dim, spacedim >::vtk_flags
 
DataOutBase::SvgFlags DataOutInterface< dim, spacedim >::svg_flags
 
DataOutBase::Deal_II_IntermediateFlags DataOutInterface< dim, spacedim >::deal_II_intermediate_flags
 
std::vector<::DataOutBase::Patch< dim, spacedim > > DataOutReader< dim, spacedim >::patches
 
std::vector< std::string > DataOutReader< dim, spacedim >::dataset_names
 
std::vector< std::tuple< unsigned int, unsigned int, std::string, DataComponentInterpretation::DataComponentInterpretation > > DataOutReader< dim, spacedim >::nonscalar_data_ranges
 
bool XDMFEntry::valid
 
std::string XDMFEntry::h5_sol_filename
 
std::string XDMFEntry::h5_mesh_filename
 
double XDMFEntry::entry_time
 
std::uint64_t XDMFEntry::num_nodes
 
std::uint64_t XDMFEntry::num_cells
 
unsigned int XDMFEntry::dimension
 
unsigned int XDMFEntry::space_dimension
 
std::map< std::string, unsigned int > XDMFEntry::attribute_dims
 
std::vector< doubleinternal::FunctionParser::ParserData::vars
 
std::vector< std::unique_ptr< muParserBase > > internal::FunctionParser::ParserData::parsers
 
std::vector< std::string > internal::FunctionParser::ParserImplementation< dim, Number >::expressions
 
Threads::ThreadLocalStorage< internal::FunctionParser::ParserDatainternal::FunctionParser::ParserImplementation< dim, Number >::parser_data
 
std::map< std::string, doubleinternal::FunctionParser::ParserImplementation< dim, Number >::constants
 
std::vector< std::string > internal::FunctionParser::ParserImplementation< dim, Number >::var_names
 
bool internal::FunctionParser::ParserImplementation< dim, Number >::initialized
 
unsigned int internal::FunctionParser::ParserImplementation< dim, Number >::n_vars
 
static const char ParameterHandler::path_separator = '.'
 
std::vector< std::string > ParameterHandler::subsection_path
 
std::unique_ptr< boost::property_tree::ptree > ParameterHandler::entries
 
std::map< std::string, std::pair< bool, bool > > ParameterHandler::entries_set_status
 
std::vector< std::unique_ptr< const Patterns::PatternBase > > ParameterHandler::patterns
 
std::vector< std::function< void(const std::string &)> > ParameterHandler::actions
 
std::vector< std::string > MultipleParameterLoop::Entry::subsection_path
 
std::string MultipleParameterLoop::Entry::entry_name
 
std::string MultipleParameterLoop::Entry::entry_value
 
std::vector< std::string > MultipleParameterLoop::Entry::different_values
 
MultipleEntryType MultipleParameterLoop::Entry::type
 
std::vector< EntryMultipleParameterLoop::multiple_choices
 
unsigned int MultipleParameterLoop::n_branches
 
std::unique_ptr< PatternBasePatterns::List::pattern
 
const unsigned int Patterns::List::min_elements
 
const unsigned int Patterns::List::max_elements
 
const std::string Patterns::List::separator
 
static const char * Patterns::List::description_init = "[List"
 
static const unsigned int Patterns::Map::max_int_value
 
std::unique_ptr< PatternBasePatterns::Map::key_pattern
 
std::unique_ptr< PatternBasePatterns::Map::value_pattern
 
const unsigned int Patterns::Map::min_elements
 
const unsigned int Patterns::Map::max_elements
 
const std::string Patterns::Map::separator
 
const std::string Patterns::Map::key_value_separator
 
static const char * Patterns::Map::description_init = "[Map"
 
std::vector< std::unique_ptr< PatternBase > > Patterns::Tuple::patterns
 
const std::string Patterns::Tuple::separator
 
static const char * Patterns::Tuple::description_init = "[Tuple"
 
std::string Patterns::MultipleSelection::sequence
 
static const char * Patterns::MultipleSelection::description_init = "[MultipleSelection"
 
static const char * Patterns::Bool::description_init = "[Bool"
 
static const char * Patterns::Anything::description_init = "[Anything"
 
FileType Patterns::FileName::file_type
 
static const char * Patterns::FileName::description_init = "[FileName"
 
static const char * Patterns::DirectoryName::description_init = "[DirectoryName"
 
static constexpr int Patterns::Tools::internal::RankInfo< T, Enable >::list_rank = 0
 
static constexpr int Patterns::Tools::internal::RankInfo< T, Enable >::map_rank = 0
 
constexpr std::array< const char *, 4 > Patterns::Tools::internal::default_list_separator
 
constexpr std::array< const char *, 4 > Patterns::Tools::internal::default_map_separator
 
static constexpr bool const Patterns::Tools::is_list_compatible< T >::value
 
static constexpr bool const Patterns::Tools::is_map_compatible< T >::value
 
static constexpr int Patterns::Tools::internal::RankInfo< T, typename std::enable_if< is_list_compatible< T >::value >::type >::list_rank
 
static constexpr int Patterns::Tools::internal::RankInfo< T, typename std::enable_if< is_list_compatible< T >::value >::type >::map_rank
 
static constexpr int Patterns::Tools::internal::RankInfo< T, typename std::enable_if< is_map_compatible< T >::value >::type >::list_rank
 
static constexpr int Patterns::Tools::internal::RankInfo< T, typename std::enable_if< is_map_compatible< T >::value >::type >::map_rank
 
static constexpr int Patterns::Tools::internal::RankInfo< Tensor< rank, dim, Number > >::list_rank = rank + RankInfo<Number>::list_rank
 
static constexpr int Patterns::Tools::internal::RankInfo< Tensor< rank, dim, Number > >::map_rank = RankInfo<Number>::map_rank
 
static constexpr int Patterns::Tools::internal::RankInfo< std::complex< Number > >::list_rank = RankInfo<Number>::list_rank + 1
 
static constexpr int Patterns::Tools::internal::RankInfo< std::complex< Number > >::map_rank = RankInfo<Number>::map_rank
 
static constexpr int Patterns::Tools::internal::RankInfo< std::unique_ptr< FunctionParser< dim > > >::list_rank = 1
 
static constexpr int Patterns::Tools::internal::RankInfo< std::unique_ptr< FunctionParser< dim > > >::map_rank = 0
 
static constexpr int Patterns::Tools::internal::RankInfo< ComponentMask >::list_rank = 1
 
static constexpr int Patterns::Tools::internal::RankInfo< ComponentMask >::map_rank = 0
 
static constexpr int Patterns::Tools::internal::RankInfo< std::pair< Key, Value > >::list_rank
 
static constexpr int Patterns::Tools::internal::RankInfo< std::pair< Key, Value > >::map_rank
 
static constexpr int Patterns::Tools::internal::RankInfo< std::tuple< Types... > >::list_rank = max_list_rank<Types...>()
 
static constexpr int Patterns::Tools::internal::RankInfo< std::tuple< Types... > >::map_rank = max_map_rank<Types...>() + 1
 
static constexpr int Patterns::Tools::internal::RankInfo< std::array< T, N > >::list_rank = RankInfo<T>::list_rank + 1
 
static constexpr int Patterns::Tools::internal::RankInfo< std::array< T, N > >::map_rank = RankInfo<T>::map_rank
 
std::vector< internal::TableEntryTableHandler::Column::entries
 
std::string TableHandler::Column::tex_caption
 
std::string TableHandler::Column::tex_format
 
unsigned int TableHandler::Column::precision
 
bool TableHandler::Column::scientific
 
unsigned int TableHandler::Column::flag
 
unsigned int TableHandler::Column::max_length
 
std::vector< std::string > TableHandler::column_order
 
std::map< std::string, ColumnTableHandler::columns
 
std::map< std::string, std::vector< std::string > > TableHandler::supercolumns
 
std::map< std::string, std::string > TableHandler::tex_supercaptions
 
std::string TableHandler::tex_table_caption
 
std::string TableHandler::tex_table_label
 
bool TableHandler::auto_fill_mode
 
unsigned int TensorFunctionParser< rank, dim, Number >::n_components
 
std::mutex Threads::Task< RT >::TaskData::mutex
 
std::future< RT > Threads::Task< RT >::TaskData::future
 
std::atomic< boolThreads::Task< RT >::TaskData::task_has_finished
 
internal::return_value< RT > Threads::Task< RT >::TaskData::returned_object
 
tbb::task_group Threads::Task< RT >::TaskData::task_group
 
std::shared_ptr< TaskDataThreads::Task< RT >::task_data
 
std::list< Task< RT > > Threads::TaskGroup< RT >::tasks
 
BlockIndices BlockMatrixBase< MatrixType >::row_block_indices
 
BlockIndices BlockMatrixBase< MatrixType >::column_block_indices
 
Table< 2, SmartPointer< BlockType, BlockMatrixBase< MatrixType > > > BlockMatrixBase< MatrixType >::sub_objects
 
std::vector< size_typeBlockMatrixBase< MatrixType >::TemporaryData::counter_within_block
 
std::vector< std::vector< size_type > > BlockMatrixBase< MatrixType >::TemporaryData::column_indices
 
std::vector< std::vector< value_type > > BlockMatrixBase< MatrixType >::TemporaryData::column_values
 
std::mutex BlockMatrixBase< MatrixType >::TemporaryData::mutex
 
TemporaryData BlockMatrixBase< MatrixType >::temporary_data
 
size_type BlockSparsityPatternBase< SparsityPatternType >::rows
 
size_type BlockSparsityPatternBase< SparsityPatternType >::columns
 
Table< 2, SmartPointer< SparsityPatternType, BlockSparsityPatternBase< SparsityPatternType > > > BlockSparsityPatternBase< SparsityPatternType >::sub_objects
 
BlockIndices BlockSparsityPatternBase< SparsityPatternType >::row_indices
 
BlockIndices BlockSparsityPatternBase< SparsityPatternType >::column_indices
 
std::vector< size_typeBlockSparsityPatternBase< SparsityPatternType >::counter_within_block
 
std::vector< std::vector< size_type > > BlockSparsityPatternBase< SparsityPatternType >::block_column_indices
 
BlockVectorinternal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::parent
 
size_type internal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::global_index
 
unsigned int internal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::current_block
 
size_type internal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::index_within_block
 
size_type internal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::next_break_forward
 
size_type internal::BlockVectorIterators::Iterator< BlockVectorType, Constness >::next_break_backward
 
std::vector< VectorType > BlockVectorBase< VectorType >::components
 
BlockIndices BlockVectorBase< VectorType >::block_indices
 
static const bool ChunkSparseMatrix< number >::Traits::zero_addition_can_be_elided = true
 
size_type ChunkSparsityPattern::rows
 
size_type ChunkSparsityPattern::cols
 
size_type ChunkSparsityPattern::chunk_size
 
SparsityPattern ChunkSparsityPattern::sparsity_pattern
 
static const bool PETScWrappers::MPI::SparseMatrix::Traits::zero_addition_can_be_elided = false
 
MPI_Comm PETScWrappers::MPI::SparseMatrix::communicator
 
double PreconditionBlock< MatrixType, inverse_type >::AdditionalData::relaxation
 
size_type PreconditionBlock< MatrixType, inverse_type >::AdditionalData::block_size
 
bool PreconditionBlock< MatrixType, inverse_type >::AdditionalData::invert_diagonal
 
bool PreconditionBlock< MatrixType, inverse_type >::AdditionalData::same_diagonal
 
PreconditionBlockBase< inverse_type >::Inversion PreconditionBlock< MatrixType, inverse_type >::AdditionalData::inversion
 
double PreconditionBlock< MatrixType, inverse_type >::AdditionalData::threshold
 
size_type PreconditionBlock< MatrixType, inverse_type >::blocksize
 
SmartPointer< const MatrixType, PreconditionBlock< MatrixType, inverse_type > > PreconditionBlock< MatrixType, inverse_type >::A
 
double PreconditionBlock< MatrixType, inverse_type >::relaxation
 
std::vector< size_typePreconditionBlock< MatrixType, inverse_type >::permutation
 
std::vector< size_typePreconditionBlock< MatrixType, inverse_type >::inverse_permutation
 
const PreconditionBlockJacobi< MatrixType, inverse_type > * PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::matrix
 
size_type PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::bs
 
size_type PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::a_block
 
FullMatrix< inverse_type >::const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::b_iterator
 
FullMatrix< inverse_type >::const_iterator PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::Accessor::b_end
 
Accessor PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator::accessor
 
std::string PreconditionSelector< MatrixType, VectorType >::preconditioning
 
SmartPointer< const MatrixType, PreconditionSelector< MatrixType, VectorType > > PreconditionSelector< MatrixType, VectorType >::A
 
const VectorType::value_type PreconditionSelector< MatrixType, VectorType >::omega
 
double SolverMinRes< VectorType >::res2
 
double SparseLUDecomposition< number >::AdditionalData::strengthen_diagonal
 
unsigned int SparseLUDecomposition< number >::AdditionalData::extra_off_diagonals
 
bool SparseLUDecomposition< number >::AdditionalData::use_previous_sparsity
 
const SparsityPatternSparseLUDecomposition< number >::AdditionalData::use_this_sparsity
 
double SparseLUDecomposition< number >::strengthen_diagonal
 
std::vector< const size_type * > SparseLUDecomposition< number >::prebuilt_lower_bound
 
SparsityPatternSparseLUDecomposition< number >::own_sparsity
 
static const bool SparseMatrix< number >::Traits::zero_addition_can_be_elided = true
 
size_type SparseMatrixEZ< number >::Entry::column
 
number SparseMatrixEZ< number >::Entry::value
 
static const size_type SparseMatrixEZ< number >::Entry::invalid = numbers::invalid_size_type
 
size_type SparseMatrixEZ< number >::RowInfo::start
 
unsigned short SparseMatrixEZ< number >::RowInfo::length
 
unsigned short SparseMatrixEZ< number >::RowInfo::diagonal
 
static const unsigned short SparseMatrixEZ< number >::RowInfo::invalid_diagonal
 
const SparseMatrixEZ< number > * SparseMatrixEZ< number >::const_iterator::Accessor::matrix
 
size_type SparseMatrixEZ< number >::const_iterator::Accessor::a_row
 
unsigned short SparseMatrixEZ< number >::const_iterator::Accessor::a_index
 
Accessor SparseMatrixEZ< number >::const_iterator::accessor
 
std::vector< number > SparseMIC< number >::diag
 
std::vector< number > SparseMIC< number >::inv_diag
 
std::vector< number > SparseMIC< number >::inner_sums
 
std::vector< entry_type > * GrowingVectorMemory< VectorType >::Pool::data
 
size_type GrowingVectorMemory< VectorType >::total_alloc
 
size_type GrowingVectorMemory< VectorType >::current_alloc
 
bool GrowingVectorMemory< VectorType >::log_statistics
 
static Threads::Mutex GrowingVectorMemory< VectorType >::mutex
 

Friends

class ParameterHandler::MultipleParameterLoop
 
class Threads::Task< RT >::TaskData::Task< RT >
 
template<typename , bool >
class BlockMatrixBase< MatrixType >::BlockMatrixIterators::Accessor
 
template<typename >
class BlockMatrixBase< MatrixType >::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< VectorType >::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 PreconditionBlockJacobi< MatrixType, inverse_type >::Accessor
 
class PreconditionBlockJacobi< MatrixType, inverse_type >::const_iterator
 
class SparseMatrixEZ< number >::const_iterator::Accessor::const_iterator
 

Subscriptor functionality

Classes derived from Subscriptor provide a facility to subscribe to this object. This is mostly used by the SmartPointer class.

using Subscriptor::map_value_type = decltype(counter_map)::value_type
 
using Subscriptor::map_iterator = decltype(counter_map)::iterator
 
std::atomic< unsigned int > Subscriptor::counter
 
std::map< std::string, unsigned int > Subscriptor::counter_map
 
std::vector< std::atomic< bool > * > Subscriptor::validity_pointers
 
const std::type_info * Subscriptor::object_info
 
static std::mutex Subscriptor::mutex
 
static ::ExceptionBaseSubscriptor::ExcInUse (int arg1, std::string arg2, std::string arg3)
 
static ::ExceptionBaseSubscriptor::ExcNoSubscriber (std::string arg1, std::string arg2)
 
template<class Archive >
void Subscriptor::serialize (Archive &ar, const unsigned int version)
 
void Subscriptor::check_no_subscribers () const noexcept
 
void Subscriptor::subscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
void Subscriptor::unsubscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
unsigned int Subscriptor::n_subscriptions () const
 
template<typename StreamType >
void Subscriptor::list_subscribers (StreamType &stream) const
 
void Subscriptor::list_subscribers () const
 

Evaluation / data extraction

using Differentiation::SD::BatchOptimizer< ReturnType >::map_dependent_expression_to_vector_entry_t = std::map< SD::Expression, std::size_t, SD::types::internal::ExpressionKeyLess >
 
enum OptimizerType Differentiation::SD::BatchOptimizer< ReturnType >::method
 
enum OptimizationFlags Differentiation::SD::BatchOptimizer< ReturnType >::flags
 
types::substitution_map Differentiation::SD::BatchOptimizer< ReturnType >::independent_variables_symbols
 
types::symbol_vector Differentiation::SD::BatchOptimizer< ReturnType >::dependent_variables_functions
 
std::vector< ReturnType > Differentiation::SD::BatchOptimizer< ReturnType >::dependent_variables_output
 
map_dependent_expression_to_vector_entry_t Differentiation::SD::BatchOptimizer< ReturnType >::map_dep_expr_vec_entry
 
std::unique_ptr< SymEngine::Visitor > Differentiation::SD::BatchOptimizer< ReturnType >::optimizer
 
bool Differentiation::SD::BatchOptimizer< ReturnType >::ready_for_value_extraction
 
bool Differentiation::SD::BatchOptimizer< ReturnType >::has_been_serialized
 
const std::vector< ReturnType > & Differentiation::SD::BatchOptimizer< ReturnType >::evaluate () const
 
ReturnType Differentiation::SD::BatchOptimizer< ReturnType >::evaluate (const Expression &func) const
 
std::vector< ReturnType > Differentiation::SD::BatchOptimizer< ReturnType >::evaluate (const std::vector< Expression > &funcs) const
 
template<int rank, int dim>
Tensor< rank, dim, ReturnType > Differentiation::SD::BatchOptimizer< ReturnType >::evaluate (const Tensor< rank, dim, Expression > &funcs) const
 
template<int rank, int dim>
SymmetricTensor< rank, dim, ReturnType > Differentiation::SD::BatchOptimizer< ReturnType >::evaluate (const SymmetricTensor< rank, dim, Expression > &funcs) const
 
ReturnType Differentiation::SD::BatchOptimizer< ReturnType >::extract (const Expression &func, const std::vector< ReturnType > &cached_evaluation) const
 
std::vector< ReturnType > Differentiation::SD::BatchOptimizer< ReturnType >::extract (const std::vector< Expression > &funcs, const std::vector< ReturnType > &cached_evaluation) const
 
template<int rank, int dim>
Tensor< rank, dim, ReturnType > Differentiation::SD::BatchOptimizer< ReturnType >::extract (const Tensor< rank, dim, Expression > &funcs, const std::vector< ReturnType > &cached_evaluation) const
 
template<int rank, int dim>
SymmetricTensor< rank, dim, ReturnType > Differentiation::SD::BatchOptimizer< ReturnType >::extract (const SymmetricTensor< rank, dim, Expression > &funcs, const std::vector< ReturnType > &cached_evaluation) const
 
bool Differentiation::SD::BatchOptimizer< ReturnType >::is_valid_nonunique_dependent_variable (const SD::Expression &function) const
 
bool Differentiation::SD::BatchOptimizer< ReturnType >::is_valid_nonunique_dependent_variable (const SymEngine::RCP< const SymEngine::Basic > &function) const
 
void Differentiation::SD::BatchOptimizer< ReturnType >::register_scalar_function (const SD::Expression &function)
 
void Differentiation::SD::BatchOptimizer< ReturnType >::register_vector_functions (const types::symbol_vector &functions)
 
void Differentiation::SD::BatchOptimizer< ReturnType >::create_optimizer (std::unique_ptr< SymEngine::Visitor > &optimizer)
 
void Differentiation::SD::BatchOptimizer< ReturnType >::substitute (const std::vector< ReturnType > &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 ()
 

Input/Output

SmartPointer< const BlockSparsityPattern, BlockSparseMatrix< number > > BlockSparseMatrix< number >::sparsity_pattern
 
static ::ExceptionBaseBlockSparseMatrix< 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
 

Input/Output

SmartPointer< const ChunkSparsityPattern, ChunkSparseMatrix< number > > ChunkSparseMatrix< number >::cols
 
std::unique_ptr< number[]> ChunkSparseMatrix< number >::val
 
size_type ChunkSparseMatrix< number >::max_len
 
template<typename somenumber >
class ChunkSparseMatrix< number >::ChunkSparseMatrix
 
template<typename , bool >
class ChunkSparseMatrix< number >::ChunkSparseMatrixIterators::Iterator
 
template<typename , bool >
class ChunkSparseMatrix< number >::ChunkSparseMatrixIterators::Accessor
 
static ::ExceptionBaseChunkSparseMatrix< number >::ExcInvalidIndex (int arg1, int arg2)
 
static ::ExceptionBaseChunkSparseMatrix< number >::ExcDifferentChunkSparsityPatterns ()
 
static ::ExceptionBaseChunkSparseMatrix< number >::ExcIteratorRange (int arg1, int arg2)
 
static ::ExceptionBaseChunkSparseMatrix< number >::ExcSourceEqualsDestination ()
 
size_type ChunkSparseMatrix< number >::compute_location (const size_type i, const size_type j) const
 
void ChunkSparseMatrix< number >::print (std::ostream &out) const
 
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
 
void ChunkSparseMatrix< number >::print_pattern (std::ostream &out, const double threshold=0.) const
 
void ChunkSparseMatrix< number >::block_write (std::ostream &out) const
 
void ChunkSparseMatrix< number >::block_read (std::istream &in)
 

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 SparseMatrix< number >::SparseLUDecomposition
 
template<typename >
class SparseMatrix< number >::SparseILU
 
template<typename >
class SparseMatrix< number >::BlockMatrixBase
 
template<typename , bool >
class SparseMatrix< number >::SparseMatrixIterators::Iterator
 
template<typename , bool >
class SparseMatrix< number >::SparseMatrixIterators::Accessor
 
template<typename Number >
void SparseMatrix< number >::Utilities::MPI::sum (const SparseMatrix< Number > &, const MPI_Comm &, SparseMatrix< Number > &)
 
static ::ExceptionBaseSparseMatrix< number >::ExcInvalidIndex (int arg1, int arg2)
 
static ::ExceptionBaseSparseMatrix< number >::ExcDifferentSparsityPatterns ()
 
static ::ExceptionBaseSparseMatrix< number >::ExcIteratorRange (int arg1, int arg2)
 
static ::ExceptionBaseSparseMatrix< 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 >::print_as_numpy_arrays (std::ostream &out, const unsigned int precision=9) 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< RowInfoSparseMatrixEZ< number >::row_info
 
std::vector< EntrySparseMatrixEZ< number >::data
 
unsigned int SparseMatrixEZ< number >::increment
 
unsigned int SparseMatrixEZ< number >::saved_default_row_length
 
static ::ExceptionBaseSparseMatrixEZ< number >::ExcNoDiagonal ()
 
static ::ExceptionBaseSparseMatrixEZ< number >::ExcInvalidEntry (int arg1, int arg2)
 
static ::ExceptionBaseSparseMatrixEZ< number >::ExcEntryAllocationFailure (int arg1, int arg2)
 
const EntrySparseMatrixEZ< number >::locate (const size_type row, const size_type col) const
 
EntrySparseMatrixEZ< number >::locate (const size_type row, const size_type col)
 
EntrySparseMatrixEZ< 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

std::unique_ptr< Epetra_Map > TrilinosWrappers::SparsityPattern::column_space_map
 
std::unique_ptr< Epetra_FECrsGraph > TrilinosWrappers::SparsityPattern::graph
 
std::unique_ptr< Epetra_CrsGraph > TrilinosWrappers::SparsityPattern::nonlocal_graph
 
class TrilinosWrappers::SparsityPattern::TrilinosWrappers::SparseMatrix
 
class TrilinosWrappers::SparsityPattern::SparsityPatternIterators::Accessor
 
class TrilinosWrappers::SparsityPattern::SparsityPatternIterators::Iterator
 
static ::ExceptionBaseTrilinosWrappers::SparsityPattern::ExcTrilinosError (int arg1)
 
static ::ExceptionBaseTrilinosWrappers::SparsityPattern::ExcInvalidIndex (size_type arg1, size_type arg2)
 
static ::ExceptionBaseTrilinosWrappers::SparsityPattern::ExcSourceEqualsDestination ()
 
static ::ExceptionBaseTrilinosWrappers::SparsityPattern::ExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4)
 
static ::ExceptionBaseTrilinosWrappers::SparsityPattern::ExcAccessToNonPresentElement (size_type arg1, size_type arg2)
 
void TrilinosWrappers::SparsityPattern::write_ascii ()
 
void TrilinosWrappers::SparsityPattern::print (std::ostream &out, const bool write_extended_trilinos_info=false) const
 
void TrilinosWrappers::SparsityPattern::print_gnuplot (std::ostream &out) const
 

Exceptions

Accessor TriaRawIterator< Accessor >::accessor
 
template<typename SomeAccessor >
class TriaRawIterator< Accessor >::TriaRawIterator
 
template<typename SomeAccessor >
class TriaRawIterator< Accessor >::TriaIterator
 
template<typename SomeAccessor >
class TriaRawIterator< Accessor >::TriaActiveIterator
 
static ::ExceptionBaseTriaRawIterator< Accessor >::ExcDereferenceInvalidCell (Accessor arg1)
 
static ::ExceptionBaseTriaRawIterator< Accessor >::ExcDereferenceInvalidObject (Accessor arg1)
 
static ::ExceptionBaseTriaRawIterator< Accessor >::ExcAdvanceInvalidObject ()
 
static ::ExceptionBaseTriaRawIterator< Accessor >::ExcInvalidComparison ()
 

Data storage and access

static ::ExceptionBaseGeneralDataStorage::ExcNameNotFound (std::string arg1)
 
static ::ExceptionBaseGeneralDataStorage::ExcNameHasBeenFound (std::string arg1)
 
static ::ExceptionBaseGeneralDataStorage::ExcTypeMismatch (std::string arg1, const char *arg2, const char *arg3)
 

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
 
ExpressionDifferentiation::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::save (Archive &archive, const unsigned int version) const
 
template<class Archive >
void Differentiation::SD::Expression::load (Archive &archive, const unsigned int version)
 
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

ExpressionDifferentiation::SD::Expression::operator= (const Expression &rhs)
 
ExpressionDifferentiation::SD::Expression::operator= (Expression &&rhs) noexcept
 
ExpressionDifferentiation::SD::Expression::operator+= (const Expression &rhs)
 
ExpressionDifferentiation::SD::Expression::operator-= (const Expression &rhs)
 
ExpressionDifferentiation::SD::Expression::operator*= (const Expression &rhs)
 
ExpressionDifferentiation::SD::Expression::operator/= (const Expression &rhs)
 

Math and relational operators with numeric types

template<typename NumberType >
ExpressionDifferentiation::SD::Expression::operator= (const NumberType &rhs)
 
Expression Differentiation::SD::Expression::operator- () const
 
template<typename NumberType >
ExpressionDifferentiation::SD::Expression::operator+= (const NumberType &rhs)
 
template<typename NumberType >
ExpressionDifferentiation::SD::Expression::operator-= (const NumberType &rhs)
 
template<typename NumberType >
ExpressionDifferentiation::SD::Expression::operator*= (const NumberType &rhs)
 
template<typename NumberType >
ExpressionDifferentiation::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 SymEngine::map_basic_basic &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
 
template<typename ReturnType >
ReturnType Differentiation::SD::Expression::substitute_and_evaluate (const SymEngine::map_basic_basic &substitution_values) const
 

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)
 

Independent variables

void Differentiation::SD::BatchOptimizer< ReturnType >::register_symbols (const types::substitution_map &substitution_map)
 
void Differentiation::SD::BatchOptimizer< ReturnType >::register_symbols (const SymEngine::map_basic_basic &substitution_map)
 
void Differentiation::SD::BatchOptimizer< ReturnType >::register_symbols (const types::symbol_vector &symbols)
 
void Differentiation::SD::BatchOptimizer< ReturnType >::register_symbols (const SymEngine::vec_basic &symbols)
 
types::symbol_vector Differentiation::SD::BatchOptimizer< ReturnType >::get_independent_symbols () const
 
std::size_t Differentiation::SD::BatchOptimizer< ReturnType >::n_independent_variables () const
 

Dependent variables

void Differentiation::SD::BatchOptimizer< ReturnType >::register_function (const Expression &function)
 
template<int rank, int dim>
void Differentiation::SD::BatchOptimizer< ReturnType >::register_function (const Tensor< rank, dim, Expression > &function_tensor)
 
template<int rank, int dim>
void Differentiation::SD::BatchOptimizer< ReturnType >::register_function (const SymmetricTensor< rank, dim, Expression > &function_tensor)
 
void Differentiation::SD::BatchOptimizer< ReturnType >::register_functions (const types::symbol_vector &functions)
 
void Differentiation::SD::BatchOptimizer< ReturnType >::register_functions (const SymEngine::vec_basic &functions)
 
template<typename T >
void Differentiation::SD::BatchOptimizer< ReturnType >::register_functions (const std::vector< T > &functions)
 
template<typename T , typename... Args>
void Differentiation::SD::BatchOptimizer< ReturnType >::register_functions (const T &functions, const Args &...other_functions)
 
const types::symbol_vectorDifferentiation::SD::BatchOptimizer< ReturnType >::get_dependent_functions () const
 
std::size_t Differentiation::SD::BatchOptimizer< ReturnType >::n_dependent_variables () const
 

Optimization

void Differentiation::SD::BatchOptimizer< ReturnType >::set_optimization_method (const enum OptimizerType &optimization_method, const enum OptimizationFlags &optimization_flags=OptimizationFlags::optimize_all)
 
enum OptimizerType Differentiation::SD::BatchOptimizer< ReturnType >::optimization_method () const
 
enum OptimizationFlags Differentiation::SD::BatchOptimizer< ReturnType >::optimization_flags () const
 
bool Differentiation::SD::BatchOptimizer< ReturnType >::use_symbolic_CSE () const
 
void Differentiation::SD::BatchOptimizer< ReturnType >::optimize ()
 
bool Differentiation::SD::BatchOptimizer< ReturnType >::optimized () const
 

Symbol substitution

void Differentiation::SD::BatchOptimizer< ReturnType >::substitute (const types::substitution_map &substitution_map) const
 
void Differentiation::SD::BatchOptimizer< ReturnType >::substitute (const SymEngine::map_basic_basic &substitution_map) const
 
void Differentiation::SD::BatchOptimizer< ReturnType >::substitute (const types::symbol_vector &symbols, const std::vector< ReturnType > &values) const
 
void Differentiation::SD::BatchOptimizer< ReturnType >::substitute (const SymEngine::vec_basic &symbols, const std::vector< ReturnType > &values) const
 
bool Differentiation::SD::BatchOptimizer< ReturnType >::values_substituted () const
 

Cell iterator functions returning ranges of iterators

static ::ExceptionBaseDoFHandler< dim, spacedim >::ExcNoFESelected ()
 
static ::ExceptionBaseDoFHandler< dim, spacedim >::ExcInvalidBoundaryIndicator ()
 
static ::ExceptionBaseDoFHandler< dim, spacedim >::ExcInvalidLevel (int arg1)
 
static ::ExceptionBaseDoFHandler< dim, spacedim >::ExcNewNumbersNotConsecutive (types::global_dof_index arg1)
 
static ::ExceptionBaseDoFHandler< dim, spacedim >::ExcInvalidFEIndex (int arg1, int arg2)
 
static ::ExceptionBaseDoFHandler< dim, spacedim >::ExcOnlyAvailableWithHP ()
 
static ::ExceptionBaseDoFHandler< dim, spacedim >::ExcNotImplementedWithHP ()
 

Exceptions

static ::ExceptionBaseDoFTools::ExcFiniteElementsDontMatch ()
 
static ::ExceptionBaseDoFTools::ExcGridNotCoarser ()
 
static ::ExceptionBaseDoFTools::ExcGridsDontMatch ()
 
static ::ExceptionBaseDoFTools::ExcNoFESelected ()
 
static ::ExceptionBaseDoFTools::ExcInvalidBoundaryIndicator ()
 

Support points and interpolation

static ::ExceptionBaseFiniteElement< dim, spacedim >::ExcShapeFunctionNotPrimitive (int arg1)
 
static ::ExceptionBaseFiniteElement< dim, spacedim >::ExcFENotPrimitive ()
 
static ::ExceptionBaseFiniteElement< dim, spacedim >::ExcUnitShapeValuesDoNotExist ()
 
static ::ExceptionBaseFiniteElement< dim, spacedim >::ExcFEHasNoSupportPoints ()
 
static ::ExceptionBaseFiniteElement< dim, spacedim >::ExcEmbeddingVoid ()
 
static ::ExceptionBaseFiniteElement< dim, spacedim >::ExcProjectionVoid ()
 
static ::ExceptionBaseFiniteElement< dim, spacedim >::ExcWrongInterfaceMatrixSize (int arg1, int arg2)
 
static ::ExceptionBaseFiniteElement< dim, spacedim >::ExcInterpolationNotImplemented ()
 

Functions to support hp

static ::ExceptionBaseFE_Q_Base< dim, spacedim >::ExcFEQCannotHaveDegree0 ()
 

Functions which should be in DoFTools

static ::ExceptionBaseFETools::ExcInvalidFEName (std::string arg1)
 
static ::ExceptionBaseFETools::ExcInvalidFEDimension (char arg1, int arg2)
 
static ::ExceptionBaseFETools::ExcInvalidFE ()
 
static ::ExceptionBaseFETools::ExcFENotPrimitive ()
 
static ::ExceptionBaseFETools::ExcTriangulationMismatch ()
 
static ::ExceptionBaseFETools::ExcHangingNodesNotAllowed ()
 
static ::ExceptionBaseFETools::ExcGridNotRefinedAtLeastOnce ()
 
static ::ExceptionBaseFETools::ExcMatrixDimensionMismatch (int arg1, int arg2, int arg3, int arg4)
 
static ::ExceptionBaseFETools::ExcLeastSquaresError (double arg1)
 
static ::ExceptionBaseFETools::ExcNotGreaterThan (int arg1, int arg2)
 

Access to the raw data

static ::ExceptionBaseFEValuesBase< dim, spacedim >::ExcAccessToUninitializedField (std::string arg1)
 
static ::ExceptionBaseFEValuesBase< dim, spacedim >::ExcNotReinited ()
 
static ::ExceptionBaseFEValuesBase< dim, spacedim >::ExcFEDontMatch ()
 
static ::ExceptionBaseFEValuesBase< dim, spacedim >::ExcShapeFunctionNotPrimitive (int arg1)
 
static ::ExceptionBaseFEValuesBase< dim, spacedim >::ExcFENotPrimitive ()
 

Exceptions

static ::ExceptionBaseMapping< dim, spacedim >::ExcInvalidData ()
 
static ::ExceptionBaseMapping< dim, spacedim >::ExcTransformationFailed ()
 
static ::ExceptionBaseMapping< dim, spacedim >::ExcDistortedMappedCell (Point< spacedim > arg1, double arg2, int arg3)
 

Exceptions

static ::ExceptionBaseGridGenerator::ExcInvalidRadii ()
 
static ::ExceptionBaseGridGenerator::ExcInvalidRepetitions (int arg1)
 
static ::ExceptionBaseGridGenerator::ExcInvalidRepetitionsDimension (int arg1)
 
static ::ExceptionBaseGridGenerator::ExcInvalidInputOrientation ()
 

Exceptions

static ::ExceptionBaseGridTools::ExcInvalidNumberOfPartitions (int arg1)
 
static ::ExceptionBaseGridTools::ExcNonExistentSubdomain (int arg1)
 
static ::ExceptionBaseGridTools::ExcTriangulationHasBeenRefined ()
 
static ::ExceptionBaseGridTools::ExcScalingFactorNotPositive (double arg1)
 
static ::ExceptionBaseGridTools::ExcVertexNotUsed (unsigned int arg1)
 

Exceptions

static ::ExceptionBaseTriangulation< dim, spacedim >::ExcInvalidLevel (int arg1, int arg2)
 
static ::ExceptionBaseTriangulation< dim, spacedim >::ExcTriangulationNotEmpty (int arg1, int arg2)
 
static ::ExceptionBaseTriangulation< dim, spacedim >::ExcGridReadError ()
 
static ::ExceptionBaseTriangulation< dim, spacedim >::ExcFacesHaveNoLevel ()
 
static ::ExceptionBaseTriangulation< dim, spacedim >::ExcEmptyLevel (int arg1)
 
static ::ExceptionBaseTriangulation< dim, spacedim >::ExcNonOrientableTriangulation ()
 
static ::ExceptionBaseTriangulation< dim, spacedim >::ExcBoundaryIdNotFound (types::boundary_id arg1)
 
static ::ExceptionBaseTriangulation< dim, spacedim >::ExcInconsistentCoarseningFlags ()
 

Advancement of iterators

static ::ExceptionBaseTriaIterator< Accessor >::ExcAssignmentOfUnusedObject ()
 

Advancement of iterators

static ::ExceptionBaseTriaActiveIterator< Accessor >::ExcAssignmentOfInactiveObject ()
 

Exceptions

static ::ExceptionBasehp::FECollection< dim, spacedim >::ExcNoFiniteElements ()
 

Multiplications

static ::ExceptionBaseFullMatrix< number >::ExcEmptyMatrix ()
 
static ::ExceptionBaseFullMatrix< number >::ExcNotRegular (number arg1)
 
static ::ExceptionBaseFullMatrix< number >::ExcInvalidDestination (size_type arg1, size_type arg2, size_type arg3)
 
static ::ExceptionBaseFullMatrix< number >::ExcSourceEqualsDestination ()
 
static ::ExceptionBaseFullMatrix< number >::ExcMatrixNotPositiveDefinite ()
 

2: Implementation of VectorSpaceVector

static ::ExceptionBaseLinearAlgebra::distributed::BlockVector< Number >::ExcVectorTypeNotCompatible ()
 
static ::ExceptionBaseLinearAlgebra::distributed::BlockVector< Number >::ExcIteratorRangeDoesNotMatchVectorSize ()
 

6: Mixed stuff

static ::ExceptionBaseLinearAlgebra::distributed::Vector< Number, MemorySpace >::ExcVectorTypeNotCompatible ()
 
static ::ExceptionBaseLinearAlgebra::distributed::Vector< Number, MemorySpace >::ExcNotAllowedForCuda ()
 
static ::ExceptionBaseLinearAlgebra::distributed::Vector< Number, MemorySpace >::ExcNonMatchingElements (Number arg1, Number arg2, unsigned int arg3)
 
static ::ExceptionBaseLinearAlgebra::distributed::Vector< Number, MemorySpace >::ExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4)
 

Partitioners

static ::ExceptionBaseTrilinosWrappers::PreconditionBase::ExcNonMatchingMaps (std::string arg1)
 

Input/Output

static ::ExceptionBaseTrilinosWrappers::SparseMatrix::ExcTrilinosError (int arg1)
 
static ::ExceptionBaseTrilinosWrappers::SparseMatrix::ExcInvalidIndex (size_type arg1, size_type arg2)
 
static ::ExceptionBaseTrilinosWrappers::SparseMatrix::ExcSourceEqualsDestination ()
 
static ::ExceptionBaseTrilinosWrappers::SparseMatrix::ExcMatrixNotCompressed ()
 
static ::ExceptionBaseTrilinosWrappers::SparseMatrix::ExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4)
 
static ::ExceptionBaseTrilinosWrappers::SparseMatrix::ExcAccessToNonPresentElement (size_type arg1, size_type arg2)
 

4: Mixed stuff

static ::ExceptionBaseTrilinosWrappers::MPI::Vector::ExcDifferentParallelPartitioning ()
 
static ::ExceptionBaseTrilinosWrappers::MPI::Vector::ExcTrilinosError (int arg1)
 
static ::ExceptionBaseTrilinosWrappers::MPI::Vector::ExcAccessToNonLocalElement (size_type arg1, size_type arg2, size_type arg3, size_type arg4)
 

Data that supports the hp-FE implementation

static ::ExceptionBaseMeshWorker::ScratchData< dim, spacedim >::ExcOnlyAvailableWithoutHP ()
 
static ::ExceptionBaseMeshWorker::ScratchData< dim, spacedim >::ExcOnlyAvailableWithHP ()
 

Detailed Description

This module contains classes that are used in the exception mechanism of deal.II.

Brief overview

Exceptions are used in two different ways:

Detailed description

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:

DeclException2 (ExcDomain, int, int,
<< "Index= " << arg1 << "Upper Bound= " << arg2);
#define DeclException2(Exception2, type1, type2, outsequence)
Definition: exceptions.h:532

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.

Use of the debug mode exceptions (static checks)

To use the exception mechanism for debug mode error checking, write lines like the following in your source code:

Assert (n<dim, ExcDomain(n,dim));
#define Assert(cond, exc)
Definition: exceptions.h:1473

which by macro expansion does essentially the following (though the actual code is slightly more complicated):

#ifdef DEBUG
if (!(cond))
{
// issue error of class ExcDomain(n,dim)
}
#else
// do nothing
#endif

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());

How it works internally

If the DEBUG preprocessor directive is set, the call Assert (cond, exc); is basically converted by the preprocessor into the following sequence:

if (!(cond))
(__FILE__,
__LINE__,
__PRETTY_FUNCTION__,
#cond,
#exc,
exc);
void issue_error_noreturn(ExceptionHandling handling, const char *file, int line, const char *function, const char *cond, const char *exc_name, ExceptionType e)
Definition: exceptions.h:1358

(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:

static ::ExceptionBase & ExcInternalError()

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.

Use of run-time exceptions (dynamic checks)

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

if (!(cond))
throw ExcSomething();

and catch it using the statement

try
{
do_something ();
}
catch (std::exception &e)
{
std::cerr << "Exception occurred:" << std::endl
<< e.what ()
<< std::endl;
do_something_to_receiver ();
}
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)

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:

if (!(cond))
{
ExcSomething e(additional information);
e.set_fields (__FILE__, __LINE__, __PRETTY_FUNCTION__,
"condition as a string",
"name of condition as a string");
throw e;
};

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

AssertThrow (cond, ExcSomething(additional information));
#define AssertThrow(cond, exc)
Definition: exceptions.h:1583

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.

Description of the DeclExceptionN macro family

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:

DeclException2 (ExcDomain,
int,
int,
<< " i=" << arg1 << ", m=" << arg2);

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):

class name : public ExceptionBase
{
public:
name (const type1 a1, const type2 a2) : arg1 (a1), arg2(a2)
{}
virtual void print_info (std::ostream &out) const
{
out << " " outsequence << std::endl;
}
private:
type1 arg1;
type2 arg2;
};

If declared as specified, you can later use this exception class in the following manner:

int i=5;
int m=3;
Assert (i<m, MyExc2(i,m));

and the output if the condition fails will be

--------------------------------------------------------
An error occurred in line <301> of file <exc-test.cc>.
The violated condition was:
i<m
The name and call sequence of the exception was:
MyExc2(i,m)
Additional Information:
i=5, m=3
--------------------------------------------------------
void call(const std::function< RT()> &function, internal::return_value< RT > &ret_val)

Obviously for the DeclException0(name) macro, no types and also no output sequence is allowed.

A corner case of Assert: The AssertNothrow macro

The 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.

Macro Definition Documentation

◆ DeclException0

#define DeclException0 (   Exception0)
Value:
\
static ::ExceptionBase &Exception0()

Declare an exception class derived from ExceptionBase without parameters.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 464 of file exceptions.h.

◆ DeclExceptionMsg

#define DeclExceptionMsg (   Exception,
  defaulttext 
)
Value:
\ \
static ::ExceptionBase &Exception()

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.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 487 of file exceptions.h.

◆ DeclException1

#define DeclException1 (   Exception1,
  type1,
  outsequence 
)
Value:
\ \
static ::ExceptionBase &Exception1(type1 arg1)

Declare an exception class derived from ExceptionBase with one additional parameter.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 509 of file exceptions.h.

◆ DeclException2

#define DeclException2 (   Exception2,
  type1,
  type2,
  outsequence 
)
Value:
\ \
static ::ExceptionBase &Exception2(type1 arg1, type2 arg2)

Declare an exception class derived from ExceptionBase with two additional parameters.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 532 of file exceptions.h.

◆ DeclException3

#define DeclException3 (   Exception3,
  type1,
  type2,
  type3,
  outsequence 
)
Value:
\ \
static ::ExceptionBase &Exception3(type1 arg1, type2 arg2, type3 arg3)

Declare an exception class derived from ExceptionBase with three additional parameters.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 555 of file exceptions.h.

◆ DeclException4

#define DeclException4 (   Exception4,
  type1,
  type2,
  type3,
  type4,
  outsequence 
)
Value:
\ \
static ::ExceptionBase &Exception4(type1 arg1, \
type2 arg2, \
type3 arg3, \
type4 arg4)

Declare an exception class derived from ExceptionBase with four additional parameters.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 578 of file exceptions.h.

◆ DeclException5

#define DeclException5 (   Exception5,
  type1,
  type2,
  type3,
  type4,
  type5,
  outsequence 
)
Value:
\ \
static ::ExceptionBase &Exception5( \
type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5)

Declare an exception class derived from ExceptionBase with five additional parameters.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 604 of file exceptions.h.

◆ Assert

#define Assert (   cond,
  exc 
)
Value:
{ \
if (__builtin_expect(!(cond), false)) \
abort_or_throw_on_exception, \
__FILE__, \
__LINE__, \
__PRETTY_FUNCTION__, \
#cond, \
#exc, \
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.

Note
Active in DEBUG mode only
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1473 of file exceptions.h.

◆ AssertNothrow

#define AssertNothrow (   cond,
  exc 
)
Value:
{ \
if (__builtin_expect(!(cond), false)) \
__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc); \
}
void issue_error_nothrow(const char *file, int line, const char *function, const char *cond, const char *exc_name, ExceptionType e) noexcept
Definition: exceptions.h:1408

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.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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.
Active in DEBUG mode only

Definition at line 1536 of file exceptions.h.

◆ AssertThrow

#define AssertThrow (   cond,
  exc 
)
Value:
{ \
if (__builtin_expect(!(cond), false)) \
throw_on_exception, \
__FILE__, \
__LINE__, \
__PRETTY_FUNCTION__, \
#cond, \
#exc, \
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.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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.
Active in both DEBUG and RELEASE modes

Definition at line 1583 of file exceptions.h.

◆ AssertDimension

#define AssertDimension (   dim1,
  dim2 
)
Value:
dim2), \
::ExcDimensionMismatch((dim1), (dim2)))
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
constexpr bool compare_for_equality(const T &t, const U &u)
Definition: exceptions.h:1624

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.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1667 of file exceptions.h.

◆ AssertVectorVectorDimension

#define AssertVectorVectorDimension (   VEC,
  DIM1,
  DIM2 
)
Value:
AssertDimension(VEC.size(), DIM1); \
for (const auto &subvector : VEC) \
{ \
(void)subvector; \
AssertDimension(subvector.size(), DIM2); \
}
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1667

An assertion that tests whether vec has size dim1, and each entry of the vector is itself an array that has the size dim2.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1690 of file exceptions.h.

◆ AssertIndexRange

#define AssertIndexRange (   index,
  range 
)
Value:
Assert( \
ExcIndexRangeType<typename ::internal::argument_type<void( \
typename std::common_type<decltype(index), decltype(range)>::type)>:: \
type>((index), 0, (range)))
static ::ExceptionBase & ExcIndexRangeType(T arg1, T arg2, T arg3)
constexpr bool compare_less_than(const T &t, const U &u)
Definition: exceptions.h:1638

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.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1732 of file exceptions.h.

◆ AssertIsFinite

#define AssertIsFinite (   number)
Value:
::ExcNumberNotFinite(std::complex<double>(number)))
static ::ExceptionBase & ExcNumberNotFinite(std::complex< double > arg1)
bool is_finite(const double x)
Definition: numbers.h:539

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.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1758 of file exceptions.h.

◆ AssertThrowMPI

#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.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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.
Active only if deal.II is compiled with MPI

Definition at line 1790 of file exceptions.h.

◆ AssertCuda

#define AssertCuda (   error_code)
Value:
Assert(error_code == cudaSuccess, \
::ExcCudaError(cudaGetErrorString(error_code)))
static ::ExceptionBase & ExcCudaError(const char *arg1)

An assertion that checks that the error code produced by calling a CUDA routine is equal to cudaSuccess.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1816 of file exceptions.h.

◆ AssertNothrowCuda

#define AssertNothrowCuda (   error_code)
Value:
AssertNothrow(error_code == cudaSuccess, \
::ExcCudaError(cudaGetErrorString(error_code)))
#define AssertNothrow(cond, exc)
Definition: exceptions.h:1536

The non-throwing equivalent of AssertCuda.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1843 of file exceptions.h.

◆ AssertCudaKernel

#define AssertCudaKernel ( )
Value:
{ \
cudaError_t local_error_code = cudaPeekAtLastError(); \
AssertCuda(local_error_code); \
local_error_code = cudaDeviceSynchronize(); \
AssertCuda(local_error_code) \
}

An assertion that checks that the kernel was launched and executed successfully.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1871 of file exceptions.h.

◆ AssertCusparse

#define AssertCusparse (   error_code)
Value:
Assert( \
error_code == CUSPARSE_STATUS_SUCCESS, \
error_code)))
static ::ExceptionBase & ExcCusparseError(std::string arg1)
std::string get_cusparse_error_string(const cusparseStatus_t error_code)
Definition: exceptions.cc:523

An assertion that checks that the error code produced by calling a cuSPARSE routine is equal to CUSPARSE_STATUS_SUCCESS.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1901 of file exceptions.h.

◆ AssertNothrowCusparse

#define AssertNothrowCusparse (   error_code)
Value:
error_code == CUSPARSE_STATUS_SUCCESS, \
error_code)))

The non-throwing equivalent of AssertCusparse.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1931 of file exceptions.h.

◆ AssertCusolver

#define AssertCusolver (   error_code)
Value:
Assert( \
error_code == CUSOLVER_STATUS_SUCCESS, \
error_code)))
std::string get_cusolver_error_string(const cusolverStatus_t error_code)
Definition: exceptions.cc:569

An assertion that checks that the error code produced by calling a cuSOLVER routine is equal to CUSOLVER_STATUS_SUCCESS.

Note
This and similar macro names are examples of preprocessor definitions in the deal.II library that are not prefixed by a string that likely makes them unique to deal.II. As a consequence, it is possible that other libraries your code interfaces with define the same name, and the result will be name collisions (see https://en.wikipedia.org/wiki/Name_collision). One can #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 1962 of file exceptions.h.

Typedef Documentation

◆ ColorFunction

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 960 of file data_out_base.h.

◆ Map3DPoint

using DataOutBase::DataOutFilter::Map3DPoint = std::multimap<Point<3>, unsigned int, Point3Comp>
private

Definition at line 1523 of file data_out_base.h.

◆ T [1/9]

template<class ValueType , std::size_t N>
using Patterns::Tools::Convert< std::array< ValueType, N > >::T = std::array<ValueType, N>

Definition at line 1921 of file patterns.h.

◆ T [2/9]

template<int rank, int dim, class Number >
using Patterns::Tools::Convert< Tensor< rank, dim, Number > >::T = Tensor<rank, dim, Number>

Definition at line 1989 of file patterns.h.

◆ T [3/9]

template<int dim, class Number >
using Patterns::Tools::Convert< Point< dim, Number > >::T = Point<dim, Number>

Definition at line 2055 of file patterns.h.

◆ T [4/9]

template<int dim>
using Patterns::Tools::Convert< std::unique_ptr< FunctionParser< dim > > >::T = std::unique_ptr<FunctionParser<dim> >

Definition at line 2084 of file patterns.h.

◆ T [5/9]

Definition at line 2149 of file patterns.h.

◆ T [6/9]

template<class Number >
using Patterns::Tools::Convert< std::complex< Number > >::T = std::complex<Number>

Definition at line 2182 of file patterns.h.

◆ T [7/9]

using Patterns::Tools::Convert< std::string >::T = std::string

Definition at line 2245 of file patterns.h.

◆ T [8/9]

template<class Key , class Value >
using Patterns::Tools::Convert< std::pair< Key, Value > >::T = std::pair<Key, Value>

Definition at line 2275 of file patterns.h.

◆ T [9/9]

template<class... Args>
using Patterns::Tools::Convert< std::tuple< Args... > >::T = std::tuple<Args...>

Definition at line 2313 of file patterns.h.

◆ map_value_type

using Subscriptor::map_value_type = decltype(counter_map)::value_type
private

The data type used in counter_map.

Definition at line 230 of file subscriptor.h.

◆ map_iterator

using Subscriptor::map_iterator = decltype(counter_map)::iterator
private

The iterator type used in counter_map.

Definition at line 235 of file subscriptor.h.

◆ map_dependent_expression_to_vector_entry_t

template<typename ReturnType >
using Differentiation::SD::BatchOptimizer< ReturnType >::map_dependent_expression_to_vector_entry_t = std::map<SD::Expression, std::size_t, SD::types::internal::ExpressionKeyLess>
private

A map type used to indicate which dependent variable is associated with which entry in the output vector.

Note
We use a custom comparator here because otherwise we can't use std::map::find; it is sensitive to the some data from the underlying SymEngine::Basic other than the value that it represents.

Definition at line 2076 of file symengine_optimizer.h.

◆ BlockType

template<class VectorType >
using BlockVectorBase< VectorType >::BlockType = VectorType

Typedef the type of the underlying vector.

Definition at line 439 of file block_vector_base.h.

◆ value_type

template<class VectorType >
using BlockVectorBase< VectorType >::value_type = typename BlockType::value_type

Definition at line 451 of file block_vector_base.h.

◆ pointer

template<class VectorType >
using BlockVectorBase< VectorType >::pointer = value_type *

Definition at line 452 of file block_vector_base.h.

◆ const_pointer

template<class VectorType >
using BlockVectorBase< VectorType >::const_pointer = const value_type *

Definition at line 453 of file block_vector_base.h.

◆ iterator

template<class VectorType >
using BlockVectorBase< VectorType >::iterator = ::internal::BlockVectorIterators::Iterator<BlockVectorBase, false>

Definition at line 454 of file block_vector_base.h.

◆ const_iterator

template<class VectorType >
using BlockVectorBase< VectorType >::const_iterator = ::internal::BlockVectorIterators::Iterator<BlockVectorBase, true>

Definition at line 456 of file block_vector_base.h.

◆ reference

template<class VectorType >
using BlockVectorBase< VectorType >::reference = typename BlockType::reference

Definition at line 458 of file block_vector_base.h.

◆ const_reference

template<class VectorType >
using BlockVectorBase< VectorType >::const_reference = typename BlockType::const_reference

Definition at line 459 of file block_vector_base.h.

◆ size_type [1/5]

template<class VectorType >
using BlockVectorBase< VectorType >::size_type = types::global_dof_index

Definition at line 460 of file block_vector_base.h.

◆ real_type

template<class VectorType >
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 471 of file block_vector_base.h.

◆ number [1/3]

template<typename MatrixType , typename inverse_type = typename MatrixType::value_type>
using PreconditionBlockJacobi< MatrixType, inverse_type >::number = typename MatrixType::value_type
private

Define number type of matrix.

Definition at line 386 of file precondition_block.h.

◆ size_type [2/5]

template<typename MatrixType , typename inverse_type = typename MatrixType::value_type>
using PreconditionBlockJacobi< MatrixType, inverse_type >::size_type = types::global_dof_index

Declare type for container size.

Definition at line 392 of file precondition_block.h.

◆ size_type [3/5]

template<typename MatrixType , typename inverse_type = typename MatrixType::value_type>
using PreconditionBlockSOR< MatrixType, inverse_type >::size_type = types::global_dof_index

Declare type for container size.

Definition at line 663 of file precondition_block.h.

◆ number [2/3]

template<typename MatrixType , typename inverse_type = typename MatrixType::value_type>
using PreconditionBlockSOR< MatrixType, inverse_type >::number = typename MatrixType::value_type

Define number type of matrix.

Definition at line 673 of file precondition_block.h.

◆ size_type [4/5]

template<typename MatrixType , typename inverse_type = typename MatrixType::value_type>
using PreconditionBlockSSOR< MatrixType, inverse_type >::size_type = types::global_dof_index

Declare type for container size.

Definition at line 826 of file precondition_block.h.

◆ number [3/3]

template<typename MatrixType , typename inverse_type = typename MatrixType::value_type>
using PreconditionBlockSSOR< MatrixType, inverse_type >::number = typename MatrixType::value_type

Define number type of matrix.

Definition at line 831 of file precondition_block.h.

◆ size_type [5/5]

template<typename VectorType = ::Vector<double>>
using GrowingVectorMemory< VectorType >::size_type = types::global_dof_index

Declare type for container size.

Definition at line 319 of file vector_memory.h.

◆ entry_type

template<typename VectorType = ::Vector<double>>
using GrowingVectorMemory< VectorType >::entry_type = std::pair<bool, std::unique_ptr<VectorType> >
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 396 of file vector_memory.h.

Enumeration Type Documentation

◆ SizeType

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 829 of file data_out_base.h.

◆ ZlibCompressionLevel

A data type providing the different possible zlib compression levels. These map directly to constants defined by zlib.

Enumerator
no_compression 

Do not use any compression.

best_speed 

Use the fastest available compression algorithm.

best_compression 

Use the algorithm which results in the smallest compressed files. This is the default flag.

default_compression 

Use the default compression algorithm. This is a compromise between speed and file size.

Definition at line 1128 of file data_out_base.h.

◆ MultipleEntryType

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 2172 of file parameter_handler.h.

◆ FileType

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 1090 of file patterns.h.

◆ OptimizerType

An enumeration to distinguish between different optimization methods that can be used by SymEngine to more rapidly evaluate complex symbolic expressions.

Enumerator
dictionary 

Use dictionary substitution. This is SymEngine's default method.

lambda 

Convert the symbolic expression into a collection of std::functions.

llvm 

Use the LLVM JIT compiler to compile the expression into an aggressively optimized, stand-alone function.

Definition at line 99 of file symengine_optimizer.h.

◆ OptimizationFlags

enum Differentiation::SD::OptimizationFlags : unsigned char
strong

An enumeration to specify which special techniques, over and above those used with the chosen OptimizerType, to be applied to the set of expressions that are to be optimized.

Enumerator
optimize_default 

No additional optimization.

optimize_cse 

Apply common subexpresson elimination.

optimize_aggressive 

Employ aggressive optimizations when compiling with the LLVM JIT compiler.

optimize_all 

Apply all possible optimizations.

Definition at line 145 of file symengine_optimizer.h.

Function Documentation

◆ ExcNameNotFound() [1/2]

static ::ExceptionBase& AnyData::ExcNameNotFound ( std::string  arg1)
static

An entry with this name does not exist in the AnyData object.

Note
The message that will be printed by this exception reads:
<< "No entry with the name " << arg1 << " exists."

◆ ExcTypeMismatch() [1/2]

static ::ExceptionBase& AnyData::ExcTypeMismatch ( std::string  arg1,
std::string  arg2 
)
static

The requested type and the stored type are different.

Note
The message that will be printed by this exception reads:
<< "The requested type " << arg1 << " and the stored type " << arg2 << " must coincide."

◆ ExcNameMismatch()

static ::ExceptionBase& AnyData::ExcNameMismatch ( int  arg1,
std::string  arg2 
)
static

Exception indicating that a function expected a vector to have a certain name, but we store a different name in that position.

Note
The message that will be printed by this exception reads:
<< "Name at position " << arg1 << " is not equal to " << arg2 << '.'

◆ ExcNameNotFound() [2/2]

static ::ExceptionBase& GeneralDataStorage::ExcNameNotFound ( std::string  arg1)
static

An entry with this name does not exist in the internal boost::any map.

Note
The message that will be printed by this exception reads:
<< "No entry with the name " << arg1 << " exists."

◆ ExcNameHasBeenFound()

static ::ExceptionBase& GeneralDataStorage::ExcNameHasBeenFound ( std::string  arg1)
static

An entry with this name does not exist in the internal boost::any map.

Note
The message that will be printed by this exception reads:
<< "An entry with the name " << arg1 << " already exists."

◆ ExcTypeMismatch() [2/2]

static ::ExceptionBase& GeneralDataStorage::ExcTypeMismatch ( std::string  arg1,
const char *  arg2,
const char *  arg3 
)
static

The requested type and the stored type are different.

Note
The message that will be printed by this exception reads:
<< "The stored type for entry with name \"" << arg1 << "" is " << arg2 << " but you requested type " << arg3 << '.'

◆ ExcRateColumnAlreadyExists()

static ::ExceptionBase& ConvergenceTable::ExcRateColumnAlreadyExists ( std::string  arg1)
static

Exception

Note
The message that will be printed by this exception reads:
<< "Rate column <" << arg1 << "> does already exist."

◆ Patch() [1/2]

template<int dim, int spacedim>
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 2029 of file data_out_base.cc.

◆ operator==() [1/6]

template<int dim, int spacedim>
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 2048 of file data_out_base.cc.

◆ memory_consumption() [1/15]

template<int dim, int spacedim>
std::size_t DataOutBase::Patch< dim, spacedim >::memory_consumption

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 2090 of file data_out_base.cc.

◆ swap() [1/2]

template<int dim, int spacedim>
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 2107 of file data_out_base.cc.

◆ ExcInvalidCombinationOfDimensions() [1/2]

template<int dim, int spacedim = dim>
static ::ExceptionBase& DataOutBase::Patch< dim, spacedim >::ExcInvalidCombinationOfDimensions ( int  arg1,
int  arg2 
)
static

Exception

Note
The message that will be printed by this exception reads:
<< "It is not possible to have a structural dimension of " << arg1 << " to be larger than the space dimension of the surrounding" << " space " << arg2

◆ Patch() [2/2]

template<int spacedim>
DataOutBase::Patch< 0, spacedim >::Patch

Default constructor. Sets points_are_available to false, and patch_index to no_neighbor.

Definition at line 2140 of file data_out_base.cc.

◆ operator==() [2/6]

template<int spacedim>
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 2151 of file data_out_base.cc.

◆ memory_consumption() [2/15]

template<int spacedim>
std::size_t DataOutBase::Patch< 0, spacedim >::memory_consumption

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 2185 of file data_out_base.cc.

◆ swap() [2/2]

template<int spacedim>
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 2197 of file data_out_base.cc.

◆ ExcInvalidCombinationOfDimensions() [2/2]

template<int spacedim>
static ::ExceptionBase& DataOutBase::Patch< 0, spacedim >::ExcInvalidCombinationOfDimensions ( int  arg1,
int  arg2 
)
static

Exception

Note
The message that will be printed by this exception reads:
<< "It is not possible to have a structural dimension of " << arg1 << " to be larger than the space dimension of the surrounding" << " space " << arg2

◆ declare_parameters() [1/7]

template<typename FlagsType >
void DataOutBase::OutputFlagsBase< FlagsType >::declare_parameters ( ParameterHandler prm)
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 580 of file data_out_base.h.

◆ parse_parameters() [1/7]

template<typename FlagsType >
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 586 of file data_out_base.h.

◆ memory_consumption() [3/15]

template<typename FlagsType >
std::size_t DataOutBase::OutputFlagsBase< FlagsType >::memory_consumption

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 592 of file data_out_base.h.

◆ DXFlags()

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 2299 of file data_out_base.cc.

◆ declare_parameters() [2/7]

void DataOutBase::DXFlags::declare_parameters ( ParameterHandler prm)
static

Declare all flags with name and type as offered by this class, for use in input files.

Definition at line 2312 of file data_out_base.cc.

◆ parse_parameters() [2/7]

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 2343 of file data_out_base.cc.

◆ UcdFlags()

DataOutBase::UcdFlags::UcdFlags ( const bool  write_preamble = false)

Constructor.

Definition at line 2207 of file data_out_base.cc.

◆ declare_parameters() [3/7]

void DataOutBase::UcdFlags::declare_parameters ( ParameterHandler prm)
static

Declare all flags with name and type as offered by this class, for use in input files.

Definition at line 2352 of file data_out_base.cc.

◆ parse_parameters() [3/7]

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 2366 of file data_out_base.cc.

◆ GnuplotFlags() [1/2]

DataOutBase::GnuplotFlags::GnuplotFlags ( )

Default constructor. Sets up the dimension labels with the default values of "x", "y", and "z".

Definition at line 2213 of file data_out_base.cc.

◆ GnuplotFlags() [2/2]

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 2222 of file data_out_base.cc.

◆ memory_consumption() [4/15]

std::size_t DataOutBase::GnuplotFlags::memory_consumption ( ) const

Return an estimate for the memory consumption, in bytes, of this object.

Definition at line 2229 of file data_out_base.cc.

◆ ExcNotEnoughSpaceDimensionLabels()

static ::ExceptionBase& DataOutBase::GnuplotFlags::ExcNotEnoughSpaceDimensionLabels ( )
static

Exception to raise when there are not enough specified dimension labels.

Note
The message that will be printed by this exception reads:
"There should be at least one space dimension per spatial " "dimension (extras are ignored)."

◆ PovrayFlags()

DataOutBase::PovrayFlags::PovrayFlags ( const bool  smooth = false,
const bool  bicubic_patch = false,
const bool  external_data = false 
)

Constructor.

Definition at line 2236 of file data_out_base.cc.

◆ declare_parameters() [4/7]

void DataOutBase::PovrayFlags::declare_parameters ( ParameterHandler prm)
static

Declare all flags with name and type as offered by this class, for use in input files.

Definition at line 2392 of file data_out_base.cc.

◆ parse_parameters() [4/7]

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 2414 of file data_out_base.cc.

◆ is_grey()

bool DataOutBase::EpsFlags::RgbValues::is_grey ( ) const
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 3446 of file data_out_base.h.

◆ default_color_function()

EpsFlags::RgbValues DataOutBase::EpsFlags::default_color_function ( const double  value,
const double  min_value,
const double  max_value 
)
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 2452 of file data_out_base.cc.

◆ grey_scale_color_function()

EpsFlags::RgbValues DataOutBase::EpsFlags::grey_scale_color_function ( const double  value,
const double  min_value,
const double  max_value 
)
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 2540 of file data_out_base.cc.

◆ reverse_grey_scale_color_function()

EpsFlags::RgbValues DataOutBase::EpsFlags::reverse_grey_scale_color_function ( const double  value,
const double  min_value,
const double  max_value 
)
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 2553 of file data_out_base.cc.

◆ EpsFlags()

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 2423 of file data_out_base.cc.

◆ declare_parameters() [5/7]

void DataOutBase::EpsFlags::declare_parameters ( ParameterHandler prm)
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 2566 of file data_out_base.cc.

◆ parse_parameters() [5/7]

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 2633 of file data_out_base.cc.

◆ TecplotFlags()

DataOutBase::TecplotFlags::TecplotFlags ( const char *  zone_name = nullptr,
const double  solution_time = -1.0 
)

Constructor.

Definition at line 2663 of file data_out_base.cc.

◆ memory_consumption() [5/15]

std::size_t DataOutBase::TecplotFlags::memory_consumption ( ) const

Return an estimate for the memory consumption, in bytes, of this object.

Definition at line 2671 of file data_out_base.cc.

◆ VtkFlags()

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,
const std::map< std::string, std::string > &  physical_units = {} 
)

Constructor. Initializes the member variables with names corresponding to the argument names of this function.

Definition at line 2678 of file data_out_base.cc.

◆ SvgFlags()

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 2373 of file data_out_base.cc.

◆ DataOutFilterFlags()

DataOutBase::DataOutFilterFlags::DataOutFilterFlags ( const bool  filter_duplicate_vertices = false,
const bool  xdmf_hdf5_output = false 
)

Constructor.

Definition at line 2245 of file data_out_base.cc.

◆ declare_parameters() [6/7]

void DataOutBase::DataOutFilterFlags::declare_parameters ( ParameterHandler prm)
static

Declare all flags with name and type as offered by this class, for use in input files.

Definition at line 2253 of file data_out_base.cc.

◆ parse_parameters() [6/7]

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 2291 of file data_out_base.cc.

◆ memory_consumption() [6/15]

std::size_t DataOutBase::DataOutFilterFlags::memory_consumption ( ) const

Determine an estimate for the memory consumption (in bytes) of this object.

◆ DataOutFilter() [1/2]

DataOutBase::DataOutFilter::DataOutFilter ( )

Default constructor.

Definition at line 332 of file data_out_base.cc.

◆ DataOutFilter() [2/2]

DataOutBase::DataOutFilter::DataOutFilter ( const DataOutBase::DataOutFilterFlags flags)

Constructor with a given set of flags. See DataOutFilterFlags for possible flags.

Definition at line 340 of file data_out_base.cc.

◆ write_point()

template<int dim>
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 350 of file data_out_base.cc