From: Matthias Maier Date: Tue, 14 May 2019 13:46:05 +0000 (-0500) Subject: Update the changelog file for the release. X-Git-Tag: v9.1.0-rc1~5^2~1 X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=44bd7aa6656aca986b1e5a52f9aea40e94096de1;p=dealii.git Update the changelog file for the release. --- diff --git a/doc/news/9.0.1-vs-9.1.0.h b/doc/news/9.0.1-vs-9.1.0.h new file mode 100644 index 0000000000..9d4eb85ee8 --- /dev/null +++ b/doc/news/9.0.1-vs-9.1.0.h @@ -0,0 +1,1976 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2017 - 2019 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + +/** +@page changes_between_9_0_1_and_9_1_0 Changes between Version 9.0.1 and 9.1.0 + +

+This is the list of changes made between the release of deal.II version +9.0.1 and that of 9.1.0. All entries are signed with the names of the +author. +

+ + + + + + +

Incompatibilities

+ +

+Following are a few modifications to the library that unfortunately +are incompatible with previous versions of the library, but which we +deem necessary for the future maintainability of the +library. Unfortunately, some of these changes will require +modifications to application programs. We apologize for the +inconvenience this causes. +

+ +
    + +
  1. + Changed: Tasks of member function + hp::FECollection::find_face_dominating_fe_in_subset() are now divided + into two functions hp::FECollection::find_common_subspace() + and hp::FECollection::find_dominated_fe(). +
    + (Marc Fehling, 2019/04/08) +
    2. + +
  2. + Removed: The IndexSet instantiations for FEValues::get_function_values() + and DataOut_DoFData::add_data_vector() have been removed. +
    + (Daniel Arndt, 2019/03/20) +
    3. + +
  3. + Changed: The "debug" and "release" targets that are created by the + DEAL_II_INVOKE_AUTOPILOT() macro no longer automatically rebuild the + project. +
    + (Matthias Maier, 2019/02/05) +
    4. + +
  4. + Changed: VectorSlice has been deprecated in favor of the more general ArrayView + class. All public interfaces now take ArrayView arguments instead of VectorSlice + arguments. Since VectorSlice now inherits from ArrayView this should be + compatible with the overwhelming majority of use cases. +
    + (David Wells, 2019/01/21) +
    5. + +
  5. + Changed: The class VectorView has been removed. The suggested replacements are + to either use an ArrayView, a BlockVector, or to copy the relevant subset into a + Vector. +
    + (David Wells, 2019/01/11) +
    6. + +
  6. + Changed: The particle MPI datatype macro PARTICLE_INDEX_MPI_TYPE is + now properly namespaced: its new name is + DEAL_II_PARTICLE_INDEX_MPI_TYPE. +
    + (David Wells, 2018/11/30) +
    7. + +
  7. + Changed: Subscriptor::subscribe cannot be called with rvalue references anymore. + In particular, temporary string literals cannot be used as argument. Storing + string literals with the same content at the same memory location is + implementation defined and cannot be relied upon. On the other hand, the + subscriber strings are not compared by their memory address anymore but by their + actual content. +
    + (Daniel Arndt, 2018/11/12) +
    8. + +
  8. + Changed: The constructor for Subscriptor requires providing a pointer to a boolean + that can be used to signal validity of the object pointed to by the subscribing + object. +
    + (Daniel Arndt, 2018/11/02) +
    9. + +
  9. + Deprecated: deal.II's NetCDF bindings have been deprecated. The present set of + bindings are incompatible with recent releases of NetCDF and, at the present + time, no one has volunteered to either maintain or upgrade our interface. The + bindings will be removed in a future version if no one steps forward to update + the bindings. +
    + (David Wells, 2018/10/27) +
    10. + +
  10. + Changed: Time is described by a real-valued scalar in Function, TensorFunction, + ConstantTensorFunction and ZeroTensorFunction, i.e. all of them derive from + FunctionTime with a real-valued scalar template parameter. +
    + (Daniel Arndt, 2018/10/26) +
    11. + +
  11. + Deprecated: FiniteElement::compare_for_face_domination() has been + deprecated and will be replaced by the more versatile function + FiniteElement::compare_for_domination(). +
    + (Marc Fehling, 2018/10/11) +
    12. + +
  12. + Changed: Triangulation::create_triangulation() doesn't allow to set a boundary + id different from numbers::internal_face_boundary_id for internal faces anymore. +
    + (Daniel Arndt, 2018/08/07) +
    13. + +
  13. + Changes: The data transfer interface of the class + `parallel::distributed::Triangulation` now requires different kinds of + callback functions. `register_data_attach()` now takes + `std::function(cell_iterator &, CellStatus)>`, + which returns the buffer of the packed data. `notify_ready_to_unpack()` + requires `std::function::const_iterator &>`, where + the last argument describes an iterator range, from which the callback + function is allowed to read. +
    + Further, the `register_data_attach()` function now requires a boolean + argument `returns_variable_size_data`, which denotes if the registered + pack_callback function interacts with the fixed size (`=false`) or + variable size (`=true`) buffer for data transfer. +
    + (Marc Fehling, 2018/07/20) +
    14. + +
  14. + Changed: MatrixCreator::create_mass_matrix and + MatrixCreator::create_boundary_mass_matrix that had mixed number type (real + valued for the matrix and complex valued for vectors) have been changed to + support complex number types uniformly. This implies that now all + underlying number types of matrix, vectors and AffineConstraint objects + have to match; mixed variants are no longer supported. +
    + (Matthias Maier, 2018/05/25) +
    15. + +
  15. + Changed: The AffineConstraints object (formerly ConstraintMatrix) gained a + template parameter for the underlying storage type. In order to facilitate + this change, the interface for AffineConstraints has become more strict: In + particular, the AffineConstraints::distribute_local_to_global(), + AffineConstraints::add_entries_local_to_global(), and other functions now + require that all matrix and vector arguments have the same matching number + type as the AffineConstraints object. +
    + (Matthias Maier, 2018/05/25) +
    16. + +
  16. + Changed: The OpenCASCADE Manifold classes with names ending in Boundary (i.e., + NormalProjectionBoundary, DirectionalProjectionBoundary, and + NormalToMeshProjectionBoundary) have been deprecated in favor of renamed classes + ending in Manifold (i.e., NormalProjectionManifold, + DirectionalProjectionManifold, and NormalToMeshProjectionManifold). +
    + (David Wells, 2018/05/16) +
    17. + +
  17. + Changed: The PolynomialSpace::compute_index() and + PolynomialsP::directional_degree() functions used to return their + information through an array that they received as a reference + argument. Instead, they now return a `std::array` + by value. +
    + (Wolfgang Bangerth, 2018/05/09) +
    18. + +
+ + + + + +

General

+ +
    + +
  1. + Improved: All tutorial programs have been reviewed and updated with new features + in the library and C++11. +
    + (Daniel Arndt, David Wells, Matthias Maier, Denis Davydov, Wolfgang Bangerth, Jean-Paul Pelteret, 2019/05/13) +
    2. + +
  2. + Deprecated: deal.II's nanoflann bindings (i.e., the KDTree class) have been + deprecated in favor of using boost::geometry::index::rtree. +
    + (David Wells, 2019/05/10) +
    3. + +
  3. + New: Ths step-64 tutorial demonstrates how to use the CUDAWrappers::MatrixFree + framework (possibly with MPI) and discusses the peculiarities of using CUDA + inside deal.II in general. +
    + (Daniel Arndt, Bruno Turcksin, 2019/05/10) +
    4. + +
  4. + New: The new tutorial program step-61 shows how to use "weak Galerkin" finite element method to solve the Poisson equation. +
    + (Zhuoran Wang, 2019/05/02) +
    5. + +
  5. + New: The new tutorial program step-62 shows how to calculate the resonance + frequency and the bandgap of a phononic crystal. The program solves the elastic + wave equation with Perfectly Matches Layers in the frequency domain using + complex algebra and parallelization via MUMPS and MPI. +
    + (Daniel Garcia-Sanchez, 2019/05/01) +
    6. + +
  6. + New: The tutorial examples now all use a quadrature formula with a degree depending on the degree of the + finite element, so that one changing the finite element degree does not also require changing by hand the number + of quadrature points. +
    + (Roland Richter, 2019/04/25) +
    7. + +
  7. + New: The ParsedConvergenceTable class allows convenient construction of convergence tables, exploiting + parameter files. +
    + (Luca Heltai, 2019/04/10) +
    8. + +
  8. + New: A new class Differentiation::SD::Expression has been added which allows + the creation and manipulation of scalar symbolic functions using the SymEngine + library. It will later be used as the basis of symbolic tensor calculus, amongst + other things. It incorporates numerous features, which currently include: +
      +
    • expression parsing,
      • +
    • comparison operations,
      • +
    • logical operations,
      • +
    • basic math operations,
      • +
    • conditional expression construction,
      • +
    • differentiation,
      • +
    • substitution (partial and complete), and
      • +
    • serialization.
      • +
    +
    + (Jean-Paul Pelteret, 2019/03/29) +
    9. + +
  9. + New: A new class Differentiation::AD::VectorFunction has been + added to help implement point-wise vector functions using automatic + differentiation. In particular, this class is designed to compute the + Jacobian of a vector function that is parameterized in + terms of scalar, vector, and tensor arguments. One example of its use + would be to compute the linearization of a multi-field constitutive + law that is expressed in terms of some kinetic variables. +
    + (Jean-Paul Pelteret, 2019/03/21) +
    10. + +
  10. + New: Triangulation::execute_coarsening_and_refinement() now also performs + p-coarsening and p-refinement on all attached hp::DoFHandler objects. +
    + (Marc Fehling, 2019/03/18) +
    11. + +
  11. + New: A new class Differentiation::AD::ScalarFunction has been + added to help implement point-wise scalar functions using automatic + differentiation. In particular, this class is designed to compute the + gradient and Hessian of a scalar function that is parameterized in + terms of scalar, vector, and tensor arguments. One example of its use + would be to compute the derivatives of a multi-field constitutive law + that is expressed in terms of an energy function. +
    + (Jean-Paul Pelteret, 2019/02/20) +
    12. + +
  12. + Improved: The preconditioner and solver setup in step-20 has been rewritten + to highlight the new LinearOperator and PackagedOperation classes. +
    + (Matthias Maier, 2019/02/08) +
    13. + +
  13. + New: Support for Ginkgo, a high-performance numerical linear algebra library + has been added. Ginkgo provides advanced highly optimized linear solvers, + matrix formats and an abstraction to easily create linear operators on both + the cpu and the gpu. The deal.II's Ginkgo interface can currently be used to + solve linear systems using Krylov solvers with the cuda and OpenMP paradigms. +
    + (Ginkgo developers, 2019/01/30) +
    14. + +
  14. + Changed: Class hp::DoFHandler now transfers the active_fe_index of each + cell automatically when refining/coarsening a Triangulation, + parallel::shared::Triangulation, or + parallel::distributed::Triangulation. However, serialization of a + parallel::distributed::Triangulation still requires a user to + explicitly call the functions + hp::DoFHandler::prepare_for_serialization_of_active_fe_indices() and + hp::DoFHandler::deserialize_active_fe_indices(). +
    + (Marc Fehling, 2019/01/27) +
    15. + +
  15. + New: A new HDF5 interface has been added. The Hierarchical Data Format (HDF) is + a cross platform and a high I/O performance format designed to store large + amounts of data. It supports serial and MPI I/O access. The deal.II's HDF5 + interface can be used to write and read data, such the results of a simulation, + in a HDF5 file. +
    + (Daniel Garcia-Sanchez, 2019/01/09) +
    16. + +
  16. + Changed: hp::DoFHandler now automatically sets active_fe_indices + on cells that will be refined and coarsened whenever a Triangulation or + parallel::shared::Triangulation is used. Upon refinement, the + active_fe_index will be passed on to the children. For coarsening, the + parent's active_fe_index will be determined from its former children + using the FiniteElementDomination logic. +
    + (Marc Fehling, 2018/10/15) +
    17. + +
  17. + New: Function FiniteElement::compare_for_domination() inspects two + FiniteElement objects upon FiniteElementDomination, and uses a codim + parameter that determines in which subspace we actually compare them. +
    + (Marc Fehling, 2018/10/11) +
    18. + +
  18. + New: A new class Differentiation::AD::ResidualLinearization has been + added to help compute the linearization of a residual vector defined on the + level of a cell (a finite element residual), or for local nonlinear equations. +
    + (Jean-Paul Pelteret, 2018/09/30) +
    19. + +
  19. + Changed: hp::DoFHandler::distribute_dofs() called on + parallel::distributed::Triangulation objects now assigns exactly + one index for each degree of freedom located on interfaces with + ghost cells. Previously, those degrees of freedom were assigned + indices by each adjacent subdomain. +
    + (Marc Fehling, 2018/08/31) +
    20. + +
  20. + New: A new class Differentiation::AD::EnergyFunctional has been + added to help implement (incremental) variational formulations using automatic + differentiation. In particular, this class is designed to compute the finite + element residuals and their linearizations. +
    + (Jean-Paul Pelteret, 2018/08/27) +
    21. + +
  21. + New: The parallel::distributed::SolutionTransfer class is now capable + of transferring data that has been associated with a hp::DoFHandler + object. See the class documentation of the former on how to use this + new functionality. +
    + (Marc Fehling, 2018/08/15) +
    22. + +
  22. + Improved: GridGenerator::extrude_triangulation can now optionally extrude manifold + ids. +
    + (David Wells, 2018/08/11) +
    23. + +
  23. + New: FE_BernardiRaugel is the implementation of an element developed by Christine Bernardi and + Genevieve Raugel in the 1985 Mathematics of Computation paper. The Bernardi-Raugel element is an + enrichment of the P1-P0 element for Stokes problems by the addition of edge-based quadratic + bubble functions. The original description is for simplicial meshes, but this implementation is + for quadrilateral and hexahedral meshes. The BR1-P0 pair is LBB stable for Stokes problems. Due + to the edge-based bubble functions, features such as hanging nodes are not supported. +
    + (Graham Harper, 07/09/2018) +
    24. + +
  24. + New: A new function GridGenerator::channel_with_cylinder has been added. This + function generates a grid corresponding to the classic flow past a cylinder test + problem, and uses manifolds to blend between the description of the cylinder and + the Cartesian bulk geometry. +
    + (David Wells, 2018/07/04) +
    25. + +
  25. + Changed: The ConstraintMatrix class has been renamed to AffineConstraints. + Further, AffineConstraints gained a template parameter for the underlying + storage type. This in particular enables the definition of complex-valued + constraints (for example, complex-valued Dirichlet boundary conditions, or + periodic boundary conditions with an additional phase shift). +
    + (Matthias Maier, Daniel Arndt, David Wells, 2018/05/31) +
    26. + +
  26. + New: The introduction to step-6 has been completely rewritten. It + previously mentioned only the bare minimum about what this important + tutorial program actually does. It now gives a much broader overview + of why we use adaptive meshes and how this is achieved in practice. +
    + (Wolfgang Bangerth, 2018/05/25) +
    27. + +
  27. + Changed: clang-format replaces astyle as source code formatting tool. +
    + (Matthias Maier, Daniel Arndt, 2018/05/24) +
    28. + +
  28. + New: FE_NedelecSZ is a new H(curl)-conforming element which overcomes the sign conflict problem + which can be encountered for Nedelec elements on hexahedral meshes. This is an implementation of + the method described in the PhD thesis of Sabine Zaglmayr and should be considered over the + FE_Nedelec element where meshes with non-standard orientation are used. Note that not all + functionality (e.g. Hessians), has been implemented for this element. +
    + (Ross Kynch, 2018/04/28) +
    29. + +
  29. + New: The new class ColorEnriched::Helper constructs an hp::FECollection, a + collection of finite element objects used by hp::DoFHandler, in a domain + with multiple, possibly overlapping, sub-domains with individual + enrichment functions. Note that the overlapping regions may have + multiple enrichment functions associated with them. This is implemented + using a general constructor of FE_Enriched which allows different + enrichment functions. +
    + (Nivesh Dommaraju, Denis Davydov, 2018/04/20) +
    30. + +
+ + + + + +

Specific improvements

+ +
    + +
  1. + Improved: DoFHandler::renumber_dofs() on parallel::distributed::Triangulation + would scale linearly with the number of MPI ranks on more than 50k ranks, + reaching times of more than 10 seconds on 150k ranks. This is now fixed for + the case the renumbering does not lead to a change in the underlying IndexSet + field of locally owned unknowns, i.e., in case the numbers merely change + within each MPI rank but not across them. +
    + (Martin Kronbichler, 2019/05/10) +
    2. + +
  2. + New: Introduced indices for future finite elements that cells will be assigned + to after the triangulation changes. The future_fe_index of each cell can be + accessed and changed via member functions of the DoFCellAccessor class, + namely DoFCellAccessor::future_fe_index(), DoFCellAccessor::set_future_fe_index(), + DoFCellAccessor::future_fe_index_set(), and DoFCellAccessor::clear_future_fe_index(). +
    + (Marc Fehling, 2019/05/10) +
    3. + +
  3. + New: Add Utilities::MPI::mean_and_standard_deviation() to calculate mean and standard deviation. +
    + (Denis Davydov, 2019/05/09) +
    4. + +
  4. + New: Add DynamicSparsityPattern::get_view() to create a subset of a sparsity pattern based on a selection of some rows. +
    + (Denis Davydov, 2019/05/08) +
    5. + +
  5. + New: Some utility functions that perform symbolic substitution on, and + evaluation of, symbolic scalar and tensor expressions have been added to the + Differentiation::SD namespace. +
    + (Jean-Paul Pelteret, 2019/05/07) +
    6. + +
  6. + Improved: Extend Utilities::inverse_Hilbert_space_filling_curve to handle degenerate cases. +
    + (Denis Davydov, 2019/05/07) +
    7. + +
  7. + New: Some utility functions that resolve explicit (and cyclic) dependencies + between entries in symbolic substitution maps. +
    + (Jean-Paul Pelteret, 2019/05/05) +
    8. + +
  8. + New: Some utility functions that facilitate the creation of symbolic maps and + symbolic substitution maps have been added to the Differentiation::SD namespace. +
    + (Jean-Paul Pelteret, 2019/05/05) +
    9. + +
  9. + New: Mapping::get_bounding_box() returns the correct bounding box for mappings that do not preserve vertex + locations. +
    + (Luca Heltai, 2019/05/03) +
    10. + +
  10. + Improved: The `Meshworker::mesh_loop()` function is now capable of working with an + IteratorRange, and also supports iterator ranges constructed from + FilteredIterators. +
    + (Jean-Paul Pelteret, 2019/05/02) +
    11. + +
  11. + Improved: The Workstream::run() function is now capable of working with iterator + ranges, or any general iterable object that defines the `begin()` and `end()` + of a range of elements to iterate over. +
    + (Jean-Paul Pelteret, 2019/05/02) +
    12. + +
  12. + New: Some utility functions that perform symbolic differentiation of scalar + symbolic expressions, as well as tensorial expressions, have been added to the + Differentiation::SD namespace. +
    + (Jean-Paul Pelteret, 2019/04/23) +
    13. + +
  13. + Changed: The chunk_size used in CUDA kernels has been reduced from 8 to 1 to + improve performance on newer architectures. +
    + (Bruno Turcksin, 2019/04/23) +
    14. + +
  14. + New: Some utility functions that facilitate the creation of both scalar and + tensor symbolic variables and symbolic functions have been added to the + Differentiation::SD namespace. +
    + (Jean-Paul Pelteret, 2019/04/22) +
    15. + +
  15. + New: Functions::CutOffFunctionBase now supports rescaling the function to keep its integral equal to one. +
    + (Luca Heltai, 2019/04/18) +
    16. + +
  16. + New: The new FunctionFromFunctionObjects class allows one to wrap a vector of + std::function objects into a Function object, to allow fast prototyping of user codes. +
    + (Luca Heltai, 2019/04/12) +
    17. + +
  17. + Fixed: Make sure that GridTools::Cache::get_cell_bounding_boxes_rtree() honors mappings. +
    + (Luca Heltai, 2019/04/11) +
    18. + +
  18. + New: Added BoundingBox::extend() that allows extending and shrinking of BoundingBox objects. +
    + (Luca Heltai, 2019/04/11) +
    19. + +
  19. + New: The method Mapping::get_center() allows one to retrieve the cell center of a cell when the + mapping object does not preserve vertex locations. +
    + (Luca Heltai, 2019/04/11) +
    20. + +
  20. + New: Member function hp::FECollection::find_dominated_fe_extended() + returns the index of the least dominating finite element out of a given + set of indices. If none was found, the search will be extended on the + complete collection. +
    + (Marc Fehling, 2019/04/08) +
    21. + +
  21. + New: Member function hp::FECollection::find_dominating_fe_extended() + returns the index of the most dominating finite element out of a given + set of indices. If none was found, the search will be extended on the + complete collection. +
    + (Marc Fehling, 2019/04/08) +
    22. + +
  22. + New: Member function hp::FECollection::find_dominated_fe() + returns the index of the least dominating finite element out of a given + set of indices. +
    + (Marc Fehling, 2019/04/08) +
    23. + +
  23. + New: Member function hp::FECollection::find_dominating_fe() + returns the index of the most dominating finite element out of a given + set of indices. +
    + (Marc Fehling, 2019/04/08) +
    24. + +
  24. + New: Member function hp::FECollection::find_enclosing_fes() + returns a set of indices from the full FECollection whose associated + finite elements are dominated by all elements of a given set of indices. +
    + (Marc Fehling, 2019/04/08) +
    25. + +
  25. + New: Member function hp::FECollection::find_common_fes() + returns a set of indices from the full FECollection whose associated + finite elements dominate all elements of a given set of indices. +
    + (Marc Fehling, 2019/04/08) +
    26. + +
  26. + Changed: SmartPointer and Subscriptor use a std::string + instead of a const char * as identifier. +
    + (Daniel Arndt, 2019/04/08) +
    27. + +
  27. + New: The GeneralDataStorage class facilitates the storage of any general data. + It offers the ability to store any amount of data, of any type, which is then + made accessible by an identifier string. +
    + (Luca Heltai, Jean-Paul Pelteret, 2019/04/02) +
    28. + +
  28. + New: Add ArraView::ArrayView() and ArrayView::reinit(value_type *, const std::size_t). +
    + (Denis Davydov, 2019/04/02) +
    29. + +
  29. + New: The Differentiation::SD::Expression class can now be used to perform + symbolic math calculations. +
    + (Jean-Paul Pelteret, 2019/03/30) +
    30. + +
  30. + New: The Vector class can now be initialized using an object of type + std::initializer_list. Such objects are, in particular, created when + the compiler sees a brace-enclosed list of numbers. +
    + (Wolfgang Bangerth, 2019/03/28) +
    31. + +
  31. + Changed: parallel::distributed::SolutionTransfer::prepare_serialization() has + been deprecated in favor of + parallel::distributed::SolutionTransfer::prepare_for_serialization(). +
    + (Daniel Arndt, 2019/03/26) +
    32. + +
  32. + New: Added a variant of MeshWorker::mesh_loop() that takes a class and its member functions as workers + and copiers. +
    + (Luca Heltai, 2019/03/23) +
    33. + +
  33. + New: The type alias FEValuesViews::View now allows one to infer the correct FEValuesViews type + that would be returned by FEValuesBase::operator[]() when called with a specified extractor type from the + FEValuesExtractors namespace. +
    + (Luca Heltai, 2019/03/20) +
    34. + +
  34. + New: Add DynamicSparsityPattern::nonempty_cols()/DynamicSparsityPattern::nonempty_rows() to return columns/rows + stored in the sparsity pattern. +
    + (Denis Davydov, 2019/03/20) +
    35. + +
  35. + New: The new method GridTools::assign_co_dimensional_manifold_indicators() propagate manifold ids from + cells to faces and edges, according to a disambiguation function that takes the set of manifold ids of + the cells that share the given face or edge. +
    + (Luca Heltai, 2019/03/19) +
    36. + +
  36. + New: FEValuesExtractor classes now have a new method get_name() that returns a unique string identifier + for each extractor. +
    + (Luca Heltai, 2019/03/19) +
    37. + +
  37. + New: Add SparsityTools::gather_sparsity_pattern(). +
    + (Denis Davydov, 2019/03/19) +
    38. + +
  38. + New: Add Utilities::MPI::create_ascending_partitioning() to create a one-to-one + ascending partitioning from locally owned sizes. +
    + (Denis Davydov, 2019/03/19) +
    39. + +
  39. + New: VectorTools::interpolate_to_different_mesh() now works with + hp::DoFHandler objects. +
    + (Sebastian Stark, 2019/03/16) +
    40. + +
  40. + Improved: DoFRenumbering::cell_wise() now support parallel::Triangulation . +
    + (Denis Davydov, 2019/03/16) +
    41. + +
  41. + Improved: The apply_all_indicators_to_manifold flag in GridIn::read_ucd() + lets the indicators be used for cells as manifold id as well. +
    + (Daniel Arndt, 2019/03/16) +
    42. + +
  42. + New: Added two new classes to the MeshWorker namespace: MeshWorker::ScratchData and + MeshWorker::CopyData, that can be used as good default classes with the + WorkStream::run() and MeshWorker::mesh_loop() functions. +
    + (Luca Heltai, 2019/03/13) +
    43. + +
  43. + New: If present, we will detect the LLD linker ld.lld at configuration time. +
    + (Timo Heister, 2019/03/11) +
    44. + +
  44. + Changed: The TrilinosWrappers::PreconditionAMG::AdditionalData data structure + is now able to return a parameter list, which can be adjusted and fine-tuned by + the user and later used to initialize the AMG preconditioner. It can also + initialize the null space settings of an existing parameter list. +
    + (Jean-Paul Pelteret, 2019/03/10) +
    45. + +
  45. + Fixed: DoFHandler::renumber_dofs() called on levels would previously run into + an assertion on distributed triangulation when used with continuous + elements. This is now fixed. +
    + (Martin Kronbichler, 2019/03/08) +
    46. + +
  46. + New: Added a new function Utilities::type_to_string() to demangle type names. +
    + (Luca Heltai, 2019/03/07) +
    47. + +
  47. + Fixed: LinearAlgebra::CUDAWrappers::Vector::add_and_dot was giving a wrong result + if the size of vector was greater than 4096. +
    + (Bruno Turcksin, 2018/03/06) +
    48. + +
  48. + Fixed: EllipiticalManifold::push_forward_gradient did previously not take the + rotation into account. This is now fixed. +
    + (Daniel Appel, Martin Kronbichler, 2019/03/05) +
    49. + +
  49. + Fixed: CylindricalManifold::get_new_point would previously return wrong + results if the resulting point is on the axis, and the cylinder axis does not + pass through the origin. +
    + (Daniel Appel, Martin Kronbichler, 2019/03/05) +
    50. + +
  50. + Fixed: the DoFTools::make_sparsity_pattern variant that takes, as arguments, two + different DoFHandler objects now works correctly with + parallel::shared::Triangulation and parallel::distributed::Triangulation. +
    + (David Wells, 2019/03/04) +
    51. + +
  51. + New: Signals Triangulation::pre_distributed_repartition and + Triangulation::post_distributed_repartition which will be triggered in + parallel::distributed::Triangulation::repartition(). +
    + (Marc Fehling, 2019/03/03) +
    52. + +
  52. + Fixed: CellAccessor::material_id interfered with the manifold object + for refining the mesh in case its dimension was less than the space dimension. +
    + (Daniel Arndt, Sebastian Stark, 2019/03/02) +
    53. + +
  53. + New: Hierarchy of finite elements in hp::FECollection objects. Get succeeding + and preceding indices via hp::FECollection::next_in_hierarchy() and + hp::FECollection::prev_in_hierarchy(). By default, a hierarchy corresponding + to indices is established. Hierarchy can be overridden via + hp::FECollection::set_hierarchy(). +
    + (Marc Fehling, 2019/02/28) +
    54. + +
  54. + Fixed: Tensor-valued pvtu output. +
    + (Daniel Jodlbauer, 2019/02/27) +
    55. + +
  55. + New: Function GridTools::guess_point_owner(), which uses a covering rtree + to guess which processes own the points of the given vector of points. +
    + (Giovanni Alzetta, 2019/02/25) +
    56. + +
  56. + Fixed: FEFaceEvaluation::evaluate() and FEFaceEvaluation::integrate() would + provide wrong results for faces in non-standard orientation layout, namely + with `orientation=true, face_flip={false,true}, face_rotation=true`. This is + now fixed. +
    + (Martin Kronbichler, 2019/02/21) +
    57. + +
  57. + New: Function DoFRenumbering::random(dof_handler, level) which allows for a random renumbering + of degrees of freedom on a level in a mutilevel hierarchy. +
    + (Conrad Clevenger, 2019/02/19) +
    58. + +
  58. + Fixed: Handle the case properly that a local matrix with all diagonal elements equal to zero is distributed with AffineConstraints::distribute_local_to_global() to the global matrix while constraints apply. +
    + (Sebastian Stark, 2019/02/13) +
    59. + +
  59. + Fixed: inverse_operator() now handles a (composite) LinearOperator, the + temporary PreconditionIdentity(), or no argument as preconditioner argument + correctly. +
    + (Matthias Maier, 2019/02/13) +
    60. + +
  60. + New: Function MGConstrainedDoFs::make_no_normal_flux_constraints which adds + functionality for no normal flux constraints during geometric mutigrid computations. + Currently, this function is limited to meshes with no normal flux boundaries + normal to the x-, y-, or z-axis. +
    + (Conrad Clevenger, 2019/02/11) +
    61. + +
  61. + New: Member functions DoFHandler::set_fe() and hp::DoFHandler::set_fe() + that will register a finite element object without enumerating all + degrees of freedom. In the hp case, the active_fe_indices will be + initialized and communicated amongst all processors, additionally. +
    + (Marc Fehling, 2019/02/10) +
    62. + +
  62. + New: make_const_array_view() creates a constant view from a non-const object. +
    + (Daniel Arndt, 2019/02/09) +
    63. + +
  63. + Fixed: PreconditionChebyshev would previously run one iteration more than + requested, i.e., perform `degree+1` matrix-vector products rather than + `degree` which is the convention in literature. This is now fixed. Note that + the quality of PreconditionChebyshev is obviously slightly reduced by this + change, and some solvers might need more outer iterations due to a ligher + Chebyshev iteration. +
    + (Martin Kronbichler, 2019/02/08) +
    64. + +
  64. + New: Add default constructor to SparsityPatternIterators::Accessor(). +
    + (Denis Davydov, 2019/02/08) +
    65. + +
  65. + Improved: The iteration of PreconditionChebyshev has been overhauled to reduce + the number of vectors written per iteration to one, leading to slightly faster + execution of the vector updates. +
    + (Martin Kronbichler, 2019/02/07) +
    66. + +
  66. + Improved: The FEEvaluation::evaluate() and FEEvaluation::integrate() routines + would previously unconditionally use an evaluation routine with a + transformation to a collocation basis and subsequent collocation derivative + for `n_q_points_1d > fe_degree` because it is faster for the usual case of + `n_q_points_1d` close to the polynomial degree. Now, we switch back to the + standard evaluation if `n_q_points_1d > 3 * (fe_degree+1) / 2` where that + variant is faster. +
    + (Martin Kronbichler, 2019/02/06) +
    67. + +
  67. + Improved: Use binary search in BlockIndices::global_to_local() to improve performance + for large number of blocks. +
    + (Denis Davydov, 2019/02/06) +
    68. + +
  68. + Fixed: MGLevelGlobalTransfer::copy_to_mg would initialize the level vectors + without ghosts. When combined with Chebyshev smoother and a DiagonalMatrix as + well as specific matrix-free loops, this could lead to ghosted vectors in + places where they were not supposed to be ghosted, leading to exceptions. This + is now fixed. +
    + (Martin Kronbichler, 2019/02/05) +
    69. + +
  69. + Documented: The minimal supported MPI version is MPI-2.0. +
    + (Daniel Arndt, 2019/02/02) +
    70. + +
  70. + New: added constructor to the class Point, which converts + a boost::geometry::model::point to a dealii::Point +
    + (Giovanni Alzetta, Daniel Arndt, Wolfgang Bangerth, 2019/01/31) +
    71. + +
  71. + Changed: Function GridGenerator::general_cell() can now generate + a cell of dimension `dim` inside a space of dimension `spacedim` + with `dim <= spacedim` +
    + (Giovanni Alzetta, 2019/01/30) +
    72. + +
  72. + New: Add internal::MatrixFreeFunctions::DoFInfo::get_dof_indices_on_cell_batch() to + return locally owned DoFs used by matrix-free framework on a given cell. +
    + (Denis Davydov, 2019/01/30) +
    73. + +
  73. + Improved: A new dummy enumeration AD::NumberTypes::none has been added. + It exists to represent number types that are scalar arithmetic types, + i.e those that hold no derivatives. They are implemented primarily to + facilitate the use of template meta-programming techniques to switch + between different AD types. This covers the case when the user does not + want an AD type at all, but rather a primitive type. +
    + (Jean-Paul Pelteret, 2019/01/25) +
    74. + +
  74. + New: Add default constructor to DynamicSparsityPatternIterators::Accessor() and + DynamicSparsityPatternIterators::Iterator() to be able to store such objects + in STL containers. +
    + (Denis Davydov, 2019/01/18) +
    75. + +
  75. + New: Indentation script deal.II/contrib/utilities/indent.py is added + to format code in external projects that use deal.II +
    + (Vishal Boddu, 2019/01/13) +
    76. + +
  76. + New: GridTools::Cache::get_covering_rtree() automatically stores and generates + a rtree of bounding boxes covering the whole triangulation. In a distributed setting + it can identify which processes have locally owned cells in any part of the mesh. +
    + (Giovanni Alzetta, 2019/01/11) +
    77. + +
  77. + Fixed: Tensor indices of set_k_vectors() in FESeries::Fourier. + Coefficients will now be distributed in every + coordinate direction correctly. +
    + (Marc Fehling, 2019/01/08) +
    78. + +
  78. + New: LinearAlgebra::distributed::Vector with CUDA memory space uses CUDA-aware + MPI in case deal.II is configured with DEAL_II_MPI_WITH_CUDA_SUPPORT=ON. +
    + (Daniel Arndt, Bruno Turcksin, 2019/01/04) +
    79. + +
  79. + New: Add LAPACKFullMatrix::apply_givens_rotation() and Vector::apply_givens_rotation() to + apply a Givens rotation matrix. +
    + (Denis Davydov, 2018/12/30) +
    80. + +
  80. + New: Add SolverBFGS to minimize a function using the limited memory BFGS approach. +
    + (Denis Davydov, 2018/12/26) +
    81. + +
  81. + Replaced: TrilinosWrappers::MPI::Vector::vector_partitioner() has been + deprecated in favor of TrilinosWrappers::MPI::Vector::trilinos_partitioner(). + The latter one returns an Epetra_BlockMap instead of an Epetra_Map avoiding an + invalid downcast. + The IndexSet constructor taking an Epetra_Map object has been replaced to + accept a base class object of type Epetra_BlockMap instead. +
    + (Daniel Arndt, 2018/12/22) +
    82. + +
  82. + Fixed: Reinit blockvector only when necessary in MGTransferBlockMatrixFree::copy_to_mg. +
    + (Daniel Jodlbauer, 2018/12/19) +
    83. + +
  83. + New: Class parallel::distributed::CellDataTransfer has been introduced to transfer + cell by cell data across distributed meshes in case of refinement/serialization. +
    + (Marc Fehling, 2018/12/18) +
    84. + +
  84. + New: Function GridTools::build_global_description_tree which exchanges a given + vector of bounding boxes on all processes and uses the result to build an Rtree + with packing algorithm. +
    + (Giovanni Alzetta, 2018/12/17) +
    85. + +
  85. + New: Add helpers functions to use varying coefficients when using + CUDAWrappers::MatrixFree. +
    + (Bruno Turcksin, 2018/12/10) +
    86. + +
  86. + New: GridTools::find_active_cell_around_point now allows you to specify an (optional) rtree, constructed + from the used vertices of the triangulation. Once you have built a tree, querying for a nearest + vertex is an O(log(N)) operation, where N is the number of used vertices. You can ask a GridTools::Cache + object to return a tree that is compatible with the new function signature. + The previous version of this function had a cost that was O(N^2) when the point was not in the cell_hint + object. +
    + (Luca Heltai, 2018/12/05) +
    87. + +
  87. + New: Add LAPACKFullMatrix::transpose() to perform out-of-place transposition. +
    + (Denis Davydov, 2018/12/05) +
    88. + +
  88. + New: Add DEAL_II_LAPACK_WITH_MKL macro which will be set if Intel MKL is being used. +
    + (Denis Davydov, 2018/12/05) +
    89. + +
  89. + Changed: FESeries::Fourier::calculate and FESeries::Legendre::calculate + accept both Vector and Vector as input parameters for + local dof values. +
    + (Marc Fehling, 2018/12/04) +
    90. + +
  90. + New: Added entries to GridTools::Cache to build a vertices RTree, and a bounding boxes RTree. +
    + (Luca Heltai, 2018/12/03) +
    91. + +
  91. + New: Class EllipticalManifold derived from ChartManifold, + valid only for dim=2 and spacedim=2. It maps points from a system of + cartesian coordinates to a system of elliptical coordinates and vice-versa. +
    + (Stefano Dominici, 2018/11/30) +
    92. + +
  92. + New: A new header deal.II/base/undefine_macros.h has been + added. This header, as the name suggests, undefines all deal.II macros that are + not prefixed with either DEAL or deal. +
    + (David Wells, 2018/11/30) +
    93. + +
  93. + Fixed: The MatrixFree::initialize() function would sometimes run into an + assertion when ghost faces occur on subdomain interfaces. This is now fixed. +
    + (Martin Kronbichler, 2018/11/28) +
    94. + +
  94. + New: Triangulation::n_faces, Triangulation::n_active_faces, and Triangulation::n_raw_faces now work also + in one dimension. +
    + (Luca Heltai, 2018/11/22) +
    95. + +
  95. + New: Add support for MPI when using CUDAWrappers::MatrixFree. This only works + with LinearAlgebra::distributed::Vector +
    + (Bruno Turcksin, 2018/11/21) +
    96. + +
  96. + Fixed: The TriaAccessor<0,dim,spacedim> and TriaAccessor<0,1,spacedim> + classes were missing member functions `get_triangulation()` and + `operator<()`. This prevented these objects from being stored in + `std::map`s, among other issues. +
    + (Wolfgang Bangerth, Luca Heltai, 2018/11/20) +
    97. + +
  97. + Fix bug with FEFaceValues initialization when used with the FE_NedelecSZ +
    + (Alexander Grayver, 2018/11/19) +
    98. + +
  98. + New: A new function GridTools::get_coarse_mesh_description has been added. This + function extracts the vertices, CellData, and SubCellData objects from a + Triangulation (i.e., it is the inverse of Triangulation::create_triangulation). +
    + (David Wells, 2018/11/11) +
    99. + +
  99. + Fixed: The operation FEEvaluation::read_dof_values performed invalid array + accesses with AVX512 vectorization in rare circumstances of particular 1d + meshes. This is now fixed. +
    + (Martin Kronbichler, 2018/11/10) +
    100. + +
  100. + Deprecated: The binary Tecplot output using the DataOutBase::tecplot_binary + format has been deprecated. +
    + (Daniel Arndt, 2018/11/10) +
    101. + +
  101. + New: GridOut::write_vtk and GridIn::read_vtk are now compatible with each other, and can be used to save + and restore a Triangulation with all manifold_ids and boundary_ids correctly saved. + This is now the only format that supports both boundary_id and manifold_id both in reading and writing. +
    + (Luca Heltai, 2018/11/07) +
    102. + +
  102. + Improved: The class ArrayView checks the memory location of the data it presents + and gained a template parameter indicating whether the data is stored in CPU or + CUDA memory. +
    + (Daniel Arndt, 2018/11/04) +
    103. + +
  103. + Improved: GridIn::read_msh also support version 4 of MSH file format + extracting the same information as for the older versions. +
    + (Daniel Arndt, 2018/11/04) +
    104. + +
  104. + Fixed: The grid generated by GridGenerator::truncated_cone now uses more level 0 + cells to improve conditioning of cells when they are refined. +
    + (David Wells, 2018/11/03) +
    105. + +
  105. + Changed: The class Subscriptor and SmartPointer check for dangling pointers and + use-after-move. The destructor of Subscriptor doesn't signal an error when there + is still an object subscribed to it. Instead, validity is checked when + dereferencing the SmartPointer object. +
    + (Daniel Arndt, 2018/11/02) +
    106. + +
  106. + Fixed: SparsityPattern::begin() and DynamicSparsityPattern::begin() + resulted in an invalid iterator if the sparsity pattern was actually + empty. +
    + (Wolfgang Bangerth, Denis Davydov, 2018/11/01) +
    107. + +
  107. + New: Add Functions::IncrementalFunction which returns the difference in values of + a given function at two time steps. +
    + (Denis Davydov, Jean-Paul Pelteret, 2018/10/05) +
    108. + +
  108. + New: Classes FESeries::Fourier and FESeries::Legendre now take two + template arguments dim and spacedim, which allow them to use corresponding + hp::FECollection objects. +
    + (Marc Fehling, 2018/10/17) +
    109. + +
  109. + Fixed: The project_boundary_values_div_conforming() function now works correctly + with parallel::distributed::Triangulation. +
    + (Jonathan Matthews, 2018/10/13) +
    110. + +
  110. + New: Functions DoFAccessor::get_active_fe_indices() and + internal::DoFAccessorImplementation::get_active_vertex_fe_indices() + return all active finite element indices on the corresponding object. +
    + (Marc Fehling, 2018/10/08) +
    111. + +
  111. + New: Added RTree class and pack_rtree() function to create a boost::geometry::index::rtree from + containers and/or iterators of BoundingBox, Point, or Segment objects. +
    + (Luca Heltai, 2018/10/06) +
    112. + +
  112. + The computation of normal vectors on very small cells could fail. This is now fixed. +
    + (Timo Heister, 2018/10/05) +
    113. + +
  113. + The class VectorizedArray has gained support for the intrinsics of Altivec + of IBM Power processors. +
    + (Martin Kronbichler, Bruno Turcksin, Sambit Das, 2018/10/05) +
    114. + +
  114. + New: Add inverse_Hilbert_space_filling_curve() to map points in dim-dimensional + space to line index of the Hilbert space filling curve. +
    + (Denis Davydov, 2018/10/05) +
    115. + +
  115. + Deprecated: The Threads::n_existing_threads() and + Threads::this_thread_id() functions have been deprecated. There are + equivalent C++11 functions that provide the same kind of + functionality. +
    + (Wolfgang Bangerth, 2018/10/05) +
    116. + +
  116. + New: There is now a constructor of hp::QCollection that, like the + existing one of hp::FECollection, takes a variable number of + quadrature objects and creates a collection from it. +
    + (Wolfgang Bangerth, 2018/10/04) +
    117. + +
  117. + New: Class parallel::distributed::CellWeights allows to set the + weight of a cell depending on the number of degrees of freedom + associated with it. This guarantees an improved load balancing + in case a hp::DoFHandler is used on a p::d::Triangulation. +
    + (Marc Fehling, 2018/10/01) +
    118. + +
  118. + Removed: The Threads::DummyMutex, Threads::DummyConditionVariable, and + Threads::DummyThreadBarrier classes have been removed. These were only + used if deal.II was compiled without thread support, in which case + certain functionality from the TBB was not available. But the + implementations of the underlying functionality is now unconditionally + available via the C++11 standard library, and so we don't need the + dummy implementations any more. +
    + (Wolfgang Bangerth, 2018/09/27) +
    119. + +
  119. + Deprecated: The Threads::PosixThreadBarrier class and the + corresponding Threads::Barrier `using` declaration are deprecated. The + functionality implemented by these classes is easily replaced by C++11 + functionality. +
    + (Wolfgang Bangerth, 2018/09/27) +
    120. + +
  120. + Deprecated: The Threads::ConditionVariable class is now + deprecated. Use `std::condition_variable` instead. +
    + (Wolfgang Bangerth, 2018/09/27) +
    121. + +
  121. + Deprecated: The Threads::Mutex class is now derived from + std::mutex. As a consequence, the Threads::Mutex::ScopedLock class is + now no longer necessary and is deprecated in favor of std::lock_guard + or any of the other similar classes provided by C++11 and + later. Similarly, the Threads::Mutex::acquire() and + Threads::Mutex::release() functions are deprecated in favor of the + corresponding functions in the std::mutex base class. +
    + (Wolfgang Bangerth, 2018/09/27) +
    122. + +
  122. + New: Support for complex values can be controlled using the CMake flag + DEAL_II_WITH_COMPLEX_VALUES. +
    + (Daniel Arndt, 2019/09/26) +
    123. + +
  123. + Fixed: The GridIn::read_abaqus() function now correctly reads in grids designed + for the co-dimension 1 case (specifically with dim == 2 and spacedim == 3). +
    + (Yuxiang Wang, Jean-Paul Pelteret, 2018/09/20) +
    124. + +
  124. + Fixed: MatrixFree::loop() would not zero a vector if all degrees of freedom + are constrained. This is now fixed. +
    + (Martin Kronbichler, 2018/09/20) +
    125. + +
  125. + New: Add optional flag to ParameterHandler to skip undefined + sections and parameters. +
    + (Denis Davydov, 2018/09/20) +
    126. + +
  126. + New: extend Patterns::Tools::Convert to work with ComponentMask + and std::unique_ptr. +
    + (Denis Davydov, 2018/09/19) +
    127. + +
  127. + New: SolverSelector gained a new constructor initializing the object completely. +
    + (Daniel Arndt, 2018/09/17) +
    128. + +
  128. + New: added the function TrilinosWrappers::MPI::Vector::import() to get data from a ReadWriteVector. +
    + (Timo Heister, 2018/09/16) +
    129. + +
  129. + New: Add line minimization functions. +
    + (Denis Davydov, 2018/09/13) +
    130. + +
  130. + Fixed: make test now runs in parallel automatically (i.e., it uses + a CMake command to determine the number of cores available). Since make + test just immediately invokes ctest as a subprocess, it is + currently not possible to link the number of globally available + make processes with the number of concurrently run tests; i.e., + the number of cores make test uses is not changeable by users. +
    + (David Wells, 2018/09/13) +
    131. + +
  131. + Fixed: VectorTools::project_boundary_values_div_conforming works correctly + in case the DoFHandler object contains more than one FE_RaviartThomas element. +
    + (Daniel Arndt, 2018/09/13) +
    132. + +
  132. + New: The function DoFRenumbering::hierarchical() is now also available + for hp::DoFHandler objects, as well as for DoFHandlers build on + triangulations with `dim != spacedim`. +
    + (Wolfgang Bangerth, 2018/09/06) +
    133. + +
  133. + Added: New function + Utilities::MPI::compute_n_point_to_point_communications() + is implemented to be used for computing number of processes + in an MPI universe to expect communication from. +
    + (Eldar Khattatov, 2018/09/04) +
    134. + +
  134. + New: Utilities::CUDA::allocate_device_data() and + Utilities::CUDA::delete_device_data() help to manage data on CUDA devices + using std::unique_ptr. +
    + (Daniel Arndt, 2018/09/01) +
    135. + +
  135. + Fixed: Member function AffineConstraints::add_entries() now skips already + existing entries. +
    + (Dustin Kumor, 2018/08/24) +
    136. + +
  136. + Fixed: TrilinosWrappers::SparseMatrix::mmult() sometimes gave the wrong result + in parallel. +
    + (Damien Lebrun-Grandie and Bruno Turcksin, 2018/08/22) +
    137. + +
  137. + Fixed: The function Particles::ParticleAccessor::serialize() was + declared but not implemented. This is now fixed. +
    + (Wolfgang Bangerth, 2018/08/21) +
    138. + +
  138. + New: Add a mask argument to filter out some vector lanes in FEEvaluationBase + This is required for local time stepping using the MatrixFree framework, + because some cells of batches must be excluded from read/write operations + when operating on different time steps compared to their neighbor cells. +
    + (Svenja Schoeder, 2018/08/21) +
    139. + +
  139. + New: Table and FullMatrix now have complete (both mutable and const) + random-access iterators. +
    + (David Wells, 2018/08/20) +
    140. + +
  140. + New: CUDAWrappers::PreconditionILU and CUDAWrappers::PreconditionIC can be used + for preconditioning CUDAWrappers::SparseMatrix objects. +
    + (Daniel Arndt, 2018/08/20) +
    141. + +
  141. + New: There are nothrow versions of AssertCUDA and AssertCusparse, namely + AssertNothrowCUDA and AssertNothrowCusparse. +
    + (Daniel Arndt, 2018/08/20) +
    142. + +
  142. + New: There are new methods CUDAWrappers::SparseMatrix::print() and + CUDAWrappers::SparseMatrix::print_formatted(). Additionally, + CUDAWrappers::SparseMatrix gained a move assignment operator. +
    + (Daniel Arndt, 2018/08/20) +
    143. + +
  143. + Fixed: Throwing an exception in Assert doesn't slice objects derived from + ExceptionBase anymore. +
    + (Daniel Arndt, 2018/08/17) +
    144. + +
  144. + New: There is LinearAlgebra::CUDAWrappers::Vector::norm_sqr() for computing + the squared l2-norm and LinearAlgebra::CUDAWrappers::Vector::swap() + for swapping two vectors. +
    + (Daniel Arndt, 2018/08/17) +
    145. + +
  145. + Fixed: CUDAWrappers::Vector performs now a deep copy instead of a shallow copy + in its copy assignment operator. +
    + (Daniel Arndt, 2018/08/16) +
    146. + +
  146. + Fixed: MGConstrainedDofs::initialize(...) now handles refinement edges across periodic boundaries correctly. +
    + (Alexander Knieps, 2018/08/13) +
    147. + +
  147. + Fixed: Bug using ScaLAPACKMatrix::save() and load() for configurations with pHDF5 in combination with serial HDF5 matrices from user code. +
    + (Benjamin Brands, 2018/08/10) +
    148. + +
  148. + Improved: Triangulation::prepare_coarsening_and_refinement also takes care of + limiting the level difference across periodic boundary faces. +
    + (Daniel Arndt, Stefan Kaessmair, 2018/08/09) +
    149. + +
  149. + New: The new function + MatrixFreeOperators::CellwiseInverseMassMatrix::transform_from_q_points_to_basis() + enables to change the basis from a representation in quadrature points into + the original basis of FEEvaluation. +
    + (Martin Kronbichler, 2018/08/06) +
    150. + +
  150. + Improved: FEEvaluation and FEFaceEvaluation have gained support for + renumbering of degrees of freedom for fully discontinuous finite element + spaces which can improve performance by around 10 percent. +
    + (Martin Kronbichler, 2018/08/06) +
    151. + +
  151. + New: Add support for constraint when using matrix-free on GPU. Note you cannot + set constraints in 2D if the degree of the finite element is even. +
    + (Bruno Turcksin, 2018/08/06) +
    152. + +
  152. + New: A convenience function Triangulation::active_face_iterators() (which is like + Triangulation::active_cell_iterators(), but for faces) has been added. +
    + (David Wells, 2018/08/05) +
    153. + +
  153. + Fixed: Minor issues when using matrix-free cell categorization + with multi-grid operators. +
    + (Denis Davydov, 2018/08/02) +
    154. + +
  154. + Fixed: The import function for LinearAlgebra::distributed::Vector would fail if + the IndexSet of the ReadWriteVector has no locally owned element +
    + (Bruno Turcksin, 2018/08/02) +
    155. + +
  155. + New: GridGenerator::merge_triangulations can merge multiple + Triangulation objects at once. +
    + (Daniel Arndt, 2018/08/01) +
    156. + +
  156. + New: LinearAlgebra::distributed::Vector has an extra template parameter + MemorySpace. This new template parameter can be used if the data should be + allocated on the host or on the device. +
    + (Bruno Turcksin, 2018/08/01) +
    157. + +
  157. + Added support for high-order VTU output by using newly + introduced Lagrange VTK cells. +
    + (Alexander Grayver, 2018/08/01) +
    158. + +
  158. + Added support for high-order VTK output by using newly + introduced Lagrange VTK cells. +
    + (Alexander Grayver, 2018/07/27) +
    159. + +
  159. + New: Add FiniteSizeHistory class to store a finite-size history of objects. +
    + (Denis Davydov, 2018/07/26) +
    160. + +
  160. + Deprecate project_boundary_values_curl_conforming in favor + of project_boundary_values_curl_conforming_l2. The former + has a number of known limitations and bugs. +
    + (Alexander Grayver, 2018/07/26) +
    161. + +
  161. + New: Add boost adaptor for dealii::BoundingBox. +
    + (Luca Heltai, 2018/07/24) +
    162. + +
  162. + New: Added geometry adaptors for boost. +
    + (Luca Heltai, Bruno Turcksin, 2018/07/22) +
    163. + +
  163. + New: Add new constructor type for FunctionParser class. +
    + (Luca Heltai, 2018/07/21) +
    164. + +
  164. + Fixed: hp::DoFHandler::distribute_dofs() now works on + parallel::distributed::Triangulation<3> objects that + contain artificial cells. +
    + (Marc Fehling, 2018/07/20) +
    165. + +
  165. + Changed: The Subscriptor class has been made thread-safe, and its behavior in + debug and release modes are now identical. Although this makes subscription and + un-subscription slightly more expensive in release mode, debugging should be + easier overall. +
    + (Jean-Paul Pelteret, 2018/07/15) +
    166. + +
  166. + New: A new function GridGenerator::concentric_hyper_shells has been added. This + function generates a grid comprised of shells of varying widths, where the + shells near the center are much thinner than those near the outer boundary. +
    + (David Wells, 2018/07/15) +
    167. + +
  167. + Fixed: Iterating over the entries of a TrilinosWrappers::SparsityPattern object + in parallel and after calling TrilinosWrappers::SparsityPattern::compress() + works now. +
    + (Mathias Anselmann, Daniel Arndt, 2018/07/11) +
    168. + +
  168. + Fixed: GridTools::delete_duplicated_vertices also treats the SubCellData + object correctly when renumbering the vertices. +
    + (Daniel Arndt, 2018/07/08) +
    169. + +
  169. + New: GridGenerator::merge_triangulations gained an option to copy manifold ids. +
    + (Daniel Arndt, 2018/07/08) +
    170. + +
  170. + New: Add GridGenerator::plate_with_a_hole() that generates a + rectangular plate with an (offset) cylindrical hole. +
    + (Denis Davydov, 2018/06/21) +
    171. + +
  171. + Fixed: The functions FEFaceEvaluation::evaluate and + FEFaceEvaluation::integrate would access invalid memory when only evaluating + function values and using multiple components in 1D. This is now fixed. +
    + (Martin Kronbichler, 2018/07/04) +
    172. + +
  172. + New: The class MatrixFreeFunctions::CellwiseInverseMassMatrix can now also be + used in 1D. +
    + (Martin Kronbichler, 2018/07/04) +
    173. + +
  173. + New: Add support for output of tensor-valued data in + DataOut::write_vtu(). +
    + (Denis Davydov, 2018/06/21) +
    174. + +
  174. + New: Extend get_vector_data_ranges() to return extra element in + the tuple to represent DataComponentInterpretation. The functions + were renamed to get_nonscalar_data_ranges(). +
    + (Denis Davydov, 2018/06/21) +
    175. + +
  175. + Fixed: FETools::back_interpolate can be used + for TrilinosWrappers::MPI::BlockVector. +
    + (Daniel Arndt, 2018/06/20) +
    176. + +
  176. + Changed: Calling GridGenerator::refine_and_coarsen_fixed_fraction() + and GridGenerator::refine_and_coarsen_fixed_fraction() with values for + the coarsen and refine fractions that added to 1.0 in exact + arithmetic, but something slightly larger in floating point + arithmetic, resulted in an error. These functions are now slightly + more relaxed in that they allow arguments that add to 1.0 up to a + small floating point round off error. +
    + (Wolfgang Bangerth, 2018/06/18) +
    177. + +
  177. + New: The LinearAlgebra::distributed::Vector::compress() function has + gained two new combine operations VectorOperation::min and + VectorOperation::max to define the entry at the owning processor as + the minimum/maximum of its own value and the one coming from a ghost. +
    + (Svenja Schoeder, 2018/06/18) +
    178. + +
  178. + Fixed: TrilinosWrappers::MPI::Vector::reinit check now checks if + parallel_partitioner is_ascending_and_one_to_one before calling + make_trilinos_map because make_trilinos_map may be able to make + a linear map if is_ascending_and_one_to_one is true. +
    + (Joshua Hanophy, 2018/06/16) +
    179. + +
  179. + Fixed: The eigenvalue approximation in SolverGMRES failed if no iterations + were performed. Now, there is simply no output in this case. +
    + (Daniel Arndt, 2018/06/15) +
    180. + +
  180. + Bugfix: Fixed bugs for TrilinosWrapper::SparseMatrix::add(factor, other_matrix) + and TrilinosWrapper::SparseMatrix::copy_from(other_matrix) for the case of + non-contiguous rows. +
    + (Uwe Koecher, 2018/06/14) +
    181. + +
  181. + Fixed: Mismatched numbers of components between the exact solution and + underlying FE in Step-51. +
    + (Pi-Yueh Chuang, 2018/06/14) +
    182. + +
  182. + Bugfix: Fixed a bug where VectorDataExchange::ghosts_were_set was + not set inside MatrixFree::cell_loop() for block vectors + with many blocks. +
    + (Denis Davydov, 2018/06/12) +
    183. + +
  183. + Fixed: CMake now supports again in-source builds (This functionality was + accidentally broken in the previous release). +
    + (Matthias Maier, 2018/06/11) +
    184. + +
  184. + Deprecated: FunctionMap is deprecated. It is recommended to + use the aliased type directly. +
    + (Daniel Arndt, 2018/06/11) +
    185. + +
  185. + Fixed: BlockLinearOperator::vmult(), BlockLinearOperator::vmult_add(), + BlockLinearOperator::Tvmult() and BlockLinearOperator::Tvmult_add() + can be used with identical source and destination vectors. +
    + (Daniel Arndt, 2018/06/10) +
    186. + +
  186. + Improved: Extend ScaLAPACKMatrix::invert() to use pXtrtri for inversion of triangular matrices. +
    + (Sambit Das, 2018/06/06) +
    187. + +
  187. + New: TimerOutput::cpu_and_wall_times_grouped will print CPU and + wallclock time in a single table. +
    + (Denis Davydov, 2018/05/29) +
    188. + +
  188. + Improved: TimerOutput now dynamically adjust to the the width of Section column. +
    + (Denis Davydov, 2018/05/29) +
    189. + +
  189. + New: The function GridTools::find_all_active_cells_around_point() returns a + list of all cells around a point, rather than only a single one for the old + GridTools::find_active_cell_around_point. +
    + (Martin Kronbichler, Niklas Fehn, 2018/05/28) +
    190. + +
  190. + Improved: MatrixFree::cell_loop() and MatrixFree::loop() directly use + LinearAlgebra::distributed::BlockVector::update_ghost_values() and + LinearAlgebra::distributed::BlockVector::compress() calls on block vectors + with many blocks, rather than splitting each method into two parts for + overlapping communication and computation. The latter is inefficient as soon + as too many MPI requests are in flight. +
    + (Martin Kronbichler, Denis Davydov, 2018/05/24) +
    191. + +
  191. + Fixed: Step-16 was broken caused by uninitialized variables, it is now fixed. +
    + (Ce Qin, 2018/05/21) +
    192. + +
  192. + Improved: MGTransferPrebuilt now supports + PETScWrappers::MPI::Vector and + PETScWrappers::MPI::SparseMatrix. +
    + (Alexander Knieps, 2018/05/21) +
    193. + +
  193. + Fixed: DoFTools::make_flux_sparsity_pattern was accessing invalid dof indices + in case neighboring cells were not using FiniteElement objects with the same + number of degrees of freedom. This is fixed now. +
    + (Daniel Arndt, 2018/05/19) +
    194. + +
  194. + Fixed: Two invalid off-by-one data accesses in the initialization of + MatrixFree with face data enabled, that appeared in some rare cases on certain + configurations of processors, have been fixed. +
    + (Daniel Arndt, Martin Kronbichler, 2018/05/18) +
    195. + +
  195. + New: Classes that act as an interface to the drivers of internally supported automatic + differentiation libraries (ADOL-C and Sacado) have been implemented. A brief summary + of what these classes are used for is given in the @ref auto_symb_diff module. +
    + (Jean-Paul Pelteret, 2017/11/18) +
    196. + +
+ +*/