SET(_diff_target ${_test_name}.mpirun${_n_cpu}.${_build_lowercase}.diff) # diff target name
SET(_test_full ${_category}/${_test_name}.mpirun=${_n_cpu}.${_build_lowercase}) # full test name
SET(_test_directory ${CMAKE_CURRENT_BINARY_DIR}/${_target}/mpirun=${_n_cpu}) # directory to run the test in
- SET(_run_command mpirun -np ${_n_cpu} ${CMAKE_CURRENT_BINARY_DIR}/${_target}/${_target}) # the command to issue
+ SET(_run_command ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${_n_cpu} ${MPIEXEC_PREFLAGS} ${CMAKE_CURRENT_BINARY_DIR}/${_target}/${_target} ${MPIEXEC_POSTFLAGS}) # the command to issue
ENDIF()
SET_IF_EMPTY(TRILINOS_DIR "$ENV{TRILINOS_DIR}")
#
-# Do not include TrilinosConfig.cmake directly, it is just too big o_O
+# Include the trilinos package configuration:
#
-# Just search for the file:
-#
-FIND_FILE(TRILINOS_CONFIG
- NAMES TrilinosConfig.cmake trilinos-config.cmake
+FIND_PACKAGE(TRILINOS_CONFIG
+ CONFIG QUIET
+ NAMES Trilinos TRILINOS
HINTS
+ ${TRILINOS_DIR}/lib/cmake/Trilinos
${TRILINOS_DIR}
PATH_SUFFIXES
lib64/cmake/Trilinos
lib/cmake/Trilinos
lib${LIB_SUFFIX}/cmake/Trilinos
- include/trilinos
- include/Trilinos
NO_SYSTEM_ENVIRONMENT_PATH
)
SET(TRILINOS_CONFIG_SAVED "${TRILINOS_CONFIG}" CACHE INTERNAL "" FORCE)
-IF(NOT TRILINOS_CONFIG MATCHES "-NOTFOUND")
-
- SET(_filtered_trilinos_config
- "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TrilinosConfig.cmake"
- )
-
- IF(_new_trilinos_config)
- GET_FILENAME_COMPONENT(_trilinos_path "${TRILINOS_CONFIG}" PATH)
- FILE(WRITE ${_filtered_trilinos_config} "SET(_cmake_current_list_dir ${_trilinos_path})\n")
-
- #
- # Only pick up every line that starts with "^SET("...
- #
- FILE(STRINGS "${TRILINOS_CONFIG}" _trilinos_config_filtered REGEX "^SET")
-
- FOREACH(_line ${_trilinos_config_filtered})
- STRING(REPLACE "CMAKE_CURRENT_LIST_DIR" "_cmake_current_list_dir"
- _line "${_line}"
- )
- FILE(APPEND ${_filtered_trilinos_config} "${_line}\n")
- ENDFOREACH()
- ENDIF()
-
- #
- # ... and include only that:
- #
- INCLUDE(${_filtered_trilinos_config})
-
- SET(TRILINOS_CONFIG_FOUND TRUE)
-ENDIF()
-
-
#
# Look for the one include file that we'll query for further information:
#
NO_CMAKE_SYSTEM_PATH
NO_CMAKE_FIND_ROOT_PATH
)
-IF(EPETRA_CONFIG_H MATCHES "-NOTFOUND")
- SET(TRILINOS_CONFIG_FOUND FALSE)
-ELSE()
- SET(TRILINOS_INCLUDE_DIRS ${Trilinos_INCLUDE_DIRS})
- #
- # *Boy* Sanitize the include paths given by TrilinosConfig.cmake...
- #
- STRING(REGEX REPLACE
- "(lib64|lib)\\/cmake\\/Trilinos\\/\\.\\.\\/\\.\\.\\/\\.\\.\\/" ""
- TRILINOS_INCLUDE_DIRS "${TRILINOS_INCLUDE_DIRS}"
- )
-ENDIF()
+
+
+#
+# *Boy* Sanitize the include paths given by TrilinosConfig.cmake...
+#
+SET(TRILINOS_INCLUDE_DIRS ${Trilinos_INCLUDE_DIRS})
+STRING(REGEX REPLACE
+ "(lib64|lib)\\/cmake\\/Trilinos\\/\\.\\.\\/\\.\\.\\/\\.\\.\\/" ""
+ TRILINOS_INCLUDE_DIRS "${TRILINOS_INCLUDE_DIRS}"
+ )
#
MARK_AS_ADVANCED(TRILINOS_LIBRARY_${_library})
- IF(TRILINOS_LIBRARY_${_library} MATCHES "-NOTFOUND")
- SET(TRILINOS_CONFIG_FOUND FALSE)
- ELSE()
- LIST(APPEND TRILINOS_LIBRARIES ${TRILINOS_LIBRARY_${_library}})
- ENDIF()
+ LIST(APPEND TRILINOS_LIBRARIES ${TRILINOS_LIBRARY_${_library}})
+ LIST(APPEND TRILINOS_LIBRARY_VARIABLES TRILINOS_LIBRARY_${_library})
+
ENDFOREACH()
#
FIND_PACKAGE_HANDLE_STANDARD_ARGS(TRILINOS DEFAULT_MSG
TRILINOS_LIBRARIES # cosmetic: Gives nice output
TRILINOS_CONFIG_FOUND
+ EPETRA_CONFIG_H
+ ${TRILINOS_LIBRARY_VARIABLES}
)
MARK_AS_ADVANCED(TRILINOS_CONFIG EPETRA_CONFIG_H)
-
IF(TRILINOS_FOUND)
#
# Extract version numbers:
ELSE()
+ SET(TRILINOS_LIBRARIES)
+ SET(TRILINOS_INCLUDE_DIRS)
+ SET(TRILINOS_CONFIG_SAVED "" CACHE INTERNAL "" FORCE)
+
SET(TRILINOS_DIR "" CACHE PATH
"An optional hint to a Trilinos installation"
)
STRING(REGEX REPLACE "^${_svn_WC_ROOT}/" "" _branch ${_svn_WC_URL})
STRING(REGEX REPLACE "^branches/" "" _branch ${_branch})
+ STRING(REGEX REPLACE "^releases/" "" _branch ${_branch})
STRING(REGEX REPLACE "/deal.II$" "" _branch ${_branch})
+ STRING(REGEX REPLACE "/" "" _branch ${_branch})
SET(CTEST_BUILD_NAME "${CTEST_BUILD_NAME}-${_branch}")
ENDIF()
# TEST_TIME_LIMIT
#
+#
+# Silence warnings:
+#
+FOREACH(_var
+ MPIEXEC MPIEXEC_NUMPROC_FLAG MPIEXEC_POSTFLAGS MPIEXEC_PREFLAGS
+ )
+ SET(${_var} ${${_var}})
+ENDFOREACH()
+
+
#
# Load all macros:
#
LIST(APPEND _options -DDEAL_II_SOURCE_DIR=${CMAKE_SOURCE_DIR})
LIST(APPEND _options -DDEAL_II_BINARY_DIR=${CMAKE_BINARY_DIR})
FOREACH(_var
- DIFF_DIR NUMDIFF_DIR TEST_DIFF TEST_PICKUP_REGEX TEST_TIME_LIMIT
+ DIFF_DIR
+ NUMDIFF_DIR
+ TEST_DIFF
+ TEST_PICKUP_REGEX
+ TEST_TIME_LIMIT
+ MPIEXEC
+ MPIEXEC_NUMPROC_FLAG
+ MPIEXEC_PREFLAGS
+ MPIEXEC_POSTFLAGS
)
# always undefine:
LIST(APPEND _options "-U${_var}")
MESSAGE(STATUS "Setup documentation")
- #
- # Required packages for the document generation:
- #
- FIND_PACKAGE(Perl)
- FIND_PACKAGE(Doxygen)
-
- #
- # Do we have all necessary dependencies?
- #
- IF(NOT PERL_FOUND)
- MESSAGE(FATAL_ERROR
- "Could not find a perl installation which is required for building the documentation"
- )
- ENDIF()
- IF(NOT DOXYGEN_FOUND OR NOT DOXYGEN_DOT_FOUND)
- MESSAGE(FATAL_ERROR
- "Could not find doxygen and dot which is required for building the documentation"
- )
- ENDIF()
-
- #
- # Generate the source documentation via doxygen:
- #
ADD_SUBDIRECTORY(doxygen)
- ADD_DEPENDENCIES(documentation doxygen)
#
# Install the static elements of the html documentation:
interface, FE_Nedelec for arbitrary polynomial degrees.
<li><em>Daniel Arndt:</em>
- FE_Q_DG0 element, ConstraintMatrix fixes, linear algebra.
+ FE_Q_DG0 element, ConstraintMatrix fixes, linear algebra, periodicity, bug fixes.
<li><em>Juan Carlos Araujo Cabarcas:</em>
Work on ARPACK.
Step-25 tutorial program.
<li><em>Chih-Che Chueh:</em>
- Step-43 tutorial program.
+ Step-43 tutorial program. Bug fixes.
<li><em>Denis Davydov:</em>
- FEValuesExtractors::Tensor and associated functionality, various other changes.
+ FEValuesExtractors::Tensor and associated functionality, bug fixes, various other changes.
<li><em>Kevin Dugan:</em>
Fixes in VectorTools::interpolate.
Lots of work on multigrid for adaptive meshes; multigrid in the
MeshWorker framework; step-16. Various fixes.
+ <li><em>Armin Ghajar Jazi:</em>
+ Small fixes.
+
<li><em>Xing Jin:</em>
step-24 tutorial program.
framework. step-37 and step-48 tutorial programs.
<li><em>Oleh Krehel:</em>
- Many documentation fixes.
+ Documentation fixes, small fixes.
<li><em>Tobias Leicht:</em>
Lots of work on internal data structures: anisotropic refinement
<li><em>Andrew McBride:</em>
FEValues extractors for symmetric tensors. step-44.
+ <li><em>Craig Michoski:</em>
+ Periodic boundaries
+
<li><em>Scott Miller:</em>
- Enhancements to FE_Nothing.
+ Enhancements to FE_Nothing, step-51, many smaller fixes.
<li><em>Helmut Müller:</em>
Multiprocessor detection on Mac OS X.
throughout the library.
<li><em>Jean-Paul Pelteret:</em>
- step-44, linear algebra.
+ step-44, linear algebra, bug fixes.
<li><em>Jonathan Pitt:</em>
Enhancements to FE_Nothing. Changes in a variety of places.
<li><em>Florian Prill:</em>
Gauss Lobatto quadrature, random bug fixes.
+ <li><em>Andreas Putz:</em>
+ GridIn::read_vtk().
+
<li><em>Daniel Castanon Quiroz:</em>
Torus domain and boundary.
refinement functions;
MinRes linear solver.
+ <li><em>Mayank Sabharwal:</em>
+ GridIn::read_vtk().
+
<li><em>Abner Salgado-Gonzalez:</em>
step-35 tutorial program. Other fixes.
This sets up all cached variables prior to the call to
<code>PROJECT(deal.II)</code>. For details see the comment at the
top. Furthermore, some bookkeeping for compiler and linker flags
- takes place, see <a href="cmake.html#configurebuild">the section
+ takes place, see <a href="../users/cmake.html#configurebuild">the section
about compile flags</a>.
<li> <code>setup_deal_ii.cmake</code>:
This file is included immediately after the call to
module is used to determine whether an external dependency can be
resolved or not. Depending on the current state of
<code>DEAL_II_WITH_<FEATURE></code> (see
- <a href="cmake.html#configurefeature">here</a>) the variables
+ <a href="../users/cmake.html#configurefeature">here</a>) the variables
<pre>
FEATURE_LIBRARIES
FEATURE_INCLUDE_DIRS
<b><small>Online Resources</small></b>
<p>
<a href="http://www.dealii.org/websvn/log.php?repname=deal.II+Repository&path=%2F&isdir=1&" target="_top">Recent changes</a><br />
+ <a href="http://cdash.kyomu.43-1.org/index.php?project=deal.II" target="body">CDash</a><br />
<a href="http://www.dealii.org/cgi-bin/regression_quick.pl" target="body">Regression tests</a><br />
- <a href="http://www.dealii.org//cgi-bin/build.pl" target="body">Build tests</a><br />
- <a href="http://www.math.tamu.edu/~heister/bench" target="body">Performance tests</a><br />
+ <a href="http://www.math.clemson.edu/~heister/bench" target="body">Performance tests</a><br />
</p>
<hr>
- The source directory of deal.II (usually ending in "[...]/deal.II"
(equivalent to https://svn.dealii.org/trunk/deal.II)
Note: This is _not_ the test directory ending in "[...]/tests"
- - If unspecified, "../deal.II" and "../../$ relative to the location
+ - If unspecified, "../deal.II" and "../../" relative to the location
of this script is used. If this is not a source directory, an error
thrown.
<p>Running the build test suite is simple and we encourage deal.II
users with configurations not found on the <a
- href="http://www.dealii.org/testsuite.html">test suite page</a> to
+ href="http://cdash.kyomu.43-1.org/index.php?project=deal.II">CDash page</a> to
participate. Assuming you checked out deal.II into the directory
<code>deal.II</code>, running it is as simple as:
<pre>
<h2>Resources</h2>
<ul>
-<li> <p><a
- href="http://www.dealii.org/cgi-bin/regression_quick.pl"
- target="body">Results of regression tests:</a> Every night,
- the regression tests are run on some of our machines. The log of the
- results can be seen here.
- </p>
-
-<li> <p><a href="http://www.dealii.org//cgi-bin/build.pl">
- Results of build tests:</a> We also build the library each night on
- a variety of computers, using different compilers. The results of
- these builds is listed as well.
- </p>
-
-<li> <p><a href="http://www.math.tamu.edu/~heister/bench">
+ <li>
+ <p>
+ <a href="http://cdash.kyomu.43-1.org/index.php?project=deal.II"
+ target="body">CDash:</a> The CDash instance is the central place where
+ all test results for regression and build tests are gathered.
+ </p>
+ <li>
+ <p>
+ <a href="http://www.dealii.org/cgi-bin/regression_quick.pl"
+ target="body">Regression tests:</a>
+ An overview of results from a blessed regression tester that tests
+ every single svn revision is available at this place
+ </p>
+
+ <li>
+ <p>
+ <a href="http://www.math.clemson.edu/~heister/bench">
Results of benchmarks:</a> We run a certain number of tests
and track the performance over time.
- </p>
+ </p>
</ul>
<hr />
##
## ---------------------------------------------------------------------
+#
+# Generate the source documentation via doxygen:
+#
+
+FIND_PACKAGE(Perl)
+FIND_PACKAGE(Doxygen)
+
+#
+# Do we have all necessary dependencies?
+#
+IF(NOT PERL_FOUND)
+ MESSAGE(FATAL_ERROR
+ "Could not find a perl installation which is required for building the documentation"
+ )
+ENDIF()
+IF(NOT DOXYGEN_FOUND)
+ MESSAGE(FATAL_ERROR
+ "Could not find doxygen which is required for building the documentation"
+ )
+ENDIF()
+
#
# A glob. I'm sorry
#
# Prepare the example steps for doxygen:
#
ADD_SUBDIRECTORY(tutorial) # uses ${DEAL_II_STEPS}
-ADD_SUBDIRECTORY(images)
#
# Prepare auxiliary files for doxygen:
${CMAKE_CURRENT_BINARY_DIR}/options.dox
)
-CONFIGURE_FILE(
- ${CMAKE_CURRENT_SOURCE_DIR}/deal.css
- ${CMAKE_CURRENT_BINARY_DIR}/deal.II/deal.css
- COPYONLY
- )
-
-CONFIGURE_FILE(
- ${CMAKE_CURRENT_SOURCE_DIR}/stylesheet.css
- ${CMAKE_CURRENT_BINARY_DIR}/stylesheet.css
- COPYONLY
- )
-
-CONFIGURE_FILE(
- ${CMAKE_CURRENT_SOURCE_DIR}/images/logo200.png
- ${CMAKE_CURRENT_BINARY_DIR}/logo200.png
- COPYONLY
- )
-
CONFIGURE_FILE(
${CMAKE_CURRENT_SOURCE_DIR}/scripts/mod_header.pl.in
${CMAKE_CURRENT_BINARY_DIR}/scripts/mod_header.pl
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
DEPENDS
tutorial
- images
${CMAKE_CURRENT_BINARY_DIR}/options.dox
${CMAKE_CURRENT_BINARY_DIR}/header.html
${CMAKE_CURRENT_BINARY_DIR}/footer.html
ADD_CUSTOM_TARGET(doxygen ALL
DEPENDS ${CMAKE_BINARY_DIR}/doxygen.log
)
+ADD_DEPENDENCIES(documentation doxygen)
INSTALL(FILES
${CMAKE_CURRENT_BINARY_DIR}/deal.tag
- ${CMAKE_CURRENT_SOURCE_DIR}/stylesheet.css
DESTINATION ${DEAL_II_DOCHTML_RELDIR}/doxygen
COMPONENT documentation
)
+++ /dev/null
-//
-// Copyright (C) 1998 - 2013 by the deal.II authors
-//
-
-table.tutorial {
- color: black;
- border: 1px solid #aaa;
- background-color: #f9f9f9;
- padding: 5px;
- font-size: 95%;
-}
-h3 {
- font-size: 120%;
- text-decoration:underline;
-}
-h4 {
- font-size: 100%;
-}
* relatively independent jobs: for example, assembling local
* contributions to the global linear system on each cell of a mesh;
* evaluating an error estimator on each cell; or postprocessing on
- * each cell computed data for output fall into this class.
+ * each cell computed data for output fall into this class. These
+ * cases can be treated using a software design pattern we call
+ * "%WorkStream". In the following, we will walk through the rationale
+ * for this pattern and its implementation; more details as well as
+ * examples for the speedup that can be achieved with it are given in
+ * the @ref workstream_paper .
*
* Code like this could then be written like this:
* @code
*
* As a final point: What if, for some reason, my assembler and copier
* function do not match the above signature with three and one argument,
- * respectively? That's not a problem either. The WorkStream class offers two
+ * respectively? That's not a problem either. The WorkStream namespace offers two
* versions of the WorkStream::run() function: one that takes an object and
* the addresses of two member functions, and one that simply takes two
* function objects that can be called with three and one argument,
// ...is the same as:
WorkStream::run (dof_handler.begin_active(),
dof_handler.end(),
- std_cxx1x::bind(&MyClass<dim>::assemble_on_one_cell, *this,
- std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3),
- std_cxx1x::bind(&MyClass<dim>::copy_local_to_global, *this, std_cxx1x::_1),
+ std_cxx1x::bind(&MyClass<dim>::assemble_on_one_cell,
+ *this,
+ std_cxx1x::_1,
+ std_cxx1x::_2,
+ std_cxx1x::_3),
+ std_cxx1x::bind(&MyClass<dim>::copy_local_to_global,
+ *this,
+ std_cxx1x::_1),
per_task_data);
* @endcode
* Note how <code>std_cxx1x::bind</code> produces a function object that takes three
WorkStream::run (dof_handler.begin_active(),
dof_handler.end(),
std_cxx1x::bind(&MyClass<dim>::assemble_on_one_cell,
- *this,
- current_solution,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3,
- previous_time+time_step),
+ *this,
+ current_solution,
+ std_cxx1x::_1,
+ std_cxx1x::_2,
+ std_cxx1x::_3,
+ previous_time+time_step),
std_cxx1x::bind(&MyClass<dim>::copy_local_to_global,
- *this, std_cxx1x::_1),
+ *this,
+ std_cxx1x::_1),
per_task_data);
* @endcode
* Here, we bind the object, the linearization point argument, and the
* current time argument to the function before we hand it off to
* WorkStream::run(). WorkStream::run() will then simply call the
* function with the cell and scratch and per task objects which will be filled
- * in at the positions indicated by <code>std_cxx1x::_1, std_cxx1x::_2</code> and <code>std_cxx1x::_3</code>.
+ * in at the positions indicated by <code>std_cxx1x::_1, std_cxx1x::_2</code>
+ * and <code>std_cxx1x::_3</code>.
*
* There are refinements to the WorkStream::run function shown above.
* For example, one may realize that the basic idea above can only scale
+++ /dev/null
-## ---------------------------------------------------------------------
-## $Id$
-##
-## Copyright (C) 2013 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 at
-## the top level of the deal.II distribution.
-##
-## ---------------------------------------------------------------------
-ADD_CUSTOM_COMMAND(
- OUTPUT
- ${CMAKE_CURRENT_BINARY_DIR}/structure.png
- ${CMAKE_CURRENT_BINARY_DIR}/structure.cmapx
- COMMAND ${DOXYGEN_DOT_EXECUTABLE}
- -Tpng -o ${CMAKE_CURRENT_BINARY_DIR}/structure.png
- -Tcmapx -o ${CMAKE_CURRENT_BINARY_DIR}/structure.cmapx
- ${CMAKE_CURRENT_SOURCE_DIR}/structure.dot
- DEPENDS
- ${CMAKE_CURRENT_SOURCE_DIR}/structure.dot
- )
-
-ADD_CUSTOM_TARGET(images
- DEPENDS
- ${CMAKE_CURRENT_BINARY_DIR}/structure.png
- ${CMAKE_CURRENT_BINARY_DIR}/structure.cmapx
- )
+++ /dev/null
-digraph G
-{
- graph[rankdir="TB",aspect=1.5,bgcolor="transparent"];
-
- edge [fontname="FreeSans",fontsize=10,labelfontname="FreeSans",labelfontsize=10];
- node [fontname="FreeSans",fontsize=10,
- shape=record,height=0.2,width=0.4,
- color="black", fillcolor="white", style="filled"];
-
- FE [label="FiniteElement",URL="../deal.II/group_fe.html"];
- Tria [label="Triangulation",URL="../deal.II/group_grid.html"];
- DoFHandler [label="DoFHandler",URL="../deal.II/group_dofs.html"];
- Quadrature [label="Quadrature",URL="../deal.II/group_Quadrature.html"];
- Mapping [label="Mapping",URL="../deal.II/group_mapping.html"];
- FEValues [label="FEValues",URL="../deal.II/group_feaccess.html"];
-# MeshWorker [label="MeshWorker",URL="../deal.II/group_MeshWorker.html"];
-# Forms [label="(Bi-)Linear Forms",URL="../deal.II/group_Integrators.html"];
- Linear [label="Discrete System",URL="../deal.II/group_LAC.html"];
- LinearSolver [label="Solver",URL="../deal.II/group_Solvers.html"];
- Output [label="Output",URL="../deal.II/group_output.html"];
-
- Tria -> DoFHandler [color="black",fontsize=10,style="solid",fontname="FreeSans"];
-# Tria -> FEValues [color="black",fontsize=10,style="solid",fontname="FreeSans"];
- FE -> DoFHandler [color="black",fontsize=10,style="solid",fontname="FreeSans"];
- FE -> FEValues [color="black",fontsize=10,style="solid",fontname="FreeSans"];
- Mapping -> FEValues [color="black",fontsize=10,style="solid",fontname="FreeSans"];
- Quadrature -> FEValues [color="black",fontsize=10,style="solid",fontname="FreeSans"];
- FEValues -> Linear [color="black",fontsize=10,style="solid",fontname="FreeSans"];
-# FEValues -> MeshWorker [color="black",fontsize=10,style="solid",fontname="FreeSans"];
-# FEValues -> Forms [color="black",fontsize=10,style="solid",fontname="FreeSans"];
-# Forms -> MeshWorker [color="black",fontsize=10,style="solid",fontname="FreeSans"];
- DoFHandler -> Linear [color="black",fontsize=10,style="solid",fontname="FreeSans"];
-# DoFHandler -> MeshWorker [color="black",fontsize=10,style="solid",fontname="FreeSans"];
-# MeshWorker -> Linear [color="black",fontsize=10,style="solid",fontname="FreeSans"];
- Linear -> LinearSolver [color="black",fontsize=10,style="solid",fontname="FreeSans"];
- LinearSolver -> Output [color="black",fontsize=10,style="solid",fontname="FreeSans"];
-}
PROJECT_NAME = "The deal.II Library"
PROJECT_NUMBER = "Reference documentation for deal.II version @DEAL_II_PACKAGE_VERSION@"
-PROJECT_LOGO = "logo200.png"
+PROJECT_LOGO = @CMAKE_CURRENT_SOURCE_DIR@/images/logo200.png
OUTPUT_DIRECTORY = .
# The doxygen documentation says this about the following flag:
MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
HTML_COLORSTYLE_HUE = 220
HTML_COLORSTYLE_SAT = 200
-HTML_EXTRA_STYLESHEET = stylesheet.css
+HTML_EXTRA_STYLESHEET = @CMAKE_CURRENT_SOURCE_DIR@/stylesheet.css
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
if (m'</head>')
{
- print '<link href="$relpath$deal.css" rel="stylesheet" type="text/css"></link>', "\n";
print '<link rel="SHORTCUT ICON" href="http://www.dealii.org/deal.ico"></link>', "\n";
print '<meta name="author" content="The deal.II Authors <authors@dealii.org>"></meta>', "\n";
print '<meta name="copyright" content="Copyright (C) 1998 - ', $year, ' by the deal.II authors"></meta>', "\n";
* <code>cmake .</code>, build it via <code>make</code> and run it using
* <code>make run</code>. The latter command also compiles the program if
* that has not already been done. The CMakefiles.txt files in the
- * different directories are based on the small program Makefile template
- * described <a href="../../user/cmakelists.html" target="_top">in this
- * section</a>.
+ * different directories are based on the
+ * <a href="../../users/cmakelists.html" target="_top">small program Makefile template</a>.
*
* <a name="graph"></a>
* <h3>Connections between tutorial programs</h3>
* </tr>
*
* </table>
- * <h4><b>Vector problems</b></h4>
+ * <h4><b>%Vector problems</b></h4>
* <table align="center" width="90%">
*
* <tr valign="top">
--- /dev/null
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2013 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 at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+/**
+ * @page changes_between_8_0_and_8_1 Changes between Version 8.0 and 8.1
+
+<p>
+This is the list of changes made between the release of
+deal.II version 8.0.0 and that of 8.1.0.
+All entries are signed with the names of the author.
+</p>
+
+
+
+<!-- ----------- INCOMPATIBILITIES ----------------- -->
+
+<a name="incompatible"></a>
+<h3 style="color:red">Incompatibilities</h3>
+
+<p style="color:red">
+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.
+</p>
+
+<ol>
+ <li>Changed: During the implementation of the 64-bit features for deal.II
+ 8.0, many linear algebra classes obtained a local typedef
+ <code>size_type</code> indicating the integer type that is used to index
+ into them. In some instances, this was accidentally set to
+ <code>types::global_dof_index</code> (which may be a 64-bit data type)
+ even in cases where this is clearly not going to work, for example for
+ FullMatrix::size_type, since we will not be able to store full matrix
+ objects of sizes for which a 32-bit index type is not sufficient. In
+ these cases, the typedef was reverted to just <code>unsigned int</code>.
+ <br>
+ (Wolfgang Bangerth, 2013/12/04)
+ </li>
+
+ <li> Removed: With the switch of the testsuite to CMake, the old report_features
+ and build test facilities are removed.
+ <br>
+ (Matthias Maier, 2013/12/03)
+ </li>
+
+ <li>
+ Changed: The kinds of template arguments for the VectorTools::interpolate
+ function taking a Mapping as first argument has changed. This was done to
+ work around a bug in the Intel ICC compiler which led to linker errors. Since
+ the actual function argument list remains unchanged, the only way you will
+ notice this change is if you <i>explicitly</i> specify template arguments.
+ The only place one would typically do that is if you take the address of
+ a template function. Since this is not a common operation, the impact of this
+ change is probably limited.
+ <br>
+ (Wolfgang Bangerth, 2013/11/27)
+ </li>
+
+ <li>
+ Changed: The ghost handling of the parallel::distributed::Vector class has
+ been reworked: The vector now carries a global state that stores whether
+ ghost elements have been updated or not. If a vector has ghost elements, it
+ does not allow calls to compress() any more. Instead, a compress operation
+ can now only be done when the ghost entries have been cleared before by
+ calling zero_out_ghosts() or operator=0. The state can be queried by the new
+ method has_ghost_elements(). This change avoids spurious entries to be
+ inserted with compress(), but requires some change in user codes. The
+ behavior of a ghosted vector is now very similar to ghosted PETSc and
+ Trilinos vectors. The only difference is that the <i>same</i> vector can
+ also be used as a non-ghosted vector which is designed for use in assembly
+ routines.
+ <br>
+ (Martin Kronbichler, 2013/10/18)
+ </li>
+
+ <li>
+ Removed: GridTools::collect_periodic_face_pairs. This function is superseded
+ by GridTools::collect_periodic_faces which exports an
+ std::vector<PeriodicFacepair<...>> instead.
+ <br>
+ (Matthias Maier, 2013/09/30)
+ </li>
+
+ <li>
+ Removed: The member function face_to_equivalent_cell_index() in
+ FiniteElementData has been removed. It had been deprecated a while
+ back already. Please use FiniteElement::face_to_cell_index() instead.
+ <br>
+ (Wolfgang Bangerth, 2013/08/09)
+ </li>
+
+ <li>
+ Changed: The typedefs DataOut::cell_iterator and
+ DataOut::active_cell_iterator were previously defined as
+ DoFHandler::(active)_cell_iterator, while they are now
+ Triangulation::(active)_cell_iterator. This is necessary to support DataOut
+ on multiple DoFHandler objects. This affects possible overloading of
+ DataOut::next_cell(cell_iterator). Use the typedef
+ DataOut::(active)_cell_iterator as argument type instead.
+ <br>
+ (Martin Kronbichler, 2013/07/24)
+ </li>
+</ol>
+
+
+<!-- ----------- GENERAL IMPROVEMENTS ----------------- -->
+
+<a name="general"></a>
+<h3>General</h3>
+
+
+<ol>
+ <li> Improved: The build system now supports usage of the library
+ out of the build directory without prior installation. This is done by
+ exporting an additional project configuration just for the build directory.
+ Furthermore, a bunch of convenience targets get now defined that just build
+ individual components (such as just the documentation or the libraries), and
+ if <tt>CMAKE_INSTALL_PREFIX</tt> is set, also install that specific component.
+ <br>
+ (Matthias Maier, Luca Heltai, 2013/12/03)
+ </li>
+
+ <li> Fixed: Missing instantiations of SparseDirectMUMPS have been added.
+ <br>
+ (Timo Heister, 2013/11/25)
+ </li>
+
+ <li> New: introduced "make test" that runs a minimal set of tests. We
+ encourage every user to run this, especially if they run in to problems.
+ The tests are automatically picked depending on the configuration and
+ will be shipped with every release.
+ <br>
+ (Timo Heister, Matthias Maier, 2013/11/08)
+ </li>
+
+ <li> Changed: It is now possible to restore a parallel Triangulation
+ (and solutions) with a different number of processors it was saved with
+ using Triangulation::save() and Triangulation::load().
+ <br>
+ (Timo Heister, 2013/11/02)
+ </li>
+
+ <li> Added support for Windows: It is now possible again to use gcc on Windows
+ in order to compile the library. We support gcc-4.8.1 on Cygwin64 and MinGW-w64.
+ <br>
+ (Matthias Maier, 2013/11/01)
+ </li>
+
+ <li> Changed: step-9, step-13 and step-14 have been converted to use the
+ more modern WorkStream concept for assembling linear systems and computing
+ error indicators in parallel.
+ <br>
+ (Bruno Turcksin, Wolfgang Bangerth, 2013/10/26)
+ </li>
+
+ <li> New: The testsuite is now ported to <a href="http://www.cmake.org/">
+ CMake</a> and uses CTest as test driver.
+ <br>
+ (Wolfgang Bangerth, Timo Heister, Matthias Maier, Bruno Turcksin, 2013/10/20)
+ </li>
+
+ <li>
+ Changed: multithreadinfo::n_default_threads is now deprecated. Use the
+ new n_threads() function instead, which works correctly with TBB.
+ <br>
+ (Timo Heister, 2013/10/02)
+ </li>
+
+ <li>
+ Changed: if configured with TBB but the number of threads is set to 1,
+ do not bother to use TBB in workstream.
+ <br>
+ (Timo Heister, 2013/10/02)
+ </li>
+
+ <li>
+ New: step-51 demonstrates the use of hybridized discontinuous Galerkin
+ methods in deal.II, using the face elements FE_FaceQ. The programs solves a
+ scalar convection-diffusion equation.
+ <br>
+ (Martin Kronbichler and Scott Miller, 2013/10/01)
+ </li>
+
+ <li>
+ New: There is now an element FE_FaceP that can be combined with FE_DGP in
+ hybridized DG methods.
+ <br>
+ (Martin Kronbichler, 2013/09/17)
+ </li>
+
+ <li>
+ Fixed: The DataOutBase::XDMFEntry class now has a proper serialization
+ function to allow for checkpointing.
+ <br>
+ (Eric Heien, 2013/09/27)
+ </li>
+
+ <li>
+ New: DataOutBase::DataOutFilter provides a way to remove duplicate vertices
+ and values from a solution vector when generating output. Currently it only
+ supports HDF5/XDMF output.
+ <br>
+ (Eric Heien, 2013/09/27)
+ </li>
+
+ <li>
+ Removed: DataOutBase::HDF5MemStream was removed and the functionality replaced
+ by DataOutBase::DataOutFilter. The user only manipulates these through
+ DataOutBase::write_hdf5_parallel so this change should be transparent.
+ <br>
+ (Eric Heien, 2013/09/27)
+ </li>
+
+ <li>
+ New: Like the usual DoFHandler class, the hp::DoFHandler class now also
+ has a cache that makes operations such as <code>cell-@>get_dof_indices(...)</code>
+ faster. This should accelerate many parts of the library that deal with
+ hp finite elements.
+ <br>
+ (Wolfgang Bangerth, 2013/09/10)
+ </li>
+
+ <li>
+ New: parallel::distributed::Triangulation now supports periodic boundaries.
+ DoFTools::make_periodicity_constraints and similar functions are now working
+ on parallel::distributed::Triangulation objects.
+ <br>
+ (Tobin Isaac, Craig Michoski, Daniel Arndt, 2013/09/06)
+ </li>
+
+ <li>
+ New: It is now possible to compile and link deal.II against LLVM's libcxx. For
+ this, a few issues with C++ standard violations are resolved.
+ <br>
+ (Matthias Maier, 2013/08/09)
+ </li>
+</ol>
+
+
+<!-- ----------- SPECIFIC IMPROVEMENTS ----------------- -->
+
+<a name="specific"></a>
+<h3>Specific improvements</h3>
+
+<ol>
+ <li> Fixed: Since the introduction of ThreadLocalStorage in version 8.0, the
+ way in which FEValues objects visit cells in a parallel assembly loop is no
+ longer deterministic. Therefore, the detection of CellSimilarity that can
+ speed up computations of certain geometric quantities (shape gradients) on
+ cells that are translations is disabled when the number of threads is
+ greater than one. This produces somewhat slower code (usually not more than
+ a few percent) but ensures exact reproducibility of results.
+ <br>
+ (Martin Kronbichler, Wolfgang Bangerth, 2013/12/09)
+ </li>
+
+ <li> Fixed: Several functions in namespace GridTools were not instantiated
+ for parallel::distributed::Triangulation objects. This is now fixed.
+ <br>
+ (Denis Davydov, Wolfgang Bangerth, 2013/12/01)
+ </li>
+
+ <li> Improved: The methods ConstraintMatrix::distribute_local_to_global
+ now use scratch data that is private to each thread instead of allocating
+ it for every cell anew. This gives better performance, in particular in
+ parallel, of these operations, while maintaining thread-safety (when
+ accessing non-overlapping rows, no race condition can exist).
+ <br>
+ (Martin Kronbichler, 2013/12/03)
+ </li>
+
+ <li> Improved: When attempting operations such as FEValues::get_function_values()
+ or FEValues::shape_value(), the FEValues object needs to know that what these
+ functions return has been computed previously. What is computed is specified
+ by the update flags that are passed to the constructor of all FEValues, FEFaceValues
+ and FESubfaceValues objects. If a user attempts an operation for which the
+ corresponding flag was not specified, an exception is generated. This exception
+ did say previously what the cause was, but it was not overly explicit.
+ The exception now generates a message that says exactly what is going wrong.
+ <br>
+ (Wolfgang Bangerth, 2013/12/01)
+ </li>
+
+ <li> Fixed: GridGenerator::truncated_cone() failed if half_length < 0.5*radius in 3d.
+ <br>
+ (Timo Heister, 2013/11/25)
+ </li>
+
+ <li> Fixed: make_hanging_node_constraints failed with an exception in a
+ parallel::distributed computation if the element is
+ RaviartThomas (and probably others).
+ <br>
+ (Timo Heister, 2013/11/23)
+ </li>
+
+ <li> Improved: CMake: Added a configuration check for incompatible ninja
+ + icc setup, fixed several setup and performance issues with the
+ testsuite.
+ <br>
+ (Matthias Maier, 2013/11/20)
+ </li>
+
+ <li> Changed: when a dealii::Exception is thrown, defer the symbol lookup of the
+ stack trace to when it is needed. This improves performance if what() is never
+ called.
+ <br>
+ (Timo Heister, 2013/11/17)
+ </li>
+
+ <li> Fixed: GridGenerator::parallelogram was not instantiated properly
+ when using intel compilers.
+ <br>
+ (Timo Heister, 2013/11/17)
+ </li>
+
+ <li>
+ Fixed: MappingQ1::transform_real_to_unit_cell() could fail in some
+ cases with very elongated and twisted cells. This should now be fixed
+ with an algorithm that uses a better method of computing the Newton
+ convergence.
+ <br>
+ (Wolfgang Bangerth, 2013/11/17)
+ </li>
+
+ <li>
+ Fixed: VectorTools::compute_no_normal_flux_constraints had a bug that
+ only appeared in rare cases at vertices of the domain if one adjacent
+ cell had two boundary indicators selected for no normal flux and another
+ had only one. This is now fixed.
+ <br>
+ (Wolfgang Bangerth, 2013/11/17)
+ </li>
+
+ <li> Fixed: dealii::FETools::interpolation_difference was
+ not working for TrilinosWrappers::MPI::Vectors with ghost
+ entries. The TrilinosWrappers::VectorBase class has now a
+ get_mpi_communicator method similar to the PETSc vector
+ classes.
+ <br>
+ (Martin Steigemann, Martin Kronbichler, 2013/11/17)
+ </li>
+
+ <li> Fixed: Bundled fparser is now compiled with FP_USE_THREAD_SAFE_EVAL in
+ case of enabled threading support so that it is thread safe.
+ <br>
+ (Matthias Maier, reported by Francesco Cattoglio 2013/11/16)
+ </li>
+
+ <li> Fixed: The CellData class now has a default constructor that
+ sets the material and boundary indicators to zero. This fixes certain
+ internal errors with the Intel ICC compiler.
+ <br>
+ (Wolfgang Bangerth, 2013/11/13)
+ </li>
+
+ <li> Cleanup: Removed obsolete files and files with unknown licensing
+ status from the source tree. Along the way, parameter_gui now uses
+ default icons from the desktop environment instead of bundled ones.
+ <br>
+ (Matthias Maier, 2013/11/11)
+ </li>
+
+ <li> New: There is now a framework for coloring graphs, with functions
+ in namespace GraphColoring.
+ <br>
+ (Bruno Turcksin, Martin Kronbichler, 2013/11/06)
+ </li>
+
+ <li>
+ Fixed: the DerivativeApproximation class was not working correctly when
+ used with parallel vectors.
+ (Timo Heister, 2013/10/28)
+ </li>
+
+ <li>
+ ~Subscriptor and ~GrowingVectorMemory no longer throw an exception (the
+ former if disable_abort_on_exception was called) to be compatible with the
+ C++11 standard which otherwise requires the program to immediately call
+ std::terminate. This was done with a new macro "AssertNothrow".
+ <br>
+ (Wolfgang Bangerth, Matthias Maier, Bruno Turcksin 2013/10/22)
+ </li>
+
+ <li>
+ dealii::SolverControl::NoConvergence now inherits dealii::ExceptionBase and
+ is thrown via AssertThrow(false, ... ).
+ <br>
+ (Matthias Maier, 2013/10/20)
+ </li>
+
+ <li>
+ New: parallel::distributed::BlockVector has now methods update_ghost_values,
+ compress, zero_out_ghosts, and has_ghost_elements that do the respective
+ operation on each block of parallel::distributed::Vector.
+ <br>
+ (Martin Kronbichler, 2013/10/18)
+ </li>
+
+ <li>
+ Fixed: When deriving from DataOut to filter the cells where output is generated, there were two different bugs that result in segmentation faults or wrong cells written (example, step-18).
+ <br>
+ (Timo Heister, 2013/10/16)
+ </li>
+
+ <li>
+ New: GridIn::read_vtk() reads 2d and 3d meshes in VTK format.
+ <br>
+ (Mayank Sabharwal, Andreas Putz, 2013/10/07)
+ </li>
+
+ <li>
+ Fixed: ConstraintMatrix would not compress() the IndexSet in the constructor
+ leading to crashes that only happen in release mode. This is now fixed.
+ <br>
+ (Timo Heister, 2013/09/27)
+ </li>
+
+ <li>
+ Fixed: PetscWrappers::MatrixBase::row_length() no longer worked after recent changes
+ to PETSc (around PETSc release 3.4). This is now fixed.
+ <br>
+ (Wolfgang Bangerth, 2013/09/24)
+ </li>
+
+ <li>
+ New: Added write_visit_record that allows writing .visit files with multiple blocks
+ and multiple time steps.
+ <br>
+ (Fahad Alrashed, 2013/09/21)
+ </li>
+
+ <li>
+ Changed: GridTools::have_same_coarse_mesh was only instantiated for
+ MGDoFHandler arguments in debug mode. This is now fixed.
+ <br>
+ (Timo Heister, 2013/09/20)
+ </li>
+
+ <li>
+ Changed: GridTools::find_active_cell_around_point now throws the exception
+ GridTools::ExcPointNotFound
+ if the point is outside the Triangulation. This exception can be caught.
+ <br>
+ (Timo Heister, 2013/09/18)
+ </li>
+
+ <li>
+ Changed: we now call MPI_Init_thread instead of MPI_Init.
+ <br>
+ (Timo Heister, 2013/09/17)
+ </li>
+
+ <li>
+ Enhancement: It is now possible to use the build directory directly without
+ the need to install first. For this, a second copy of all necessary project
+ configuration files (deal.IIConfig.cmake, ..., Make.global_options) are
+ generated and deployed in the build directory. (This is fully compatible with
+ the old possibility to install into the build dir.)
+ <br>
+ (Matthias Maier, 2013/09/15)
+ </li>
+
+ <li>
+ Fixed: DoFTools::extract_locally_*_dofs now instantiated for hp::DofHandler.
+ <br>
+ (Jean-Paul Pelteret, 2013/09/11)
+ </li>
+
+ <li>
+ Changed: distributed::parallel:BlockVector::operator= now allows importing
+ of ghost values like all other vector types. Also added some new constructors
+ for BlockVector and Vector using IndexSets to mirror the other linear algebra
+ classes.
+ <br>
+ (Timo Heister, 2013/09/04)
+ </li>
+
+ <li>
+ Fixed: VectorTools::compute_no_normal_flux_constraints had a bug that
+ only manifested on complex meshes. This is now fixed.
+ <br>
+ (Chih-Che Chueh, Wolfgang Bangerth, 2013/09/04)
+ </li>
+
+ <li>
+ New: All vector classes now have functions <code>extract_subvector_to()</code>
+ that allow extracting not just a single value but a whole set.
+ <br>
+ (Fahad Alrashed, 2013/09/02)
+ </li>
+
+ <li>
+ Fixed: <code>common/Make.global_options</code> now exports enable-threads
+ correctly, furthermore, <code>lib-suffix</code>, <code>shared-lib-suffix</code>
+ and <code>static-lib-suffix</code> are now exported as well for better legacy
+ support.
+ <br>
+ (Matthias Maier, 2013/08/30)
+ </li>
+
+ <li>
+ New: The ParameterHandler class can now deal with including one parameter
+ file from another.
+ <br>
+ (Wolfgang Bangerth, 2013/08/25)
+ </li>
+
+ <li>
+ New: The method VectorTools::compute_normal_flux_constraints can be used to
+ force a vector finite element function to be normal to the boundary.
+ <br>
+ (Martin Kronbichler, 2013/08/23)
+ </li>
+
+ <li>
+ Improved: MappingQ now uses the points of the Gauss-Lobatto quadrature
+ formula as support points instead of equispaced ones. This allows its use
+ for high polynomial orders and also gives better interpolation of circular
+ boundaries. Beware that mappings of order three and higher will behave
+ slightly differently now (usually better).
+ <br>
+ (Martin Kronbichler, 2013/08/23)
+ </li>
+
+ <li>
+ Improved: Several .cc files in the deal.II directory have been split in
+ order to better utilize multiple processors when compiling in parallel and
+ reduce memory requirements of the compilation stage.
+ <br>
+ (Martin Kronbichler, 2013/08/22)
+ </li>
+
+ <li>
+ Fixed: The ParameterHandler::declare_entry() did not check that the
+ default value of a parameter indeed satisfies the pattern given for this
+ parameter (despite a statement in the documentation that this checking
+ would happen). This is now fixed.
+ <br>
+ (Wolfgang Bangerth, 2013/08/21)
+ </li>
+
+ <li>
+ New: Patterns::List and Patterns::Map now accept a string
+ different than the default comma that denotes the separator
+ between entries of the list or map.
+ <br>
+ (Wolfgang Bangerth, 2013/08/21)
+ </li>
+
+ <li>
+ Fixed: Some operations in the MappingQ class are now done in higher
+ precision arithmetic to mitigate the ill-conditioning that appears
+ when using mappings of high order (say, order 6 or 8 or 10).
+ <br>
+ (Juan Carlos Araujo Cabarcas, 2013/08/20)
+ </li>
+
+ <li>
+ Fixed: The SLEPcWrappers classes could not be compiled for 64-bit
+ indices. This is now fixed.
+ <br>
+ (Denis Davydov, Wolfgang Bangerth, 2013/08/20)
+ </li>
+
+ <li>
+ Fixed: SolutionTransfer used to crash whenever one transfered in the hp
+ context between cells that use FE_Nothing and FE_Q. This is now fixed.
+ <br>
+ (Krzyszof Bzowski, Wolfgang Bangerth, 2013/08/18)
+ </li>
+
+ <li>
+ Fixed: Under some circumstances (see http://code.google.com/p/dealii/issues/detail?id=82)
+ the DoFTools::make_periodicity_constraints() function could create cycles in
+ the ConstraintMatrix object. This is now fixed.
+ <br>
+ (David Emerson, Wolfgang Bangerth, 2013/08/16)
+ </li>
+
+ <li>
+ New: There is now a function ConstraintMatrix::are_identity_constrained().
+ <br>
+ (Wolfgang Bangerth, 2013/08/16)
+ </li>
+
+ <li>
+ New: TableHandler::write_text() now also supports output in
+ org-mode (http://orgmode.org/) format via a new entry in the
+ TableHandler::TextOutputFormat enumeration.
+ <br>
+ (Oleh Krehel, 2013/08/15)
+ </li>
+
+ <li>
+ New: There are now global functions <code>scalar_product</code>
+ that compute the scalar product (double contraction) between
+ tensors of rank 2.
+ <br>
+ (Scott Miller, 2013/08/14)
+ </li>
+
+ <li>
+ Fixed: Creating objects of type MappingQ was previously only possible
+ for low order polynomials. For orders higher than around 6, one ran
+ into assertions that tested for internal consistency. These assertions
+ have now been appropriately relaxes for the growth of round-off errors
+ with growing polynomial degrees.
+ <br>
+ (Juan Carlos Araujo Cabarcas, Wolfgang Bangerth, 2013/08/14)
+ </li>
+
+ <li>
+ New: MappingQEulerian is now also instantiated for vector elements
+ of type TrilinosWrappers::Vector as well as the MPI and block
+ variants.
+ <br>
+ (Armin Ghajar Jazi, 2013/08/14)
+ </li>
+
+ <li>
+ Fixed: The FiniteElement::face_to_cell_index() function had a bug
+ that made it work incorrectly for elements that have more than one
+ degree of freedom per line (in 2d) or per quad (in 3d). This is now
+ fixed for the most common cases, namely the FE_Q elements as well
+ as elements composed of FESystem elements. For all other cases, an
+ exception is generated reporting that this case is not implemented.
+ If you run into this, let us know.
+ <br>
+ (Wolfgang Bangerth, 2013/08/10)
+ </li>
+
+ <li>
+ New: DataOutBase::VtkFlags now has a flag
+ DataOutBase::VtkFlags::print_date_and_time that can be used to suppress output
+ of date and time in output files. This is useful in test suites where a newer
+ run at a different time produces differences against previously stored files,
+ even though the actual data is exactly the same.
+ <br>
+ (Oleh Krehel, 2013/08/06)
+ </li>
+
+ <li>
+ Fixed: The various block matrix classes are all derived from BlockMatrixBase
+ which had race conditions when the set() or add() functions were called from
+ different threads. This is now fixed.
+ <br>
+ (Wolfgang Bangerth, 2013/08/05)
+ </li>
+
+ <li>
+ Fixed: various fixes with assignment and reinit of PETScWrappers::MPI::Vector.
+ <br>
+ (Timo Heister, 2013/08/05)
+ </li>
+
+ <li>Fixed: An assertion wrongly triggered in
+ DoFTools::make_hanging_node_constraints when used with a particular
+ combination of FESystem elements containing FE_Nothing. This is now fixed.
+ <br>
+ (Denis Davydov, Wolfgang Bangerth, 2013/08/01)
+ </li>
+
+ <li>
+ New: Add has_ghost_elements() for PETScWrappers::MPI::BlockVector and
+ TrilinosWrappers::MPI::BlockVector.
+ <br>
+ (Timo Heister, 2013/08/01)
+ </li>
+
+ <li>
+ SparsityTools::distribute_sparsity_pattern did not work correctly for
+ block systems, this has been fixed (function has a different signature).
+ <br>
+ (Timo Heister, 2013/07/31)
+ </li>
+
+ <li>Fixed: When typing <code>make run</code> in the step-32 directory,
+ the program was executed with <code>mpirun -np 2 ./step-32</code>. This
+ assumes that a program <code>mpirun</code> exists, but also does that
+ deal.II was in fact compiled with MPI support on. Neither was intended.
+ This is now fixed.
+ <br>
+ (Wolfgang Bangerth, 2013/07/24)
+ </li>
+
+ <li>New: The DataOut, DataOutFaces, and DataOutRotation classes now allow
+ the output of data vectors using different DoFHandler objects (based on the
+ same triangulation), by new functions add_data_vector. This is used in the
+ step-31 tutorial program which avoids creating a joint DoFHandler just for
+ output.
+ <br>
+ (Martin Kronbichler, 2013/07/24)
+ </li>
+
+ <li>Changed: GridGenerator used to be a class with only static members
+ but is now a namespace, like all other similar constructs in deal.II.
+ <br>
+ (Wolfgang Bangerth, 2013/07/24)
+ </li>
+
+ <li>Changed: In GridGenerator, several functions had erroneously been changed
+ to take an argument of type <code>size_type</code> rather than <code>unsigned
+ int</code>. <code>GridGenerator::size_type</code> was a typedef to
+ types::global_dof_index, which for most users was <code>unsigned int</code>
+ anyway, but could also be set to be a 64-bit integer type. In any case, the
+ change has been reverted and these functions take just a regular
+ <code>unsigned int</code> again.
+ <br>
+ (Wolfgang Bangerth, 2013/07/24)
+ </li>
+</ol>
+
+
+*/
// ---------------------------------------------------------------------
/**
-// * @page changes_after_8_0 Changes after Version 8.0
+// * @page changes_after_8_1 Changes after Version 8.1
<p>
This is the list of changes made after the release of
-deal.II version 8.0.0.
+deal.II version 8.1.0.
All entries are signed with the names of the authors.
</p>
</p>
<ol>
- <li> Removed: With the switch of the testsuite to CMake, the old report_features
- and build test facilities are removed.
- <br>
- (Matthias Maier, 2013/12/03)
- </li>
-
- <li>
- Changed: The kinds of template arguments for the VectorTools::interpolate
- function taking a Mapping as first argument has changed. This was done to
- work around a bug in the Intel ICC compiler which led to linker errors. Since
- the actual function argument list remains unchanged, the only way you will
- notice this change is if you <i>explicitly</i> specify template arguments.
- The only place one would typically do that is if you take the address of
- a template function. Since this is not a common operation, the impact of this
- change is probably limited.
- <br>
- (Wolfgang Bangerth, 2013/11/27)
- </li>
-
- <li>
- Changed: The ghost handling of the parallel::distributed::Vector class has
- been reworked: The vector now carries a global state that stores whether
- ghost elements have been updated or not. If a vector has ghost elements, it
- does not allow calls to compress() any more. Instead, a compress operation
- can now only be done when the ghost entries have been cleared before by
- calling zero_out_ghosts() or operator=0. The state can be queried by the new
- method has_ghost_elements(). This change avoids spurious entries to be
- inserted with compress(), but requires some change in user codes. The
- behavior of a ghosted vector is now very similar to ghosted PETSc and
- Trilinos vectors. The only difference is that the <i>same</i> vector can
- also be used as a non-ghosted vector which is designed for use in assembly
- routines.
- <br>
- (Martin Kronbichler, 2013/10/18)
- </li>
-
- <li>
- Removed: GridTools::collect_periodic_face_pairs. This function is superseded
- by GridTools::collect_periodic_faces which exports an
- std::vector<PeriodicFacepair<...>> instead.
- <br>
- (Matthias Maier, 2013/09/30)
- </li>
-
- <li>
- Removed: The member function face_to_equivalent_cell_index() in
- FiniteElementData has been removed. It had been deprecated a while
- back already. Please use FiniteElement::face_to_cell_index() instead.
- <br>
- (Wolfgang Bangerth, 2013/08/09)
- </li>
-
- <li>
- Changed: The typedefs DataOut::cell_iterator and
- DataOut::active_cell_iterator were previously defined as
- DoFHandler::(active)_cell_iterator, while they are now
- Triangulation::(active)_cell_iterator. This is necessary to support DataOut
- on multiple DoFHandler objects. This affects possible overloading of
- DataOut::next_cell(cell_iterator). Use the typedef
- DataOut::(active)_cell_iterator as argument type instead.
- <br>
- (Martin Kronbichler, 2013/07/24)
- </li>
</ol>
<ol>
- <li> Improved: The build system now supports usage of the library
- out of the build directory without prior installation. This is done by
- exporting an additional project configuration just for the build directory.
- Furthermore, a bunch of convenience targets get now defined that just build
- individual components (such as just the documentation or the libraries), and
- if <tt>CMAKE_INSTALL_PREFIX</tt> is set, also install that specific component.
- <br>
- (Matthias Maier, Luca Heltai, 2013/12/03)
- </li>
-
- <li> Fixed: Missing instantiations of SparseDirectMUMPS have been added.
- <br>
- (Timo Heister, 2013/11/25)
- </li>
-
- <li> New: introduced "make test" that runs a minimal set of tests. We
- encourage every user to run this, especially if they run in to problems.
- The tests are automatically picked depending on the configuration and
- will be shipped with every release.
- <br>
- (Timo Heister, Matthias Maier, 2013/11/08)
- </li>
-
- <li> Changed: It is now possible to restore a parallel Triangulation
- (and solutions) with a different number of processors it was saved with
- using Triangulation::save() and Triangulation::load().
- <br>
- (Timo Heister, 2013/11/02)
- </li>
-
- <li> Added support for Windows: It is now possible again to use gcc on Windows
- in order to compile the library. We support gcc-4.8.1 on Cygwin64 and MinGW-w64.
- <br>
- (Matthias Maier, 2013/11/01)
- </li>
-
- <li> Changed: step-9, step-13 and step-14 have been converted to use the
- more modern WorkStream concept for assembling linear systems and computing
- error indicators in parallel.
- <br>
- (Bruno Turcksin, Wolfgang Bangerth, 2013/10/26)
- </li>
-
- <li> New: The testsuite is now ported to <a href="http://www.cmake.org/">
- CMake</a> and uses CTest as test driver.
- <br>
- (Wolfgang Bangerth, Timo Heister, Matthias Maier, Bruno Turcksin, 2013/10/20)
- </li>
-
- <li>
- Changed: multithreadinfo::n_default_threads is now deprecated. Use the
- new n_threads() function instead, which works correctly with TBB.
- <br>
- (Timo Heister, 2013/10/02)
- </li>
-
- <li>
- Changed: if configured with TBB but the number of threads is set to 1,
- do not bother to use TBB in workstream.
- <br>
- (Timo Heister, 2013/10/02)
- </li>
-
- <li>
- New: step-51 demonstrates the use of hybridized discontinuous Galerkin
- methods in deal.II, using the face elements FE_FaceQ. The programs solves a
- scalar convection-diffusion equation.
- <br>
- (Martin Kronbichler and Scott Miller, 2013/10/01)
- </li>
-
- <li>
- New: There is now an element FE_FaceP that can be combined with FE_DGP in
- hybridized DG methods.
- <br>
- (Martin Kronbichler, 2013/09/17)
- </li>
-
- <li>
- Fixed: The DataOutBase::XDMFEntry class now has a proper serialization
- function to allow for checkpointing.
- <br>
- (Eric Heien, 2013/09/27)
- </li>
-
- <li>
- New: DataOutBase::DataOutFilter provides a way to remove duplicate vertices
- and values from a solution vector when generating output. Currently it only
- supports HDF5/XDMF output.
- <br>
- (Eric Heien, 2013/09/27)
- </li>
-
- <li>
- Removed: DataOutBase::HDF5MemStream was removed and the functionality replaced
- by DataOutBase::DataOutFilter. The user only manipulates these through
- DataOutBase::write_hdf5_parallel so this change should be transparent.
- <br>
- (Eric Heien, 2013/09/27)
- </li>
-
- <li>
- New: Like the usual DoFHandler class, the hp::DoFHandler class now also
- has a cache that makes operations such as <code>cell-@>get_dof_indices(...)</code>
- faster. This should accelerate many parts of the library that deal with
- hp finite elements.
- <br>
- (Wolfgang Bangerth, 2013/09/10)
- </li>
-
- <li>
- New: parallel::distributed::Triangulation now supports periodic boundaries.
- DoFTools::make_periodicity_constraints and similar functions are now working
- on parallel::distributed::Triangulation objects.
- <br>
- (Tobin Isaac, Craig Michoski, Daniel Arndt, 2013/09/06)
- </li>
-
- <li>
- New: It is now possible to compile and link deal.II against LLVM's libcxx. For
- this, a few issues with C++ standard violations are resolved.
- <br>
- (Matthias Maier, 2013/08/09)
- </li>
</ol>
<h3>Specific improvements</h3>
<ol>
- <li> Fixed: Several functions in namespace GridTools were not instantiated
- for parallel::distributed::Triangulation objects. This is now fixed.
- <br>
- (Denis Davydov, Wolfgang Bangerth, 2013/12/01)
- </li>
-
- <li> Improved: The methods ConstraintMatrix::distribute_local_to_global
- now use scratch data that is private to each thread instead of allocating
- it for every cell anew. This gives better performance, in particular in
- parallel, of these operations, while maintaining thread-safety (when
- accessing non-overlapping rows, no race condition can exist).
- <br>
- (Martin Kronbichler, 2013/12/03)
- </li>
-
- <li> Improved: When attempting operations such as FEValues::get_function_values()
- or FEValues::shape_value(), the FEValues object needs to know that what these
- functions return has been computed previously. What is computed is specified
- by the update flags that are passed to the constructor of all FEValues, FEFaceValues
- and FESubfaceValues objects. If a user attempts an operation for which the
- corresponding flag was not specified, an exception is generated. This exception
- did say previously what the cause was, but it was not overly explicit.
- The exception now generates a message that says exactly what is going wrong.
- <br>
- (Wolfgang Bangerth, 2013/12/01)
- </li>
-
- <li> Fixed: GridGenerator::truncated_cone() failed if half_length < 0.5*radius in 3d.
- <br>
- (Timo Heister, 2013/11/25)
- </li>
-
- <li> Fixed: make_hanging_node_constraints failed with an exception in a
- parallel::distributed computation if the element is
- RaviartThomas (and probably others).
- <br>
- (Timo Heister, 2013/11/23)
- </li>
-
- <li> Improved: CMake: Added a configuration check for incompatible ninja
- + icc setup, fixed several setup and performance issues with the
- testsuite.
- <br>
- (Matthias Maier, 2013/11/20)
- </li>
-
- <li> Changed: when a dealii::Exception is thrown, defer the symbol lookup of the
- stack trace to when it is needed. This improves performance if what() is never
- called.
- <br>
- (Timo Heister, 2013/11/17)
- </li>
-
- <li> Fixed: GridGenerator::parallelogram was not instantiated properly
- when using intel compilers.
- <br>
- (Timo Heister, 2013/11/17)
- </li>
-
- <li>
- Fixed: MappingQ1::transform_real_to_unit_cell() could fail in some
- cases with very elongated and twisted cells. This should now be fixed
- with an algorithm that uses a better method of computing the Newton
- convergence.
- <br>
- (Wolfgang Bangerth, 2013/11/17)
- </li>
-
- <li>
- Fixed: VectorTools::compute_no_normal_flux_constraints had a bug that
- only appeared in rare cases at vertices of the domain if one adjacent
- cell had two boundary indicators selected for no normal flux and another
- had only one. This is now fixed.
- <br>
- (Wolfgang Bangerth, 2013/11/17)
- </li>
-
- <li> Fixed: dealii::FETools::interpolation_difference was
- not working for TrilinosWrappers::MPI::Vectors with ghost
- entries. The TrilinosWrappers::VectorBase class has now a
- get_mpi_communicator method similar to the PETSc vector
- classes.
- <br>
- (Martin Steigemann, Martin Kronbichler, 2013/11/17)
- </li>
-
- <li> Fixed: Bundled fparser is now compiled with FP_USE_THREAD_SAFE_EVAL in
- case of enabled threading support so that it is thread safe.
- <br>
- (Matthias Maier, reported by Francesco Cattoglio 2013/11/16)
- </li>
-
- <li> Fixed: The CellData class now has a default constructor that
- sets the material and boundary indicators to zero. This fixes certain
- internal errors with the Intel ICC compiler.
- <br>
- (Wolfgang Bangerth, 2013/11/13)
- </li>
-
- <li> Cleanup: Removed obsolete files and files with unknown licensing
- status from the source tree. Along the way, parameter_gui now uses
- default icons from the desktop environment instead of bundled ones.
- <br>
- (Matthias Maier, 2013/11/11)
- </li>
-
- <li> New: There is now a framework for coloring graphs, with functions
- in namespace GraphColoring.
- <br>
- (Bruno Turcksin, Martin Kronbichler, 2013/11/06)
- </li>
-
- <li>
- Fixed: the DerivativeApproximation class was not working correctly when
- used with parallel vectors.
- (Timo Heister, 2013/10/28)
- </li>
-
- <li>
- ~Subscriptor and ~GrowingVectorMemory no longer throw an exception (the
- former if disable_abort_on_exception was called) to be compatible with the
- C++11 standard which otherwise requires the program to immediately call
- std::terminate. This was done with a new macro "AssertNothrow".
- <br>
- (Wolfgang Bangerth, Matthias Maier, Bruno Turcksin 2013/10/22)
- </li>
-
- <li>
- dealii::SolverControl::NoConvergence now inherits dealii::ExceptionBase and
- is thrown via AssertThrow(false, ... ).
- <br>
- (Matthias Maier, 2013/10/20)
- </li>
-
- <li>
- New: parallel::distributed::BlockVector has now methods update_ghost_values,
- compress, zero_out_ghosts, and has_ghost_elements that do the respective
- operation on each block of parallel::distributed::Vector.
- <br>
- (Martin Kronbichler, 2013/10/18)
- </li>
-
- <li>
- Fixed: When deriving from DataOut to filter the cells where output is generated, there were two different bugs that result in segmentation faults or wrong cells written (example, step-18).
- <br>
- (Timo Heister, 2013/10/16)
- </li>
-
- <li>
- New: GridIn::read_vtk() reads 2d and 3d meshes in VTK format.
- <br>
- (Mayank Sabharwal, Andreas Putz, 2013/10/07)
- </li>
-
- <li>
- Fixed: ConstraintMatrix would not compress() the IndexSet in the constructor
- leading to crashes that only happen in release mode. This is now fixed.
- <br>
- (Timo Heister, 2013/09/27)
- </li>
-
- <li>
- Fixed: PetscWrappers::MatrixBase::row_length() no longer worked after recent changes
- to PETSc (around PETSc release 3.4). This is now fixed.
- <br>
- (Wolfgang Bangerth, 2013/09/24)
- </li>
-
- <li>
- New: Added write_visit_record that allows writing .visit files with multiple blocks
- and multiple time steps.
- <br>
- (Fahad Alrashed, 2013/09/21)
- </li>
-
- <li>
- Changed: GridTools::have_same_coarse_mesh was only instantiated for
- MGDoFHandler arguments in debug mode. This is now fixed.
- <br>
- (Timo Heister, 2013/09/20)
- </li>
-
- <li>
- Changed: GridTools::find_active_cell_around_point now throws the exception
- GridTools::ExcPointNotFound
- if the point is outside the Triangulation. This exception can be caught.
- <br>
- (Timo Heister, 2013/09/18)
- </li>
-
- <li>
- Changed: we now call MPI_Init_thread instead of MPI_Init.
- <br>
- (Timo Heister, 2013/09/17)
- </li>
-
- <li>
- Enhancement: It is now possible to use the build directory directly without
- the need to install first. For this, a second copy of all necessary project
- configuration files (deal.IIConfig.cmake, ..., Make.global_options) are
- generated and deployed in the build directory. (This is fully compatible with
- the old possibility to install into the build dir.)
- <br>
- (Matthias Maier, 2013/09/15)
- </li>
-
- <li>
- Fixed: DoFTools::extract_locally_*_dofs now instantiated for hp::DofHandler.
- <br>
- (Jean-Paul Pelteret, 2013/09/11)
- </li>
-
- <li>
- Changed: distributed::parallel:BlockVector::operator= now allows importing
- of ghost values like all other vector types. Also added some new constructors
- for BlockVector and Vector using IndexSets to mirror the other linear algebra
- classes.
- <br>
- (Timo Heister, 2013/09/04)
- </li>
-
- <li>
- Fixed: VectorTools::compute_no_normal_flux_constraints had a bug that
- only manifested on complex meshes. This is now fixed.
- <br>
- (Chih-Che Chueh, Wolfgang Bangerth, 2013/09/04)
- </li>
-
- <li>
- New: All vector classes now have functions <code>extract_subvector_to()</code>
- that allow extracting not just a single value but a whole set.
- <br>
- (Fahad Alrashed, 2013/09/02)
- </li>
-
- <li>
- Fixed: <code>common/Make.global_options</code> now exports enable-threads
- correctly, furthermore, <code>lib-suffix</code>, <code>shared-lib-suffix</code>
- and <code>static-lib-suffix</code> are now exported as well for better legacy
- support.
- <br>
- (Matthias Maier, 2013/08/30)
- </li>
-
- <li>
- New: The ParameterHandler class can now deal with including one parameter
- file from another.
- <br>
- (Wolfgang Bangerth, 2013/08/25)
- </li>
-
- <li>
- New: The method VectorTools::compute_normal_flux_constraints can be used to
- force a vector finite element function to be normal to the boundary.
- <br>
- (Martin Kronbichler, 2013/08/23)
- </li>
-
- <li>
- Improved: MappingQ now uses the points of the Gauss-Lobatto quadrature
- formula as support points instead of equispaced ones. This allows its use
- for high polynomial orders and also gives better interpolation of circular
- boundaries. Beware that mappings of order three and higher will behave
- slightly differently now (usually better).
- <br>
- (Martin Kronbichler, 2013/08/23)
- </li>
-
- <li>
- Improved: Several .cc files in the deal.II directory have been split in
- order to better utilize multiple processors when compiling in parallel and
- reduce memory requirements of the compilation stage.
- <br>
- (Martin Kronbichler, 2013/08/22)
- </li>
-
- <li>
- Fixed: The ParameterHandler::declare_entry() did not check that the
- default value of a parameter indeed satisfies the pattern given for this
- parameter (despite a statement in the documentation that this checking
- would happen). This is now fixed.
- <br>
- (Wolfgang Bangerth, 2013/08/21)
- </li>
-
- <li>
- New: Patterns::List and Patterns::Map now accept a string
- different than the default comma that denotes the separator
- between entries of the list or map.
- <br>
- (Wolfgang Bangerth, 2013/08/21)
- </li>
-
- <li>
- Fixed: Some operations in the MappingQ class are now done in higher
- precision arithmetic to mitigate the ill-conditioning that appears
- when using mappings of high order (say, order 6 or 8 or 10).
- <br>
- (Juan Carlos Araujo Cabarcas, 2013/08/20)
- </li>
-
- <li>
- Fixed: The SLEPcWrappers classes could not be compiled for 64-bit
- indices. This is now fixed.
- <br>
- (Denis Davydov, Wolfgang Bangerth, 2013/08/20)
- </li>
-
- <li>
- Fixed: SolutionTransfer used to crash whenever one transfered in the hp
- context between cells that use FE_Nothing and FE_Q. This is now fixed.
- <br>
- (Krzyszof Bzowski, Wolfgang Bangerth, 2013/08/18)
- </li>
-
- <li>
- Fixed: Under some circumstances (see http://code.google.com/p/dealii/issues/detail?id=82)
- the DoFTools::make_periodicity_constraints() function could create cycles in
- the ConstraintMatrix object. This is now fixed.
- <br>
- (David Emerson, Wolfgang Bangerth, 2013/08/16)
- </li>
-
- <li>
- New: There is now a function ConstraintMatrix::are_identity_constrained().
- <br>
- (Wolfgang Bangerth, 2013/08/16)
- </li>
-
- <li>
- New: TableHandler::write_text() now also supports output in
- org-mode (http://orgmode.org/) format via a new entry in the
- TableHandler::TextOutputFormat enumeration.
- <br>
- (Oleh Krehel, 2013/08/15)
- </li>
-
- <li>
- New: There are now global functions <code>scalar_product</code>
- that compute the scalar product (double contraction) between
- tensors of rank 2.
- <br>
- (Scott Miller, 2013/08/14)
- </li>
-
- <li>
- Fixed: Creating objects of type MappingQ was previously only possible
- for low order polynomials. For orders higher than around 6, one ran
- into assertions that tested for internal consistency. These assertions
- have now been appropriately relaxes for the growth of round-off errors
- with growing polynomial degrees.
- <br>
- (Juan Carlos Araujo Cabarcas, Wolfgang Bangerth, 2013/08/14)
- </li>
-
- <li>
- New: MappingQEulerian is now also instantiated for vector elements
- of type TrilinosWrappers::Vector as well as the MPI and block
- variants.
- <br>
- (Armin Ghajar Jazi, 2013/08/14)
- </li>
-
- <li>
- Fixed: The FiniteElement::face_to_cell_index() function had a bug
- that made it work incorrectly for elements that have more than one
- degree of freedom per line (in 2d) or per quad (in 3d). This is now
- fixed for the most common cases, namely the FE_Q elements as well
- as elements composed of FESystem elements. For all other cases, an
- exception is generated reporting that this case is not implemented.
- If you run into this, let us know.
- <br>
- (Wolfgang Bangerth, 2013/08/10)
- </li>
-
- <li>
- New: DataOutBase::VtkFlags now has a flag
- DataOutBase::VtkFlags::print_date_and_time that can be used to suppress output
- of date and time in output files. This is useful in test suites where a newer
- run at a different time produces differences against previously stored files,
- even though the actual data is exactly the same.
- <br>
- (Oleh Krehel, 2013/08/06)
- </li>
-
- <li>
- Fixed: The various block matrix classes are all derived from BlockMatrixBase
- which had race conditions when the set() or add() functions were called from
- different threads. This is now fixed.
- <br>
- (Wolfgang Bangerth, 2013/08/05)
- </li>
-
- <li>
- Fixed: various fixes with assignment and reinit of PETScWrappers::MPI::Vector.
- <br>
- (Timo Heister, 2013/08/05)
- </li>
-
- <li>Fixed: An assertion wrongly triggered in
- DoFTools::make_hanging_node_constraints when used with a particular
- combination of FESystem elements containing FE_Nothing. This is now fixed.
- <br>
- (Denis Davydov, Wolfgang Bangerth, 2013/08/01)
- </li>
-
- <li>
- New: Add has_ghost_elements() for PETScWrappers::MPI::BlockVector and
- TrilinosWrappers::MPI::BlockVector.
- <br>
- (Timo Heister, 2013/08/01)
- </li>
-
- <li>
- SparsityTools::distribute_sparsity_pattern did not work correctly for
- block systems, this has been fixed (function has a different signature).
- <br>
- (Timo Heister, 2013/07/31)
- </li>
-
- <li>Fixed: When typing <code>make run</code> in the step-32 directory,
- the program was executed with <code>mpirun -np 2 ./step-32</code>. This
- assumes that a program <code>mpirun</code> exists, but also does that
- deal.II was in fact compiled with MPI support on. Neither was intended.
- This is now fixed.
- <br>
- (Wolfgang Bangerth, 2013/07/24)
- </li>
-
- <li>New: The DataOut, DataOutFaces, and DataOutRotation classes now allow
- the output of data vectors using different DoFHandler objects (based on the
- same triangulation), by new functions add_data_vector. This is used in the
- step-31 tutorial program which avoids creating a joint DoFHandler just for
- output.
- <br>
- (Martin Kronbichler, 2013/07/24)
- </li>
-
- <li>Changed: GridGenerator used to be a class with only static members
- but is now a namespace, like all other similar constructs in deal.II.
- <br>
- (Wolfgang Bangerth, 2013/07/24)
- </li>
-
- <li>Changed: In GridGenerator, several functions had erroneously been changed
- to take an argument of type <code>size_type</code> rather than <code>unsigned
- int</code>. <code>GridGenerator::size_type</code> was a typedef to
- types::global_dof_index, which for most users was <code>unsigned int</code>
- anyway, but could also be set to be a 64-bit integer type. In any case, the
- change has been reverted and these functions take just a regular
- <code>unsigned int</code> again.
- <br>
- (Wolfgang Bangerth, 2013/07/24)
- </li>
</ol>
mailing list</a> for additional news.
</p>
+
<p>
<dt><strong>Recent changes</strong></dt>
<dd>
Changes in the library since the last major release are
- <strong><a href="../doxygen/deal.II/changes_after_8_0.html">here.</a></strong>
+ <strong><a href="../doxygen/deal.II/changes_after_8_1.html">here.</a></strong>
</dd>
</p>
+
<dl>
+ <dt>
+ <strong style="color:red">2013/12/24: Version 8.1 released</strong>
+ </dt>
+ <dd>
+ deal.II version 8.1 was released today. A full list of changes can be
+ found <a href="../doxygen/deal.II/changes_between_8_0_and_8_1.html"
+ target="body">here</a>.
+ <br>
+ deal.II can be downloaded at
+ <a href="https://code.google.com/p/dealii/downloads/list"
+ target="_top">this site</a>.
+ </dd>
+
<dt>
<strong>2013/11/01: step-42 solves an elasto-plastic contact problem </strong>
</dt>
}
-%% The deal.II web page and online reference.
-%% Please cite specific versions only if you really need to
-
-@Manual{DealIIReference,
- title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
- Technical Reference},
- author = {W. Bangerth and T. Heister and G. Kanschat},
- note = {\texttt{http://www.dealii.org}},
- url = {http://www.dealii.org}
-}
-
-@Manual{DealIIReference600,
- title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
- Technical Reference},
- author = {W. Bangerth and G. Kanschat},
- note = {\texttt{http://www.dealii.org}},
- url = {http://www.dealii.org/6.0.0},
- year = 2007
+@Misc{dealII80,
+ title = {The {\tt deal.{I}{I}} Library, Version 8.0},
+ author = {W. Bangerth and T. Heister and L. Heltai and G. Kanschat
+ and M. Kronbichler and M. Maier and B. Turcksin and T. D. Young},
+ note = {\texttt{http://www.dealii.org}},
+ url = {http://www.dealii.org},
+ year = {2013}
+ }
}
-@Manual{DealIIReference610,
- title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
- Technical Reference},
- author = {W. Bangerth and G. Kanschat},
- note = {\texttt{http://www.dealii.org}},
- url = {http://www.dealii.org/6.1.0},
- year = 2008
-}
-@Manual{DealIIReference621,
- title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
- Technical Reference},
- author = {W. Bangerth and G. Kanschat},
- note = {\texttt{http://www.dealii.org}},
- url = {http://www.dealii.org/6.2.1},
- year = 2009
-}
-@Manual{DealIIReference631,
- title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
- Technical Reference},
- author = {W. Bangerth and G. Kanschat},
- note = {\texttt{http://www.dealii.org}},
- url = {http://www.dealii.org/6.3.1},
- year = 2010
-}
-@Manual{DealIIReference700,
- title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
- Technical Reference},
- author = {W. Bangerth and G. Kanschat},
- note = {\texttt{http://www.dealii.org}},
- url = {http://www.dealii.org/7.0.0},
- year = 2011
-}
-@Manual{DealIIReference710,
- title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
- Technical Reference},
- author = {W. Bangerth and G. Kanschat},
- note = {\texttt{http://www.dealii.org}},
- url = {http://www.dealii.org/7.1.0},
- year = 2011
-}
%% Additional papers on deal.II and special aspects
doi = {10.1016/j.compfluid.2012.04.012}
}
+
+
+%% older references:
+
+@Manual{DealIIReference,
+ title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
+ Technical Reference},
+ author = {W. Bangerth and T. Heister and G. Kanschat},
+ note = {\texttt{http://www.dealii.org}},
+ url = {http://www.dealii.org}
+}
+
+@Manual{DealIIReference600,
+ title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
+ Technical Reference},
+ author = {W. Bangerth and G. Kanschat},
+ note = {\texttt{http://www.dealii.org}},
+ url = {http://www.dealii.org/6.0.0},
+ year = 2007
+}
+
+@Manual{DealIIReference610,
+ title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
+ Technical Reference},
+ author = {W. Bangerth and G. Kanschat},
+ note = {\texttt{http://www.dealii.org}},
+ url = {http://www.dealii.org/6.1.0},
+ year = 2008
+}
+
+@Manual{DealIIReference621,
+ title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
+ Technical Reference},
+ author = {W. Bangerth and G. Kanschat},
+ note = {\texttt{http://www.dealii.org}},
+ url = {http://www.dealii.org/6.2.1},
+ year = 2009
+}
+
+@Manual{DealIIReference631,
+ title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
+ Technical Reference},
+ author = {W. Bangerth and G. Kanschat},
+ note = {\texttt{http://www.dealii.org}},
+ url = {http://www.dealii.org/6.3.1},
+ year = 2010
+}
+
+@Manual{DealIIReference700,
+ title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
+ Technical Reference},
+ author = {W. Bangerth and G. Kanschat},
+ note = {\texttt{http://www.dealii.org}},
+ url = {http://www.dealii.org/7.0.0},
+ year = 2011
+}
+
+@Manual{DealIIReference710,
+ title = {{\tt deal.{I}{I}} Differential Equations Analysis Library,
+ Technical Reference},
+ author = {W. Bangerth and G. Kanschat},
+ note = {\texttt{http://www.dealii.org}},
+ url = {http://www.dealii.org/7.1.0},
+ year = 2011
+}
}
</pre>
</li>
- <li> <a href="http://www.math.tamu.edu/~bangerth"
- target="_top">W. Bangerth</a>,
- <a href="http://www.math.clemson.edu/~heister"
- target="_top">T. Heister</a>
- and
- <a href="http://www.math.tamu.edu/~kanschat"
- target="_top">G. Kanschat</a>
- <br>
- <strong><acronym>deal.II</acronym> Differential Equations
- Analysis Library, Technical Reference
+ <li>
+ Wolfgang Bangerth, Timo Heister, Luca Heltai, Guido Kanschat, Martin Kronbichler, Matthias Maier, and Toby D. Young <br/>
+ <strong>The <acronym>deal.II</acronym> Library, Version 8.0
</strong>
<br>
- To be found on the project webpage <a href="http://www.dealii.org"
- target="_top">http://www.dealii.org</a>
+ <a href="http://arxiv.org/abs/1312.2266" target="_top">arxiv:1312.2266</a>, 2013.
<br>
<pre>
-@Manual{DealIIReference,
- title = {{\tt deal.{I}{I}} Differential Equations Analysis Library, Technical Reference},
- author = {W. Bangerth and T. Heister and G. Kanschat and others},
- note = {\texttt{http://www.dealii.org}},
- url = {http://www.dealii.org}
+@Misc{dealII80,
+ title = {The {\tt deal.{I}{I}} Library, Version 8.0},
+ author = {W. Bangerth and T. Heister and L. Heltai and G. Kanschat
+ and M. Kronbichler and M. Maier and B. Turcksin and T. D. Young},
+ note = {\texttt{http://www.dealii.org}},
+ url = {http://www.dealii.org},
+ year = {2013}
+ }
}
</pre>
</li>
Preprint, MPI Magdeburg, 2013.
</li>
+
+ <li> A. Bonito, D. Devaud
+ <br>
+ <strong>Adaptive Finite Element Methods for the Stokes Problems with Discontinuous Coefficients</strong>
+ <br>
+ submitted, 2013.
+ </li>
+
<li> A. Bonito, R. DeVore, R. H. Nochetto
<br>
<strong>Adaptive Finite Element Methods for Elliptic Problems with Discontinuous Coefficients</strong>
<br>
- arXiv:1301.3203, submitted, 2013.
+ SIAM J. Numer. Anal. 51 (2013), no. 6, 3106--3134.
+ </li>
+
+ <li> A. Bonito, R. Glowinski
+ <br>
+ <strong>On the Nodal Set of the Eigenfunctions of the Laplace-Beltrami Operator for Bounded Surfaces in R3: A Computational Approach</strong>
+ <br>
+ submitted, 2013.
+ </li>
+
+ <li> A. Bonito, J.-L. Guermond, S. Lee
+ <br>
+ <strong>Two Modified Pressure-Correction Projection Methods for the Time-Dependent Stokes Equations</strong>
+ <br>
+ submitted, 2013.
</li>
<li> A. Bonito, I. Kyza, R. H. Nochetto
SIAM J. Numer. Anal., 51(1), 577--608, 2013.
</li>
+ <li> A. Bonito, J. E. Pasciak
+ <br>
+ <strong>Numerical Approximation of Fractional Powers of Elliptic Operators</strong>
+ <br>
+ submitted, 2013.
+ </li>
+
<li> J. Bosch, M. Stoll, P. Benner
<br>
<strong>Fast solution of Cahn-Hilliard variational
<li>Mac OS X: GCC version 4.1 or later; Clang version 3.0 or later.
Please see the <a href="https://code.google.com/p/dealii/wiki/MacOSX"
target="_top">deal.II Wiki</a> for installation instructions.</li>
- <li>Windows: GCC version 4.8.* (Cygwin or MinGW, 64bit).
- Please see the <a href="https://code.google.com/p/dealii/wiki/Windows"
- target="_top">deal.II Wiki</a> for installation instructions.</li>
+ <li>Windows: Currently, Windows is not supported officially.
+ Please have a look at the
+ <a href="https://code.google.com/p/dealii/wiki/FrequentlyAskedQuestions#Can_I_use_deal.II_on_a_Windows_platform?">
+ FAQ</a> and at the <a href="https://code.google.com/p/dealii/wiki/Windows"
+ target="_top">deal.II Wiki</a> for some strategies to use deal.II on
+ Windows.</li>
</li>
</ul>
please report it as a bug.</i>
</p>
-<p>
- Please note that the Microsoft Visual C++ compiler, that is widely
- used on Microsoft Windows, is not supported. If you need a native
- Windows target, use the MinGW compiler instead.
-</p>
-
<a name="additional-software"></a>
<h3>Additional software requirements</h3>
-//
-// Copyright (C) 1998 - 2013 by the deal.II authors
-//
+/*
+ Copyright (C) 1998 - 2013 by the deal.II authors
+*/
body {
background-image: none;
based on the <code>DEAL_II_SETUP_TARGET</code> macro. This method gives
full control of what's happening and is easily extensible to more complex
projects, as exemplified in the subsections here and later in the section
- on <a href="cmakeadvanced">advanced topics</a>. Here is a full example
+ on <a href="#cmakeadvanced">advanced topics</a>. Here is a full example
(<a href="CMakeLists.txt.sample" target="_top">plain text</a>
version):
Doxygen, if the online documentation is available,
<a href="../doxygen/deal.II/index.html">here</a>. For older revisions,
links are provided here by revision number:
+ <a href="http://www.dealii.org/8.1.0/doxygen/deal.tag">8.1.0</a>,
<a href="http://www.dealii.org/8.0.0/doxygen/deal.tag">8.0.0</a>,
<a href="http://www.dealii.org/7.3.0/doxygen/deal.tag">7.3.0</a>,
<a href="http://www.dealii.org/7.2.0/doxygen/deal.tag">7.2.0</a>,
template<int dim>
void HeatEquation<dim>::run()
{
- const unsigned int initial_global_refinement = (dim == 2 ? 1 : 2);
- const unsigned int n_adaptive_pre_refinement_steps = 1;
+ const unsigned int initial_global_refinement = 2;
+ const unsigned int n_adaptive_pre_refinement_steps = 4;
GridGenerator::hyper_L (triangulation);
triangulation.refine_global (initial_global_refinement);
system_rhs);
}
- constraints.condense (system_rhs);
+ constraints.condense (system_matrix, system_rhs);
solve_time_step();
The classical formulation of the problem possesses the following form:
@f{align*}
\varepsilon(\mathbf u) &= A\sigma + \varepsilon^p & &\quad\text{in } \Omega,\\
- -\textrm{\textrm{div}}\ \sigma &= \mathbf f & &\quad\text{in } \Omega,\\
+ -\textrm{div}\ \sigma &= \mathbf f & &\quad\text{in } \Omega,\\
\varepsilon^p:(\tau - \sigma) &\geq 0\quad\forall\tau\text{ with
}\mathcal{F}(\tau)\leq 0 & &\quad\text{in } \Omega,\\
\mathbf u &= 0 & &\quad\text{on }\Gamma_D,\\
* Read or write the data of this object for serialization
*/
template <class Archive>
- void serialize(Archive &ar, const unsigned int version) {
+ void serialize(Archive &ar, const unsigned int version)
+ {
ar &valid
- &h5_sol_filename
- &h5_mesh_filename
- &entry_time
- &num_nodes
- &num_cells
- &dimension
- &attribute_dims;
+ &h5_sol_filename
+ &h5_mesh_filename
+ &entry_time
+ &num_nodes
+ &num_cells
+ &dimension
+ &attribute_dims;
}
/// Get the XDMF content associated with this entry.
/**
* Override the standard function that returns the description of the error.
*/
- virtual const char* what() const throw();
+ virtual const char *what() const throw();
/**
* Get exception name.
// Fill the fields of the exception object
e.set_fields (file, line, function, cond, exc_name);
- switch(handling)
+ switch (handling)
{
case abort_on_exception:
dealii::deal_II_exceptions::internals::abort(e);
*/
#ifdef DEBUG
#define Assert(cond, exc) \
-{ \
- if (!(cond)) \
- ::dealii::deal_II_exceptions::internals:: \
- issue_error(::dealii::deal_II_exceptions::internals::abort_on_exception,\
- __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc); \
-}
+ { \
+ if (!(cond)) \
+ ::dealii::deal_II_exceptions::internals:: \
+ issue_error(::dealii::deal_II_exceptions::internals::abort_on_exception,\
+ __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc); \
+ }
#else
#define Assert(cond, exc) \
-{}
+ {}
#endif
*/
#ifdef DEBUG
#define AssertNothrow(cond, exc) \
-{ \
- if (!(cond)) \
- ::dealii::deal_II_exceptions::internals:: \
- issue_error( \
- ::dealii::deal_II_exceptions::internals::abort_nothrow_on_exception, \
- __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc); \
-}
+ { \
+ if (!(cond)) \
+ ::dealii::deal_II_exceptions::internals:: \
+ issue_error( \
+ ::dealii::deal_II_exceptions::internals::abort_nothrow_on_exception, \
+ __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc); \
+ }
#else
#define AssertNothrow(cond, exc) \
-{}
+ {}
#endif
*/
#ifdef HAVE_BUILTIN_EXPECT
#define AssertThrow(cond, exc) \
-{ \
- if (__builtin_expect(!(cond), false)) \
- ::dealii::deal_II_exceptions::internals:: \
- issue_error(::dealii::deal_II_exceptions::internals::throw_on_exception,\
- __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc); \
-}
+ { \
+ if (__builtin_expect(!(cond), false)) \
+ ::dealii::deal_II_exceptions::internals:: \
+ issue_error(::dealii::deal_II_exceptions::internals::throw_on_exception,\
+ __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc); \
+ }
#else /*ifdef HAVE_BUILTIN_EXPECT*/
#define AssertThrow(cond, exc) \
-{ \
- if (!(cond)) \
- ::dealii::deal_II_exceptions::internals:: \
- issue_error(::dealii::deal_II_exceptions::internals::throw_on_exception,\
- __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc); \
-}
+ { \
+ if (!(cond)) \
+ ::dealii::deal_II_exceptions::internals:: \
+ issue_error(::dealii::deal_II_exceptions::internals::throw_on_exception,\
+ __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc); \
+ }
#endif /*ifdef HAVE_BUILTIN_EXPECT*/
static void
alternating_form_at_vertices
#ifndef DEAL_II_CONSTEXPR_BUG
- (const Point<spacedim> (&vertices)[vertices_per_cell],
- Tensor<spacedim-dim,spacedim> (&forms)[vertices_per_cell]);
+ (const Point<spacedim> (&vertices)[vertices_per_cell],
+ Tensor<spacedim-dim,spacedim> (&forms)[vertices_per_cell]);
#else
- (const Point<spacedim> *vertices,
- Tensor<spacedim-dim,spacedim> *forms);
+ (const Point<spacedim> *vertices,
+ Tensor<spacedim-dim,spacedim> *forms);
#endif
/**
Assert (i < dim, ExcIndexRange(i, 0, dim));
static const RefinementCase options[dim] = { RefinementPossibilities<2>::cut_x,
- RefinementPossibilities<2>::cut_y };
+ RefinementPossibilities<2>::cut_y
+ };
return options[i];
}
Assert (i < dim, ExcIndexRange(i, 0, dim));
static const RefinementCase options[dim] = { RefinementPossibilities<3>::cut_x,
- RefinementPossibilities<3>::cut_y,
- RefinementPossibilities<3>::cut_z };
+ RefinementPossibilities<3>::cut_y,
+ RefinementPossibilities<3>::cut_z
+ };
return options[i];
}
return (p[0] <= 0.5 ?
(p[1] <= 0.5 ? 0 : 2) :
- (p[1] <= 0.5 ? 1 : 3));
+ (p[1] <= 0.5 ? 1 : 3));
}
return (p[0] <= 0.5 ?
(p[1] <= 0.5 ?
(p[2] <= 0.5 ? 0 : 4) :
- (p[2] <= 0.5 ? 2 : 6)) :
- (p[1] <= 0.5 ?
- (p[2] <= 0.5 ? 1 : 5) :
- (p[2] <= 0.5 ? 3 : 7)));
+ (p[2] <= 0.5 ? 2 : 6)) :
+ (p[1] <= 0.5 ?
+ (p[2] <= 0.5 ? 1 : 5) :
+ (p[2] <= 0.5 ? 3 : 7)));
}
// intersection of the conflict indices.
for (unsigned int i=0; i<partition_size; ++i)
for (unsigned int j=i+1; j<partition_size; ++j)
- // If the two iterators share indices then we increase the degree of the
- // vertices and create an ''edge'' in the graph.
- if (have_nonempty_intersection (conflict_indices[i], conflict_indices[j]))
- {
- ++degrees[i];
- ++degrees[j];
- graph[i].push_back(j);
- graph[j].push_back(i);
- }
+ // If the two iterators share indices then we increase the degree of the
+ // vertices and create an ''edge'' in the graph.
+ if (have_nonempty_intersection (conflict_indices[i], conflict_indices[j]))
+ {
+ ++degrees[i];
+ ++degrees[j];
+ graph[i].push_back(j);
+ graph[j].push_back(i);
+ }
// Sort the vertices by decreasing degree.
std::vector<int>::iterator degrees_it;
*/
Threads::ThreadLocalStorage<std_cxx1x::shared_ptr<std::ostringstream> > outstreams;
- template <typename T> friend LogStream &operator << (LogStream & log, const T &t);
+ template <typename T> friend LogStream &operator << (LogStream &log, const T &t);
};
*/
template <typename T>
inline
-LogStream & operator<< (LogStream &log, const T &t)
+LogStream &operator<< (LogStream &log, const T &t)
{
// print to the internal stringstream
log.get_stream() << t;
* three elements.
*/
template <typename I1, typename I2,
- typename I3, typename I4>
+ typename I3, typename I4>
static
void
apply (const F &f,
* module.
*/
template <typename InputIterator,
- typename OutputIterator,
- typename Predicate>
+ typename OutputIterator,
+ typename Predicate>
void transform (const InputIterator &begin_in,
const InputIterator &end_in,
OutputIterator out,
* module.
*/
template <typename InputIterator1,
- typename InputIterator2,
- typename OutputIterator,
- typename Predicate>
+ typename InputIterator2,
+ typename OutputIterator,
+ typename Predicate>
void transform (const InputIterator1 &begin_in1,
const InputIterator1 &end_in1,
InputIterator2 in2,
* module.
*/
template <typename InputIterator1,
- typename InputIterator2,
- typename InputIterator3,
- typename OutputIterator,
- typename Predicate>
+ typename InputIterator2,
+ typename InputIterator3,
+ typename OutputIterator,
+ typename Predicate>
void transform (const InputIterator1 &begin_in1,
const InputIterator1 &end_in1,
InputIterator2 in2,
* for each subrange.
*/
template <typename ResultType,
- typename Function>
+ typename Function>
struct ReductionOnSubranges
{
/**
* Advance a tuple of iterators by $n$.
*/
template <typename I1, typename I2,
- typename I3, typename I4>
+ typename I3, typename I4>
inline
void advance (std_cxx1x::tuple<I1,I2,I3, I4> &t,
const unsigned int n)
* Advance a tuple of iterators by 1.
*/
template <typename I1, typename I2,
- typename I3, typename I4>
+ typename I3, typename I4>
inline
void advance_by_one (std_cxx1x::tuple<I1,I2,I3,I4> &t)
{
* for each number of arguments.
*/
template <typename RT, typename ArgList,
- int length = std_cxx1x::tuple_size<ArgList>::value>
+
int length = std_cxx1x::tuple_size<ArgList>::value>
struct fun_ptr_helper;
* returned by the function called on
* the thread.
*/
- std_cxx1x::shared_ptr<return_value<RT> > ret_val;
+ std_cxx1x::shared_ptr<return_value<RT> > ret_val;
/**
* Start the thread and
* Copy constructor.
*/
Thread (const Thread<RT> &t)
- :
- thread_descriptor (t.thread_descriptor)
+ :
+ thread_descriptor (t.thread_descriptor)
{}
/**
* @deprecated Use new_thread() instead.
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3>,3>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3)) DEAL_II_DEPRECATED;
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3>,3>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3))
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3>,3>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3)) DEAL_II_DEPRECATED;
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3>,3>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3))
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3>,3>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3) const) DEAL_II_DEPRECATED;
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3>,3>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3) const)
* @deprecated Use new_thread() instead.
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4)) DEAL_II_DEPRECATED;
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4))
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4)) DEAL_II_DEPRECATED;
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4))
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4) const) DEAL_II_DEPRECATED;
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4>,4>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4) const)
* @deprecated Use new_thread() instead.
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5)) DEAL_II_DEPRECATED;
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5))
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5)) DEAL_II_DEPRECATED;
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5))
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5) const) DEAL_II_DEPRECATED;
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5>,5>
spawn (const C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5) const)
* @deprecated Use new_thread() instead.
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6)) DEAL_II_DEPRECATED;
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6))
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6)) DEAL_II_DEPRECATED;
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
spawn (C &c, RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6))
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
internal::fun_encapsulator<RT,
std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
internal::fun_encapsulator<RT,
std_cxx1x::tuple<Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>,6>
* @deprecated Use new_thread() instead.
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6, Arg7>,7>
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
internal::fun_encapsulator<RT,
std_cxx1x::tuple<Arg1, Arg2, Arg3,
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
internal::fun_encapsulator<RT,
std_cxx1x::tuple<Arg1, Arg2, Arg3,
* @deprecated Use new_thread() instead.
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
internal::fun_encapsulator<RT,
std_cxx1x::tuple<Arg1, Arg2, Arg3,
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
internal::fun_encapsulator<RT,
std_cxx1x::tuple<Arg1, Arg2, Arg3,
* @deprecated Use new_thread() instead.
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
internal::fun_encapsulator<RT,std_cxx1x::tuple<Arg1, Arg2, Arg3,
Arg4, Arg5, Arg6,
* @deprecated Use new_thread() instead.
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
internal::fun_encapsulator<RT,
std_cxx1x::tuple<Arg1, Arg2, Arg3,
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
internal::fun_encapsulator<RT,
std_cxx1x::tuple<Arg1, Arg2, Arg3,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
Thread<RT>
new_thread (RT (*fun_ptr)(Arg1,Arg2,Arg3),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
Thread<RT>
new_thread (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
Thread<RT>
new_thread (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
Thread<RT>
new_thread (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
Thread<RT>
new_thread (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
Thread<RT>
new_thread (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
Thread<RT>
new_thread (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
Thread<RT>
new_thread (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* Copy constructor.
*/
Task (const Task<RT> &t)
- :
- task_descriptor (t.task_descriptor)
+ :
+ task_descriptor (t.task_descriptor)
{}
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
Task<RT>
new_task (RT (*fun_ptr)(Arg1,Arg2,Arg3),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3>
+ typename Arg1, typename Arg2, typename Arg3>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
Task<RT>
new_task (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
Task<RT>
new_task (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
Task<RT>
new_task (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
Task<RT>
new_task (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7),
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7) const,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
Task<RT>
new_task (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
Task<RT>
new_task (RT (*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* @ingroup threads
*/
template <typename RT, typename C,
- typename Arg1, typename Arg2, typename Arg3,
- typename Arg4, typename Arg5, typename Arg6,
- typename Arg7, typename Arg8, typename Arg9>
+ typename Arg1, typename Arg2, typename Arg3,
+ typename Arg4, typename Arg5, typename Arg6,
+ typename Arg7, typename Arg8, typename Arg9>
inline
Task<RT>
new_task (RT (C::*fun_ptr)(Arg1,Arg2,Arg3,Arg4,Arg5,
* A class that creates a sequence of items from a range of iterators.
*/
template <typename Iterator,
- typename ScratchData,
- typename CopyData>
+ typename ScratchData,
+ typename CopyData>
class IteratorRangeToItemStream : public tbb::filter
{
public:
* run in parallel.
*/
template <typename Iterator,
- typename ScratchData,
- typename CopyData>
+ typename ScratchData,
+ typename CopyData>
class Worker : public tbb::filter
{
public:
* they are created.
*/
template <typename Iterator,
- typename ScratchData,
- typename CopyData>
+ typename ScratchData,
+ typename CopyData>
class Copier : public tbb::filter
{
public:
* A class that creates a sequence of items from a range of iterators.
*/
template <typename Iterator,
- typename ScratchData,
- typename CopyData>
+ typename ScratchData,
+ typename CopyData>
class IteratorRangeToItemStream : public tbb::filter
{
public:
* run in parallel.
*/
template <typename Iterator,
- typename ScratchData,
- typename CopyData>
+ typename ScratchData,
+ typename CopyData>
class WorkerAndCopier : public tbb::filter
{
public:
* are generated.
*/
template <typename Worker,
- typename Copier,
- typename Iterator,
- typename ScratchData,
- typename CopyData>
+ typename Copier,
+ typename Iterator,
+ typename ScratchData,
+ typename CopyData>
void
run (const Iterator &begin,
const typename identity<Iterator>::type &end,
* are generated.
*/
template <typename Worker,
- typename Copier,
- typename Iterator,
- typename ScratchData,
- typename CopyData>
+ typename Copier,
+ typename Iterator,
+ typename ScratchData,
+ typename CopyData>
void
run (const std::vector<std::vector<Iterator> > &colored_iterators,
Worker worker,
* are generated.
*/
template <typename MainClass,
- typename Iterator,
- typename ScratchData,
- typename CopyData>
+ typename Iterator,
+ typename ScratchData,
+ typename CopyData>
void
run (const Iterator &begin,
const typename identity<Iterator>::type &end,
}
//forward declaration of the data type for periodic face pairs
-namespace GridTools {template <typename CellIterator> struct PeriodicFacePair;}
+namespace GridTools
+{
+ template <typename CellIterator> struct PeriodicFacePair;
+}
namespace parallel
{
register_data_attach (const std::size_t size,
const std_cxx1x::function<void (const cell_iterator &,
const CellStatus,
- void *)> & pack_callback);
+ void *)> &pack_callback);
/**
* The given function is called for
notify_ready_to_unpack (const unsigned int offset,
const std_cxx1x::function<void (const cell_iterator &,
const CellStatus,
- const void *)> & unpack_callback);
+ const void *)> &unpack_callback);
/**
* Returns a permutation vector for the order the coarse
*/
void
add_periodicity
- (const std::vector<GridTools::PeriodicFacePair<cell_iterator> >&);
+ (const std::vector<GridTools::PeriodicFacePair<cell_iterator> > &);
*/
void
fill_vertices_with_ghost_neighbors
- (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
- &vertices_with_ghost_neighbors);
+ (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
+ &vertices_with_ghost_neighbors);
template <int, int> friend class dealii::internal::DoFHandler::Policy::ParallelDistributed;
};
*/
void
fill_vertices_with_ghost_neighbors
- (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
- &vertices_with_ghost_neighbors);
+ (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
+ &vertices_with_ghost_neighbors);
};
}
{
return dof_handler.faces->lines.
get_dof_index (dof_handler,
- obj_index,
+ obj_index,
fe_index,
local_index,
obj_level);
const dealii::internal::int2type<1> &)
{
return dof_handler.levels[obj_level]->fe_index_is_active(obj_index,
- fe_index);
+ fe_index);
}
const unsigned int obj_index,
const dealii::internal::int2type<1> &)
{
- // on a cell, the number of active elements is one
+ // on a cell, the number of active elements is one
return 1;
}
const unsigned int n,
const dealii::internal::int2type<1> &)
{
- Assert (n==0, ExcMessage("On cells, there can only be one active FE index"));
+ Assert (n==0, ExcMessage("On cells, there can only be one active FE index"));
return dof_handler.levels[obj_level]->active_fe_index (obj_index);
}
const dealii::internal::int2type<2> &)
{
return dof_handler.levels[obj_level]->fe_index_is_active(obj_index,
- fe_index);
+ fe_index);
}
const unsigned int obj_index,
const dealii::internal::int2type<2> &)
{
- // on a cell, the number of active elements is one
+ // on a cell, the number of active elements is one
return 1;
}
const unsigned int n,
const dealii::internal::int2type<2> &)
{
- Assert (n==0, ExcMessage("On cells, there can only be one active FE index"));
+ Assert (n==0, ExcMessage("On cells, there can only be one active FE index"));
return dof_handler.levels[obj_level]->active_fe_index (obj_index);
}
const dealii::internal::int2type<3> &)
{
return dof_handler.levels[obj_level]->fe_index_is_active(obj_index,
- fe_index);
+ fe_index);
}
const unsigned int obj_index,
const dealii::internal::int2type<3> &)
{
- // on a cell, the number of active elements is one
+ // on a cell, the number of active elements is one
return 1;
}
const unsigned int n,
const dealii::internal::int2type<3> &)
{
- Assert (n==0, ExcMessage("On cells, there can only be one active FE index"));
+ Assert (n==0, ExcMessage("On cells, there can only be one active FE index"));
return dof_handler.levels[obj_level]->active_fe_index (obj_index);
}
Assert (static_cast<unsigned int>(accessor.present_index)
<
accessor.dof_handler->levels[accessor.present_level]
- ->cell_cache_offsets.size(),
+ ->cell_cache_offsets.size(),
ExcInternalError());
Assert (accessor.dof_handler->levels[accessor.present_level]
->cell_cache_offsets[accessor.present_index]
std::vector<types::global_dof_index> dof_indices (dofs_per_cell);
static_cast<const dealii::DoFAccessor<dim,dealii::hp::DoFHandler<dim,spacedim>,lda> &>
- (accessor).get_dof_indices (dof_indices, accessor.active_fe_index());
+ (accessor).get_dof_indices (dof_indices, accessor.active_fe_index());
types::global_dof_index *next_dof_index
- = &accessor.dof_handler->levels[accessor.present_level]
- ->cell_dof_indices_cache[accessor.dof_handler->levels[accessor.present_level]
- ->cell_cache_offsets[accessor.present_index]];
+ = &accessor.dof_handler->levels[accessor.present_level]
+ ->cell_dof_indices_cache[accessor.dof_handler->levels[accessor.present_level]
+ ->cell_cache_offsets[accessor.present_index]];
for (unsigned int i=0; i<dofs_per_cell; ++i, ++next_dof_index)
*next_dof_index = dof_indices[i];
}
ExcMessage ("DoFHandler not initialized"));
return accessor.dof_handler->levels[accessor.level()]
- ->active_fe_index(accessor.present_index);
+ ->active_fe_index(accessor.present_index);
}
ExcMessage ("DoFHandler not initialized"));
accessor.dof_handler->levels[accessor.level()]
- ->set_active_fe_index (accessor.present_index, i);
+ ->set_active_fe_index (accessor.present_index, i);
}
template <int dim, int spacedim, bool lda, typename number,
- class OutputMatrix, typename OutputVector>
+ class OutputMatrix, typename OutputVector>
static
void
distribute_local_to_global (const DoFCellAccessor<dealii::DoFHandler<dim,spacedim>, lda> &accessor,
template <int dim, int spacedim, bool lda, typename number,
- class OutputMatrix, typename OutputVector>
+ class OutputMatrix, typename OutputVector>
static
void
distribute_local_to_global (const DoFCellAccessor<dealii::hp::DoFHandler<dim,spacedim>, lda> &accessor,
AssertDimension (dof_indices.size(), this->get_fe().dofs_per_cell);
const types::global_dof_index *cache
- = this->dof_handler->levels[this->present_level]
- ->get_cell_cache_start (this->present_index, this->get_fe().dofs_per_cell);
+ = this->dof_handler->levels[this->present_level]
+ ->get_cell_cache_start (this->present_index, this->get_fe().dofs_per_cell);
for (unsigned int i=0; i<this->get_fe().dofs_per_cell; ++i, ++cache)
dof_indices[i] = *cache;
}
typename DoFCellAccessor::ExcVectorDoesNotMatch());
const types::global_dof_index *cache
- = this->dof_handler->levels[this->present_level]
- ->get_cell_cache_start (this->present_index, this->get_fe().dofs_per_cell);
+ = this->dof_handler->levels[this->present_level]
+ ->get_cell_cache_start (this->present_index, this->get_fe().dofs_per_cell);
values.extract_subvector_to (cache,
cache + this->get_fe().dofs_per_cell,
== this->get_fe().dofs_per_cell,
typename DoFCellAccessor::ExcVectorDoesNotMatch());
Assert (values.size() == this->get_dof_handler().n_dofs(),
- typename DoFCellAccessor::ExcVectorDoesNotMatch());
+ typename DoFCellAccessor::ExcVectorDoesNotMatch());
const types::global_dof_index *cache
- = this->dof_handler->levels[this->present_level]
- ->get_cell_cache_start (this->present_index, this->get_fe().dofs_per_cell);
+ = this->dof_handler->levels[this->present_level]
+ ->get_cell_cache_start (this->present_index, this->get_fe().dofs_per_cell);
constraints.get_dof_values(values, *cache, local_values_begin,
local_values_end);
== this->get_fe().dofs_per_cell,
typename DoFCellAccessor::ExcVectorDoesNotMatch());
Assert (values.size() == this->get_dof_handler().n_dofs(),
- typename DoFCellAccessor::ExcVectorDoesNotMatch());
+ typename DoFCellAccessor::ExcVectorDoesNotMatch());
const types::global_dof_index *cache
- = this->dof_handler->levels[this->present_level]
- ->get_cell_cache_start (this->present_index, this->get_fe().dofs_per_cell);
+ = this->dof_handler->levels[this->present_level]
+ ->get_cell_cache_start (this->present_index, this->get_fe().dofs_per_cell);
for (unsigned int i=0; i<this->get_fe().dofs_per_cell; ++i, ++cache)
values(*cache) = local_values(i);
*
* Defined in dof_handler.cc.
*/
- template<int dim, int spacedim>
- std::string policy_to_string(const dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> & policy);
+ template<int dim, int spacedim>
+ std::string policy_to_string(const dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> &policy);
}
"the one that was associated with the DoFHandler previously stored."));
AssertThrow (policy_name == internal::policy_to_string(*policy),
ExcMessage (std::string ("The policy currently associated with this DoFHandler (")
- + internal::policy_to_string(*policy)
- +std::string(") does not match the one that was associated with the "
- "DoFHandler previously stored (")
- + policy_name
- + ")."));
+ + internal::policy_to_string(*policy)
+ +std::string(") does not match the one that was associated with the "
+ "DoFHandler previously stored (")
+ + policy_name
+ + ")."));
}
*/
const types::global_dof_index *
get_cell_cache_start (const unsigned int obj_index,
- const unsigned int dofs_per_cell) const;
+ const unsigned int dofs_per_cell) const;
/**
* Determine an estimate for the
inline
const types::global_dof_index *
DoFLevel<dim>::get_cell_cache_start (const unsigned int obj_index,
- const unsigned int dofs_per_cell) const
+ const unsigned int dofs_per_cell) const
{
Assert (obj_index*dofs_per_cell+dofs_per_cell
<=
template <class GridClass> class InterGridMap;
template <int dim, int spacedim> class Mapping;
-namespace GridTools {template <typename CellIterator> struct PeriodicFacePair;}
+namespace GridTools
+{
+ template <typename CellIterator> struct PeriodicFacePair;
+}
//TODO: map_support_points_to_dofs should generate a multimap, rather than just a map, since several dofs may be located at the same support point
template<typename DH>
void
make_periodicity_constraints
- (const std::vector<GridTools::PeriodicFacePair<typename DH::cell_iterator> >
- &periodic_faces,
+ (const std::vector<GridTools::PeriodicFacePair<typename DH::cell_iterator> >
+ &periodic_faces,
dealii::ConstraintMatrix &constraint_matrix,
const ComponentMask &component_mask = ComponentMask());
*
* We follow the usual definition of the degree of RT elements, which
* denotes the polynomial degree of the largest complete polynomial
- * subspace contained in the RT space. Then, approxiamtion order of
+ * subspace contained in the RT space. Then, approximation order of
* the function itself is <i>degree+1</i>, as with usual polynomial
* spaces. The numbering so chosen implies the sequence
* @f[
* @p distribute function of your hanging node constraints object.
*/
template <int dim, int spacedim,
- template <int,int> class DH1,
- template <int,int> class DH2,
- class InVector, class OutVector>
+ template <int,int> class DH1,
+ template <int,int> class DH2,
+ class InVector, class OutVector>
void
interpolate (const DH1<dim,spacedim> &dof1,
const InVector &u1,
* DoF values at the discontinuities.
*/
template <int dim, int spacedim,
- template <int, int> class DH1,
- template <int, int> class DH2,
- class InVector, class OutVector>
+ template <int, int> class DH1,
+ template <int, int> class DH2,
+ class InVector, class OutVector>
void interpolate (const DH1<dim,spacedim> &dof1,
const InVector &u1,
const DH2<dim,spacedim> &dof2,
* type @p hp::DoFHandler.
*/
template <int dim,
- template <int> class DH,
- class InVector, class OutVector, int spacedim>
+ template <int> class DH,
+ class InVector, class OutVector, int spacedim>
void back_interpolate (const DH<dim> &dof1,
const InVector &u1,
const FiniteElement<dim,spacedim> &fe2,
*/
DeclException1 (ExcAccessToUninitializedField,
char *,
- << ("You are requesting information from an FEValues/FEFaceValues/FESubfaceValues "
- "object for which this kind of information has not been computed. What "
- "information these objects compute is determined by the update_* flags you "
- "pass to the constructor. Here, the operation you are attempting requires "
- "the <")
- << arg1
- << "> flag to be set, but it was apparently not specified upon construction.");
+ << ("You are requesting information from an FEValues/FEFaceValues/FESubfaceValues "
+ "object for which this kind of information has not been computed. What "
+ "information these objects compute is determined by the update_* flags you "
+ "pass to the constructor. Here, the operation you are attempting requires "
+ "the <")
+ << arg1
+ << "> flag to be set, but it was apparently not specified upon construction.");
/**
* @todo Document this
*
FEValuesBase<dim,spacedim>::get_quadrature_points () const
{
Assert (this->update_flags & update_quadrature_points,
- ExcAccessToUninitializedField("update_quadrature_points"));
+ ExcAccessToUninitializedField("update_quadrature_points"));
return this->quadrature_points;
}
FEValuesBase<dim,spacedim>::get_JxW_values () const
{
Assert (this->update_flags & update_JxW_values,
- ExcAccessToUninitializedField("update_JxW_values"));
+ ExcAccessToUninitializedField("update_JxW_values"));
return this->JxW_values;
}
FEValuesBase<dim,spacedim>::get_jacobians () const
{
Assert (this->update_flags & update_jacobians,
- ExcAccessToUninitializedField("update_jacobians"));
+ ExcAccessToUninitializedField("update_jacobians"));
return this->jacobians;
}
FEValuesBase<dim,spacedim>::get_jacobian_grads () const
{
Assert (this->update_flags & update_jacobian_grads,
- ExcAccessToUninitializedField("update_jacobians_grads"));
+ ExcAccessToUninitializedField("update_jacobians_grads"));
return this->jacobian_grads;
}
FEValuesBase<dim,spacedim>::get_inverse_jacobians () const
{
Assert (this->update_flags & update_inverse_jacobians,
- ExcAccessToUninitializedField("update_inverse_jacobians"));
+ ExcAccessToUninitializedField("update_inverse_jacobians"));
return this->inverse_jacobians;
}
FEValuesBase<dim,spacedim>::quadrature_point (const unsigned int i) const
{
Assert (this->update_flags & update_quadrature_points,
- ExcAccessToUninitializedField("update_quadrature_points"));
+ ExcAccessToUninitializedField("update_quadrature_points"));
Assert (i<this->quadrature_points.size(), ExcIndexRange(i, 0, this->quadrature_points.size()));
return this->quadrature_points[i];
FEValuesBase<dim,spacedim>::JxW (const unsigned int i) const
{
Assert (this->update_flags & update_JxW_values,
- ExcAccessToUninitializedField("update_JxW_values"));
+ ExcAccessToUninitializedField("update_JxW_values"));
Assert (i<this->JxW_values.size(), ExcIndexRange(i, 0, this->JxW_values.size()));
return this->JxW_values[i];
FEValuesBase<dim,spacedim>::jacobian (const unsigned int i) const
{
Assert (this->update_flags & update_jacobians,
- ExcAccessToUninitializedField("update_jacobians"));
+ ExcAccessToUninitializedField("update_jacobians"));
Assert (i<this->jacobians.size(), ExcIndexRange(i, 0, this->jacobians.size()));
return this->jacobians[i];
FEValuesBase<dim,spacedim>::jacobian_grad (const unsigned int i) const
{
Assert (this->update_flags & update_jacobian_grads,
- ExcAccessToUninitializedField("update_jacobians_grads"));
+ ExcAccessToUninitializedField("update_jacobians_grads"));
Assert (i<this->jacobian_grads.size(), ExcIndexRange(i, 0, this->jacobian_grads.size()));
return this->jacobian_grads[i];
FEValuesBase<dim,spacedim>::inverse_jacobian (const unsigned int i) const
{
Assert (this->update_flags & update_inverse_jacobians,
- ExcAccessToUninitializedField("update_inverse_jacobians"));
+ ExcAccessToUninitializedField("update_inverse_jacobians"));
Assert (i<this->inverse_jacobians.size(), ExcIndexRange(i, 0, this->inverse_jacobians.size()));
return this->inverse_jacobians[i];
*/
template<int dim>
void hyper_cube_with_cylindrical_hole (
- Triangulation<dim> &triangulation,
- const double inner_radius = .25,
- const double outer_radius = .5,
- const double L = .5,
- const unsigned int repetition = 1,
- const bool colorize = false);
+ Triangulation<dim> &triangulation,
+ const double inner_radius = .25,
+ const double outer_radius = .5,
+ const double L = .5,
+ const unsigned int repetition = 1,
+ const bool colorize = false);
/**
* Produce a ring of cells in 3D that is cut open, twisted and glued
/**
* This function will collect periodic face pairs on the
- * coarsest mesh level of the given @p container (a Triangulation or DoFHandler).
+ * coarsest mesh level of the given @p container (a Triangulation or
+ * DoFHandler) and add them to the vector @p matched_pairs leaving the
+ * original contents intact.
*
* Define a 'first' boundary as all boundary faces having boundary_id
* @p b_id1 and a 'second' boundary consisting of all faces belonging
* parallel::distributed::Triangulation::add_periodicity to enforce
* periodicity algebraically.
*
+ * @note Because elements will be added to @p matched_pairs (and existing
+ * entries will be preserved), it is possible to call this function several
+ * times with different boundary ids to generate a vector with all periodic
+ * pairs.
+ *
* @author Daniel Arndt, Matthias Maier, 2013
*/
template<typename CONTAINER>
- std::vector<PeriodicFacePair<typename CONTAINER::cell_iterator> >
+ void
collect_periodic_faces
(const CONTAINER &container,
const types::boundary_id b_id1,
const types::boundary_id b_id2,
const int direction,
+ std::vector<PeriodicFacePair<typename CONTAINER::cell_iterator> > &matched_pairs,
const dealii::Tensor<1,CONTAINER::space_dimension> &offset = dealii::Tensor<1,CONTAINER::space_dimension>());
* face with local face index <code>2*dimension+1</code> and boundary
* indicator @p b_id.
*
- * This function will collect periodic face pairs on the coarsest mesh level.
+ * This function will collect periodic face pairs on the coarsest mesh level
+ * and add them to @p matched_pairs leaving the original contents intact.
*
* @note This version of collect_periodic_face_pairs will not work on
* meshes with cells not in @ref GlossFaceOrientation
* @author Daniel Arndt, Matthias Maier, 2013
*/
template<typename CONTAINER>
- std::vector<PeriodicFacePair<typename CONTAINER::cell_iterator> >
+ void
collect_periodic_faces
(const CONTAINER &container,
const types::boundary_id b_id,
const int direction,
+ std::vector<PeriodicFacePair<typename CONTAINER::cell_iterator> > &matched_pairs,
const dealii::Tensor<1,CONTAINER::space_dimension> &offset = dealii::Tensor<1,CONTAINER::space_dimension>());
void serialize(Archive &ar,
const unsigned int version);
};
-
+
/**
* Store boundary and material data. For
* example, in one dimension, this field
return *(pointer + 1 + local_index);
else
pointer += static_cast<types::global_dof_index>(
- dof_handler.get_fe()[*pointer]
- .template n_dofs_per_object<structdim>() + 1);
+ dof_handler.get_fe()[*pointer]
+ .template n_dofs_per_object<structdim>() + 1);
}
}
return true;
else
pointer += static_cast<types::global_dof_index>(
- dof_handler.get_fe()[*pointer]
- .template n_dofs_per_object<structdim>()+1);
+ dof_handler.get_fe()[*pointer]
+ .template n_dofs_per_object<structdim>()+1);
}
}
* <tt>levels[]</tt> tree of
* the Triangulation objects.
*/
- std::vector<dealii::internal::hp::DoFLevel*> levels;
+ std::vector<dealii::internal::hp::DoFLevel *> levels;
/**
* Space to store the DoF
*/
void
set_active_fe_index (const unsigned int obj_index,
- const unsigned int fe_index);
+ const unsigned int fe_index);
/**
* Return a pointer to the beginning of the DoF indices cache
*/
const types::global_dof_index *
get_cell_cache_start (const unsigned int obj_index,
- const unsigned int dofs_per_cell) const;
+ const unsigned int dofs_per_cell) const;
/**
* Determine an estimate for the
"information is available"));
Assert (fe_index == active_fe_indices[obj_index],
- ExcMessage ("FE index does not match that of the present cell"));
+ ExcMessage ("FE index does not match that of the present cell"));
// see if the dof_indices array has been compressed for this
// particular cell
Assert ((signed_active_fe_index_type)active_fe_indices[obj_index]>=0,
ExcMessage ("This function can no longer be called after compressing the dof_indices array"));
Assert (fe_index == active_fe_indices[obj_index],
- ExcMessage ("FE index does not match that of the present cell"));
+ ExcMessage ("FE index does not match that of the present cell"));
dof_indices[dof_offsets[obj_index]+local_index] = global_index;
}
void
DoFLevel::
set_active_fe_index (const unsigned int obj_index,
- const unsigned int fe_index)
+ const unsigned int fe_index)
{
Assert (obj_index < active_fe_indices.size(),
ExcIndexRange (obj_index, 0, active_fe_indices.size()));
inline
const types::global_dof_index *
DoFLevel::get_cell_cache_start (const unsigned int obj_index,
- const unsigned int dofs_per_cell) const
+ const unsigned int dofs_per_cell) const
{
Assert (obj_index < cell_cache_offsets.size(),
ExcInternalError());
}
-/**
- * Cell matrix for gradient. The derivative is on the trial function.
- * \f[
- * \int_Z \nabla u \cdot \mathbf v\,dx
- * \f]
- *
- * This is the strong gradient and the trial space should be at least
- * in <i>H</i><sup>1</sup>. The test functions can be discontinuous.
- *
- * @author Guido Kanschat
- * @date 2011
- */
+ /**
+ * Cell matrix for gradient. The derivative is on the trial function.
+ * \f[
+ * \int_Z \nabla u \cdot \mathbf v\,dx
+ * \f]
+ *
+ * This is the strong gradient and the trial space should be at least
+ * in <i>H</i><sup>1</sup>. The test functions can be discontinuous.
+ *
+ * @author Guido Kanschat
+ * @date 2011
+ */
template <int dim>
void gradient_matrix(
FullMatrix<double> &M,
{
const double dx = fe1.JxW(k);
const Point<dim> &n = fe1.normal_vector(k);
- for (unsigned int i=0; i<n_dofs; ++i)
- {
- for (unsigned int j=0; j<n_dofs; ++j)
- {
- double u1dotn = 0.;
- double v1dotn = 0.;
- double u2dotn = 0.;
- double v2dotn = 0.;
-
- for (unsigned int d=0; d<dim; ++d)
- {
- u1dotn += n(d)*fe1.shape_value_component(j,k,d);
- v1dotn += n(d)*fe1.shape_value_component(i,k,d);
- u2dotn += n(d)*fe2.shape_value_component(j,k,d);
- v2dotn += n(d)*fe2.shape_value_component(i,k,d);
- }
-
- for (unsigned int d=0; d<fe1.get_fe().n_components(); ++d)
- {
-
- // multiply by
- const double vi = fe1.shape_value_component(i,k,d)*(1-v1dotn);
- const double dnvi = n * fe1.shape_grad_component(i,k,d)*(1-v1dotn);
- const double ve = fe2.shape_value_component(i,k,d)*(1-v2dotn);
- const double dnve = n * fe2.shape_grad_component(i,k,d)*(1-v2dotn);
- const double ui = fe1.shape_value_component(j,k,d)*(1-u1dotn);
- const double dnui = n * fe1.shape_grad_component(j,k,d)*(1-u1dotn);
- const double ue = fe2.shape_value_component(j,k,d)*(1-u2dotn);
- const double dnue = n * fe2.shape_grad_component(j,k,d)*(1-u2dotn);
+ for (unsigned int i=0; i<n_dofs; ++i)
+ {
+ for (unsigned int j=0; j<n_dofs; ++j)
+ {
+ double u1dotn = 0.;
+ double v1dotn = 0.;
+ double u2dotn = 0.;
+ double v2dotn = 0.;
+
+ double ngradu1n = 0.;
+ double ngradv1n = 0.;
+ double ngradu2n = 0.;
+ double ngradv2n = 0.;
+
+ for (unsigned int d=0; d<dim; ++d)
+ {
+ u1dotn += n(d)*fe1.shape_value_component(j,k,d);
+ v1dotn += n(d)*fe1.shape_value_component(i,k,d);
+ u2dotn += n(d)*fe2.shape_value_component(j,k,d);
+ v2dotn += n(d)*fe2.shape_value_component(i,k,d);
+
+ ngradu1n += n*fe1.shape_grad_component(j,k,d)*n(d);
+ ngradv1n += n*fe1.shape_grad_component(i,k,d)*n(d);
+ ngradu2n += n*fe2.shape_grad_component(j,k,d)*n(d);
+ ngradv2n += n*fe2.shape_grad_component(i,k,d)*n(d);
+ }
+
+ for (unsigned int d=0; d<fe1.get_fe().n_components(); ++d)
+ {
+ const double vi = fe1.shape_value_component(i,k,d)-v1dotn*n(d);
+ const double dnvi = n * fe1.shape_grad_component(i,k,d)-ngradv1n*n(d);
+
+ const double ve = fe2.shape_value_component(i,k,d)-v2dotn*n(d);
+ const double dnve = n * fe2.shape_grad_component(i,k,d)-ngradv2n*n(d);
+
+ const double ui = fe1.shape_value_component(j,k,d)-u1dotn*n(d);
+ const double dnui = n * fe1.shape_grad_component(j,k,d)-ngradu1n*n(d);
+
+ const double ue = fe2.shape_value_component(j,k,d)-u2dotn*n(d);
+ const double dnue = n * fe2.shape_grad_component(j,k,d)-ngradu2n*n(d);
+
M11(i,j) += dx*(-.5*nui*dnvi*ui-.5*nui*dnui*vi+nu*penalty*ui*vi);
M12(i,j) += dx*( .5*nui*dnvi*ue-.5*nue*dnue*vi-nu*penalty*vi*ue);
M21(i,j) += dx*(-.5*nue*dnve*ui+.5*nui*dnui*ve-nu*penalty*ui*ve);
* functions of ARPACK.
*/
template <typename VECTOR, typename MATRIX1,
- typename MATRIX2, typename INVERSE>
+ typename MATRIX2, typename INVERSE>
void solve(
const MATRIX1 &A,
const MATRIX2 &B,
template <typename VECTOR, typename MATRIX1,
- typename MATRIX2, typename INVERSE>
+ typename MATRIX2, typename INVERSE>
inline
void ArpackSolver::solve (
const MATRIX1 &system_matrix,
if (same_level_only && cell->neighbor(4)->neighbor(2)->level() != cell->level()) break;
if (cell->neighbor(4)->neighbor(0)->at_boundary(2)) break;
if (same_level_only && cell->neighbor(4)->neighbor(0)->neighbor(2)->level() != cell->level()) break;
- // No break here
+ // No break here
case 2:
if (cell->at_boundary(2)) break;
if (same_level_only && cell->neighbor(2)->level() != cell->level()) break;
indices[fe.face_to_cell_index(i,5)] = numbers::invalid_dof_index;
}
add(k, indices);
- // no break here
+ // no break here
case 1:
cell->get_mg_dof_indices(indices);
for (unsigned int i=0; i<fe.dofs_per_face; ++i)
* compiler.
*/
template <class BlockVectorType,
- class VectorType>
+ class VectorType>
void vmult_block_nonblock (BlockVectorType &dst,
const VectorType &src) const;
* compiler.
*/
template <class BlockVectorType,
- class VectorType>
+ class VectorType>
void vmult_nonblock_block (VectorType &dst,
const BlockVectorType &src) const;
* compiler.
*/
template <class BlockVectorType,
- class VectorType>
+ class VectorType>
void Tvmult_block_nonblock (BlockVectorType &dst,
const VectorType &src) const;
* compiler.
*/
template <class BlockVectorType,
- class VectorType>
+ class VectorType>
void Tvmult_nonblock_block (VectorType &dst,
const BlockVectorType &src) const;
* beginning of their use, so there is no point actually copying
* anything.
*/
- TemporaryData & operator = (const TemporaryData &)
+ TemporaryData &operator = (const TemporaryData &)
{
return *this;
}
template <class MatrixType>
template <class BlockVectorType,
- class VectorType>
+ class VectorType>
void
BlockMatrixBase<MatrixType>::
vmult_nonblock_block (VectorType &dst,
template <class MatrixType>
template <class BlockVectorType,
- class VectorType>
+ class VectorType>
void
BlockMatrixBase<MatrixType>::
vmult_block_nonblock (BlockVectorType &dst,
template <class MatrixType>
template <class BlockVectorType,
- class VectorType>
+ class VectorType>
void
BlockMatrixBase<MatrixType>::
Tvmult_block_nonblock (BlockVectorType &dst,
template <class MatrixType>
template <class BlockVectorType,
- class VectorType>
+ class VectorType>
void
BlockMatrixBase<MatrixType>::
Tvmult_nonblock_block (VectorType &dst,
* only one block column.
*/
template <typename block_number,
- typename nonblock_number>
+ typename nonblock_number>
void vmult (BlockVector<block_number> &dst,
const Vector<nonblock_number> &src) const;
* only one block row.
*/
template <typename block_number,
- typename nonblock_number>
+ typename nonblock_number>
void vmult (Vector<nonblock_number> &dst,
const BlockVector<block_number> &src) const;
* only one block row.
*/
template <typename block_number,
- typename nonblock_number>
+ typename nonblock_number>
void Tvmult (BlockVector<block_number> &dst,
const Vector<nonblock_number> &src) const;
* only one block column.
*/
template <typename block_number,
- typename nonblock_number>
+ typename nonblock_number>
void Tvmult (Vector<nonblock_number> &dst,
const BlockVector<block_number> &src) const;
template <typename number>
template <typename block_number,
- typename nonblock_number>
+ typename nonblock_number>
inline
void
BlockSparseMatrix<number>::vmult (BlockVector<block_number> &dst,
template <typename number>
template <typename block_number,
- typename nonblock_number>
+ typename nonblock_number>
inline
void
BlockSparseMatrix<number>::vmult (Vector<nonblock_number> &dst,
template <typename number>
template <typename block_number,
- typename nonblock_number>
+ typename nonblock_number>
inline
void
BlockSparseMatrix<number>::Tvmult (BlockVector<block_number> &dst,
template <typename number>
template <typename block_number,
- typename nonblock_number>
+ typename nonblock_number>
inline
void
BlockSparseMatrix<number>::Tvmult (Vector<nonblock_number> &dst,
template <typename OtherNumber>
inline
void BlockVectorBase<VectorType>::extract_subvector_to (const std::vector<size_type> &indices,
- std::vector<OtherNumber> &values) const
+ std::vector<OtherNumber> &values) const
{
for (size_type i = 0; i < indices.size(); ++i)
values[i] = operator()(indices[i]);
const ForwardIterator indices_end,
OutputIterator values_begin) const
{
- while (indices_begin != indices_end) {
- *values_begin = operator()(*indices_begin);
- indices_begin++; values_begin++;
- }
+ while (indices_begin != indices_end)
+ {
+ *values_begin = operator()(*indices_begin);
+ indices_begin++;
+ values_begin++;
+ }
}
#endif // DOXYGEN
* fragment.
*/
template <typename MatrixIterator,
- typename SrcIterator,
- typename DstIterator>
+ typename SrcIterator,
+ typename DstIterator>
inline
void
chunk_vmult_add (const size_type chunk_size,
* the residual.
*/
template <typename MatrixIterator,
- typename SrcIterator,
- typename DstIterator>
+ typename SrcIterator,
+ typename DstIterator>
inline
void
chunk_vmult_subtract (const size_type chunk_size,
* chunk_size to the destination vector fragment.
*/
template <typename MatrixIterator,
- typename SrcIterator,
- typename DstIterator>
+ typename SrcIterator,
+ typename DstIterator>
inline
void
chunk_Tvmult_add (const size_type chunk_size,
* individual chunk.
*/
template <typename result_type,
- typename MatrixIterator,
- typename SrcIterator1,
- typename SrcIterator2>
+ typename MatrixIterator,
+ typename SrcIterator1,
+ typename SrcIterator2>
inline
result_type
chunk_matrix_scalar_product (const size_type chunk_size,
* task scheduler.
*/
template <typename number,
- typename InVector,
- typename OutVector>
+ typename InVector,
+ typename OutVector>
void vmult_add_on_subrange (const ChunkSparsityPattern &cols,
const unsigned int begin_row,
const unsigned int end_row,
* IndexSet, whereas otherwise it contains the global problem size and the
* local range.
*/
- const IndexSet & get_local_lines() const;
+ const IndexSet &get_local_lines() const;
/**
* This function copies the content of @p constraints_in with DoFs that are
* <code>index2=index1</code>.
*/
bool are_identity_constrained (const size_type index1,
- const size_type index2) const;
+ const size_type index2) const;
/**
* Return the maximum number of other dofs that one dof is constrained
* prevent data races.
*/
template <typename ForwardIteratorVec, typename ForwardIteratorInd,
- class VectorType>
+ class VectorType>
void
distribute_local_to_global (ForwardIteratorVec local_vector_begin,
ForwardIteratorVec local_vector_end,
* set (i.e., distribute to be called).
*/
template <typename ForwardIteratorVec, typename ForwardIteratorInd,
- class VectorType>
+ class VectorType>
void
get_dof_values (const VectorType &global_vector,
ForwardIteratorInd local_indices_begin,
*/
bool sorted;
- /**
- * Scratch data that is used during calls to distribute_local_to_global and
- * add_entries_local_to_global. In order to avoid frequent memory
- * allocation, we keep the data alive from one call to the next.
- */
- struct ScratchData
- {
- /**
- * Constructor, does nothing.
- */
- ScratchData () :
- in_use (false)
- {}
-
- /**
- * Copy constructor, does nothing
- */
- ScratchData (const ScratchData &) :
- in_use (false)
- {}
-
- /**
- * Stores whether the data is currently in use.
- */
- bool in_use;
-
- /**
- * Temporary array for column indices
- */
- std::vector<size_type> columns;
-
- /**
- * Temporary array for column values
- */
- std::vector<double> values;
-
- /**
- * Temporary array for block start indices
- */
- std::vector<size_type> block_starts;
-
- /**
- * Temporary array for vector indices
- */
- std::vector<size_type> vector_indices;
-
- /**
- * Data array for reorder row/column indices. Use a shared ptr to
- * global_rows to avoid defining in the .h file
- */
- std_cxx1x::shared_ptr<internals::GlobalRowsFromLocal> global_rows;
-
- /**
- * Data array for reorder row/column indices. Use a shared ptr to
- * global_rows to avoid defining in the .h file
- */
- std_cxx1x::shared_ptr<internals::GlobalRowsFromLocal> global_columns;
- };
-
- /**
- * Here comes the actual data structure for the scratch data. It is made
- * mutable since it is modified in a const function. Since only one thread
- * can access it at a time, no conflicting access can occur. For this to be
- * valid, we need to make sure that no call within
- * distribute_local_to_global is made that by itself can spawn
- * tasks. Otherwise, we might end up in a situation where several threads
- * fight for the data.
- */
- mutable Threads::ThreadLocalStorage<ScratchData> scratch_data;
-
/**
* Internal function to calculate the index of line @p line in the vector
* lines_cache using local_lines.
:
lines (),
local_lines (local_constraints),
- sorted (false),
- scratch_data (ScratchData())
+ sorted (false)
{
// make sure the IndexSet is compressed. Otherwise this can lead to crashes
// that are hard to find (only happen in release mode).
lines (constraint_matrix.lines),
lines_cache (constraint_matrix.lines_cache),
local_lines (constraint_matrix.local_lines),
- sorted (constraint_matrix.sorted),
- scratch_data (ScratchData())
+ sorted (constraint_matrix.sorted)
{}
template <typename ForwardIteratorVec, typename ForwardIteratorInd,
- class VectorType>
+ class VectorType>
inline
void ConstraintMatrix::distribute_local_to_global (
ForwardIteratorVec local_vector_begin,
template <typename ForwardIteratorVec, typename ForwardIteratorInd,
- class VectorType>
+ class VectorType>
inline
void ConstraintMatrix::get_dof_values (const VectorType &global_vector,
ForwardIteratorInd local_indices_begin,
{
AssertDimension(data.size(), individual_size.size()*row_length);
// no space left in this row, need to double row_length and
- // rearrange the data items
+ // rearrange the data items. Move all items to the right except the
+ // first one, starting at the back. Since individual_size contains
+ // at least one element when we get here, subtracting 1 works fine.
data.resize(2*data.size());
- for (size_type i=individual_size.size(); i>0; )
- {
- --i;
- std::memmove(&data[i*row_length*2], &data[i*row_length],
- individual_size[i]*
- sizeof(std::pair<size_type,double>));
- }
+ for (size_type i=individual_size.size()-1; i>0; --i)
+ std::memmove(&data[i*row_length*2], &data[i*row_length],
+ individual_size[i]*
+ sizeof(std::pair<size_type,double>));
row_length *= 2;
}
data[index*row_length+my_length] = pair;
}
}
+
+
+ /**
+ * Scratch data that is used during calls to distribute_local_to_global and
+ * add_entries_local_to_global. In order to avoid frequent memory
+ * allocation, we keep the data alive from one call to the next in a static
+ * variable. Since we want to allow for different number types in matrices,
+ * this is a template.
+ *
+ * Since each thread gets its private version of scratch data out of the
+ * ThreadLocalStorage, no conflicting access can occur. For this to be
+ * valid, we need to make sure that no call within
+ * distribute_local_to_global is made that by itself can spawn
+ * tasks. Otherwise, we might end up in a situation where several threads
+ * fight for the data.
+ *
+ * Access to the scratch data is only through the accessor class which
+ * handles the access as well as marking the data as used.
+ */
+ template <typename Number>
+ class ConstraintMatrixData
+ {
+ public:
+ struct ScratchData
+ {
+ /**
+ * Constructor, does nothing.
+ */
+ ScratchData ()
+ :
+ in_use (false)
+ {}
+
+ /**
+ * Copy constructor, does nothing
+ */
+ ScratchData (const ScratchData &)
+ :
+ in_use (false)
+ {}
+
+ /**
+ * Stores whether the data is currently in use.
+ */
+ bool in_use;
+
+ /**
+ * Temporary array for column indices
+ */
+ std::vector<size_type> columns;
+
+ /**
+ * Temporary array for column values
+ */
+ std::vector<Number> values;
+
+ /**
+ * Temporary array for block start indices
+ */
+ std::vector<size_type> block_starts;
+
+ /**
+ * Temporary array for vector indices
+ */
+ std::vector<size_type> vector_indices;
+
+ /**
+ * Data array for reorder row/column indices. Use a shared ptr to
+ * global_rows to avoid defining in the .h file
+ */
+ GlobalRowsFromLocal global_rows;
+
+ /**
+ * Data array for reorder row/column indices. Use a shared ptr to
+ * global_rows to avoid defining in the .h file
+ */
+ GlobalRowsFromLocal global_columns;
+ };
+
+ /**
+ * Accessor class to guard access to scratch_data
+ */
+ class ScratchDataAccessor
+ {
+ public:
+ /**
+ * Constructor. Grabs a scratch data object on the current thread and
+ * mark it as used
+ */
+ ScratchDataAccessor()
+ :
+ my_scratch_data(&ConstraintMatrixData::scratch_data.get())
+ {
+ Assert(my_scratch_data->in_use == false,
+ ExcMessage("Access to thread-local scratch data tried, but it is already "
+ "in use"));
+ my_scratch_data->in_use = true;
+ }
+
+ /**
+ * Destructor. Mark scratch data as available again.
+ */
+ ~ScratchDataAccessor()
+ {
+ my_scratch_data->in_use = false;
+ }
+
+ /**
+ * Dereferencing operator.
+ */
+ ScratchData &operator* ()
+ {
+ return *my_scratch_data;
+ }
+
+ /**
+ * Dereferencing operator.
+ */
+ ScratchData *operator-> ()
+ {
+ return my_scratch_data;
+ }
+
+ private:
+ ScratchData *my_scratch_data;
+ };
+
+ private:
+ /**
+ * The actual data object that contains a scratch data for each thread.
+ */
+ static Threads::ThreadLocalStorage<ScratchData> scratch_data;
+ };
+
+
+
// function for block matrices: Find out where in the list of local dofs
// (sorted according to global ids) the individual blocks start. Transform
// the global indices to block-local indices in order to be able to use
const size_type n_local_dofs = local_dof_indices.size();
- ScratchData &my_scratch_data = scratch_data.get();
- Assert(my_scratch_data.in_use == false,
- ExcMessage("Access to thread-local scratch data tried, but it is already "
- "in use"));
- // TODO: might want to have a scoped variable for in_use here and in the
- // methods below
- my_scratch_data.in_use = true;
-
- if (my_scratch_data.global_rows.get() == 0)
- my_scratch_data.global_rows.reset(new internals::GlobalRowsFromLocal());
- internals::GlobalRowsFromLocal &global_rows = *my_scratch_data.global_rows;
+ typename internals::ConstraintMatrixData<number>::ScratchDataAccessor
+ scratch_data;
+
+ internals::GlobalRowsFromLocal &global_rows = scratch_data->global_rows;
global_rows.reinit(n_local_dofs);
make_sorted_row_list (local_dof_indices, global_rows);
// an array in any case since we cannot know about the actual data type in
// the ConstraintMatrix class (unless we do cast). This involves a little
// bit of logic to determine the type of the matrix value.
- std::vector<size_type> & cols = my_scratch_data.columns;
- std::vector<double> & vals = my_scratch_data.values;
- std::vector<number> values_non_double;
+ std::vector<size_type> &cols = scratch_data->columns;
+ std::vector<number> &vals = scratch_data->values;
SparseMatrix<number> *sparse_matrix
= dynamic_cast<SparseMatrix<number> *>(&global_matrix);
if (use_dealii_matrix == false)
{
cols.resize (n_actual_dofs);
- if (types_are_equal<double,number>::value == false)
- values_non_double.resize(n_actual_dofs);
- else
- vals.resize (n_actual_dofs);
+ vals.resize (n_actual_dofs);
}
else
Assert (sparse_matrix != 0, ExcInternalError());
size_type *col_ptr = &cols[0];
// cast is uncritical here and only used to avoid compiler
// warnings. We never access a non-double array
- number *val_ptr = types_are_equal<double,number>::value ?
- reinterpret_cast<number*>(&vals[0]) : &values_non_double[0];
+ number *val_ptr = &vals[0];
internals::resolve_matrix_row (global_rows, global_rows, i, 0,
n_actual_dofs,
local_matrix, col_ptr, val_ptr);
const size_type n_values = col_ptr - &cols[0];
if (n_values > 0)
- global_matrix.add(row, n_values, &cols[0], val_ptr-n_values, false,
+ global_matrix.add(row, n_values, &cols[0], &vals[0], false,
true);
}
else
internals::set_matrix_diagonals (global_rows, local_dof_indices,
local_matrix, *this,
global_matrix, global_vector, use_inhomogeneities_for_rhs);
- my_scratch_data.in_use = false;
}
const size_type n_local_row_dofs = row_indices.size();
const size_type n_local_col_dofs = col_indices.size();
- ScratchData &my_scratch_data = scratch_data.get();
- Assert(my_scratch_data.in_use == false,
- ExcMessage("Access to thread-local scratch data tried, but it is already "
- "in use"));
- my_scratch_data.in_use = true;
-
- if (my_scratch_data.global_rows.get() == 0)
- my_scratch_data.global_rows.reset(new internals::GlobalRowsFromLocal());
- if (my_scratch_data.global_columns.get() == 0)
- my_scratch_data.global_columns.reset(new internals::GlobalRowsFromLocal());
- internals::GlobalRowsFromLocal &global_rows = *my_scratch_data.global_rows;
+ typename internals::ConstraintMatrixData<number>::ScratchDataAccessor
+ scratch_data;
+ internals::GlobalRowsFromLocal &global_rows = scratch_data->global_rows;
global_rows.reinit(n_local_row_dofs);
- internals::GlobalRowsFromLocal &global_cols = *my_scratch_data.global_columns;
+ internals::GlobalRowsFromLocal &global_cols = scratch_data->global_columns;
global_cols.reinit(n_local_col_dofs);
make_sorted_row_list (row_indices, global_rows);
make_sorted_row_list (col_indices, global_cols);
// create arrays for the column data (indices and values) that will then be
// written into the matrix. Shortcut for deal.II sparse matrix
- std::vector<size_type> & cols = my_scratch_data.columns;
- std::vector<double> & vals = my_scratch_data.values;
- std::vector<number> values_non_double;
+ std::vector<size_type> &cols = scratch_data->columns;
+ std::vector<number> &vals = scratch_data->values;
cols.resize(n_actual_col_dofs);
- if (types_are_equal<double,number>::value == true)
- vals.resize(n_actual_col_dofs);
- else
- values_non_double.resize(n_actual_col_dofs);
+ vals.resize(n_actual_col_dofs);
// now do the actual job.
for (size_type i=0; i<n_actual_row_dofs; ++i)
// calculate all the data that will be written into the matrix row.
size_type *col_ptr = &cols[0];
- number *val_ptr = types_are_equal<double,number>::value ?
- reinterpret_cast<number*>(&vals[0]) : &values_non_double[0];
+ number *val_ptr = &vals[0];
internals::resolve_matrix_row (global_rows, global_cols, i, 0,
n_actual_col_dofs,
local_matrix, col_ptr, val_ptr);
const size_type n_values = col_ptr - &cols[0];
if (n_values > 0)
- global_matrix.add(row, n_values, &cols[0], val_ptr-n_values,
- false, true);
+ global_matrix.add(row, n_values, &cols[0], &vals[0], false, true);
}
-
- my_scratch_data.in_use = false;
}
}
Assert (sorted == true, ExcMatrixNotClosed());
- ScratchData &my_scratch_data = scratch_data.get();
- Assert(my_scratch_data.in_use == false,
- ExcMessage("Access to thread-local scratch data tried, but it is already "
- "in use"));
- my_scratch_data.in_use = true;
+ typename internals::ConstraintMatrixData<number>::ScratchDataAccessor
+ scratch_data;
const size_type n_local_dofs = local_dof_indices.size();
- if (my_scratch_data.global_rows.get() == 0)
- my_scratch_data.global_rows.reset(new internals::GlobalRowsFromLocal());
- internals::GlobalRowsFromLocal &global_rows = *my_scratch_data.global_rows;
+ internals::GlobalRowsFromLocal &global_rows = scratch_data->global_rows;
global_rows.reinit(n_local_dofs);
make_sorted_row_list (local_dof_indices, global_rows);
const size_type n_actual_dofs = global_rows.size();
- std::vector<size_type> &global_indices = my_scratch_data.vector_indices;
+ std::vector<size_type> &global_indices = scratch_data->vector_indices;
if (use_vectors == true)
{
global_indices.resize(n_actual_dofs);
// additional construct that also takes care of block indices.
const size_type num_blocks = global_matrix.n_block_rows();
- std::vector<size_type> &block_starts = my_scratch_data.block_starts;
+ std::vector<size_type> &block_starts = scratch_data->block_starts;
block_starts.resize(num_blocks+1);
internals::make_block_starts (global_matrix, global_rows, block_starts);
- std::vector<size_type> & cols = my_scratch_data.columns;
- std::vector<double> & vals = my_scratch_data.values;
- std::vector<number> values_non_double;
+ std::vector<size_type> &cols = scratch_data->columns;
+ std::vector<number> &vals = scratch_data->values;
if (use_dealii_matrix == false)
{
cols.resize (n_actual_dofs);
- if (types_are_equal<double,number>::value == true)
- vals.resize(n_actual_dofs);
- else
- values_non_double.resize(n_actual_dofs);
+ vals.resize (n_actual_dofs);
}
// the basic difference to the non-block variant from now onwards is that we
if (use_dealii_matrix == false)
{
size_type *col_ptr = &cols[0];
- number *val_ptr = types_are_equal<double,number>::value ?
- reinterpret_cast<number*>(&vals[0]) : &values_non_double[0];
+ number *val_ptr = &vals[0];
internals::resolve_matrix_row (global_rows, global_rows, i,
start_block, end_block,
local_matrix, col_ptr, val_ptr);
const size_type n_values = col_ptr - &cols[0];
if (n_values > 0)
global_matrix.block(block, block_col).add(row, n_values,
- &cols[0],
- val_ptr-n_values,
+ &cols[0], &vals[0],
false, true);
}
else
internals::set_matrix_diagonals (global_rows, local_dof_indices,
local_matrix, *this,
global_matrix, global_vector, use_inhomogeneities_for_rhs);
-
- my_scratch_data.in_use = false;
}
AssertDimension (dof_mask.n_cols(), n_local_dofs);
}
- ScratchData &my_scratch_data = scratch_data.get();
- Assert(my_scratch_data.in_use == false,
- ExcMessage("Access to thread-local scratch data tried, but it is already "
- "in use"));
- my_scratch_data.in_use = true;
+ internals::ConstraintMatrixData<double>::ScratchDataAccessor scratch_data;
// if the dof mask is not active, all we have to do is to add some indices
// in a matrix format. To do this, we first create an array of all the
// plus some indices that come from constraints.
if (dof_mask_is_active == false)
{
- std::vector<size_type> & actual_dof_indices = my_scratch_data.columns;
+ std::vector<size_type> &actual_dof_indices = scratch_data->columns;
actual_dof_indices.resize(n_local_dofs);
make_sorted_row_list (local_dof_indices, actual_dof_indices);
const size_type n_actual_dofs = actual_dof_indices.size();
sparsity_pattern.add (local_dof_indices[i], local_dof_indices[i]);
}
- my_scratch_data.in_use = false;
return;
}
// complicated case: we need to filter out some indices. then the function
// gets similar to the function for distributing matrix entries, see there
// for additional comments.
- if (my_scratch_data.global_rows.get() == 0)
- my_scratch_data.global_rows.reset(new internals::GlobalRowsFromLocal());
- internals::GlobalRowsFromLocal &global_rows = *my_scratch_data.global_rows;
+ internals::GlobalRowsFromLocal &global_rows = scratch_data->global_rows;
global_rows.reinit(n_local_dofs);
make_sorted_row_list (local_dof_indices, global_rows);
const size_type n_actual_dofs = global_rows.size();
// create arrays for the column indices that will then be written into the
// sparsity pattern.
- std::vector<size_type> & cols = my_scratch_data.columns;
+ std::vector<size_type> &cols = scratch_data->columns;
cols.resize(n_actual_dofs);
for (size_type i=0; i<n_actual_dofs; ++i)
internals::set_sparsity_diagonals (global_rows, local_dof_indices,
dof_mask, keep_constrained_entries,
sparsity_pattern);
- my_scratch_data.in_use = false;
}
const size_type n_local_dofs = local_dof_indices.size();
const size_type num_blocks = sparsity_pattern.n_block_rows();
- ScratchData &my_scratch_data = scratch_data.get();
- Assert(my_scratch_data.in_use == false,
- ExcMessage("Access to thread-local scratch data tried, but it is already "
- "in use"));
- my_scratch_data.in_use = true;
+ internals::ConstraintMatrixData<double>::ScratchDataAccessor scratch_data;
bool dof_mask_is_active = false;
if (dof_mask.n_rows() == n_local_dofs)
if (dof_mask_is_active == false)
{
- std::vector<size_type> & actual_dof_indices = my_scratch_data.columns;
+ std::vector<size_type> &actual_dof_indices = scratch_data->columns;
actual_dof_indices.resize(n_local_dofs);
make_sorted_row_list (local_dof_indices, actual_dof_indices);
const size_type n_actual_dofs = actual_dof_indices.size();
// additional construct that also takes care of block indices.
- std::vector<size_type> &block_starts = my_scratch_data.block_starts;
+ std::vector<size_type> &block_starts = scratch_data->block_starts;
block_starts.resize(num_blocks+1);
internals::make_block_starts (sparsity_pattern, actual_dof_indices,
block_starts);
sparsity_pattern.add (local_dof_indices[i], local_dof_indices[i]);
}
- my_scratch_data.in_use = false;
return;
}
// difficult case with dof_mask, similar to the distribute_local_to_global
// function for block matrices
- if (my_scratch_data.global_rows.get() == 0)
- my_scratch_data.global_rows.reset(new internals::GlobalRowsFromLocal());
- internals::GlobalRowsFromLocal &global_rows = *my_scratch_data.global_rows;
+ internals::GlobalRowsFromLocal &global_rows = scratch_data->global_rows;
global_rows.reinit(n_local_dofs);
make_sorted_row_list (local_dof_indices, global_rows);
const size_type n_actual_dofs = global_rows.size();
// additional construct that also takes care of block indices.
- std::vector<size_type> & block_starts = my_scratch_data.block_starts;
+ std::vector<size_type> &block_starts = scratch_data->block_starts;
block_starts.resize(num_blocks+1);
internals::make_block_starts(sparsity_pattern, global_rows, block_starts);
- std::vector<size_type> &cols = my_scratch_data.columns;
+ std::vector<size_type> &cols = scratch_data->columns;
cols.resize(n_actual_dofs);
// the basic difference to the non-block variant from now onwards is that we
internals::set_sparsity_diagonals (global_rows, local_dof_indices,
dof_mask, keep_constrained_entries,
sparsity_pattern);
- my_scratch_data.in_use = false;
}
*
* @author Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth, 1993-2004
*/
-template<typename number>
+template <typename number>
class FullMatrix : public Table<2,number>
{
public:
/**
- * Declare type of container size.
+ * A type of used to index into this container. Because we can not
+ * expect to store matrices bigger than what can be indexed by a regular
+ * unsigned integer, <code>unsigned int</code> is completely sufficient
+ * as an index type.
*/
- // A FullMatrix will never require to use unsigned long long int instead of
- // unsigned but because a ConstraintMatrix can be a SparseMatrix or a
- // FullMatrix, we need have the same interface.
- typedef types::global_dof_index size_type;
+ typedef unsigned int size_type;
/**
* Type of matrix entries. In analogy to
/**
* Variable assignment operator.
*/
- template<typename number2>
+ template <typename number2>
FullMatrix<number> &
operator = (const FullMatrix<number2> &);
* rows and columns in the current object. In other words,
* the current object is not resized for this operation.
*/
- template <typename MatrixType>
+ template <typename MatrixType, typename index_type>
void extract_submatrix_from (const MatrixType &matrix,
- const std::vector<size_type> &row_index_set,
- const std::vector<size_type> &column_index_set);
+ const std::vector<index_type> &row_index_set,
+ const std::vector<index_type> &column_index_set);
/**
* Copy the elements of the current matrix object into a specified
* rows and columns in the current object. In other words,
* the current object is not resized for this operation.
*/
- template <typename MatrixType>
+ template <typename MatrixType, typename index_type>
void
- scatter_matrix_to (const std::vector<size_type> &row_index_set,
- const std::vector<size_type> &column_index_set,
+ scatter_matrix_to (const std::vector<index_type> &row_index_set,
+ const std::vector<index_type> &column_index_set,
MatrixType &matrix) const;
/**
* determined either by the size
* of <tt>this</tt> or <tt>src</tt>.
*/
- template<typename number2>
+ template <typename number2>
void fill (const FullMatrix<number2> &src,
const size_type dst_offset_i = 0,
const size_type dst_offset_j = 0,
* Make function of base class
* available.
*/
- template<typename number2>
+ template <typename number2>
void fill (const number2 *);
/**
* possible to duplicate rows or
* columns by this method.
*/
- template<typename number2>
+ template <typename number2>
void fill_permutation (const FullMatrix<number2> &src,
const std::vector<size_type> &p_rows,
const std::vector<size_type> &p_cols);
* complex-valued, but not mixed, for
* this function to make sense.
*/
- template<typename number2>
+ template <typename number2>
number2 matrix_norm_square (const Vector<number2> &v) const;
/**
* complex-valued, but not mixed, for
* this function to make sense.
*/
- template<typename number2>
+ template <typename number2>
number2 matrix_scalar_product (const Vector<number2> &u,
const Vector<number2> &v) const;
* convertible to the data type
* of this matrix.
*/
- template<typename number2>
+ template <typename number2>
void add (const number a,
const FullMatrix<number2> &A);
* convertible to the data type
* of this matrix.
*/
- template<typename number2>
+ template <typename number2>
void add (const number a,
const FullMatrix<number2> &A,
const number b,
* is convertible to the data
* type of this matrix.
*/
- template<typename number2>
+ template <typename number2>
void add (const number a,
const FullMatrix<number2> &A,
const number b,
* size of <tt>this</tt> or <tt>src</tt>
* and the given offsets.
*/
- template<typename number2>
+ template <typename number2>
void add (const FullMatrix<number2> &src,
const number factor,
const size_type dst_offset_i = 0,
*
* <i>A += s B<sup>T</sup></i>
*/
- template<typename number2>
+ template <typename number2>
void Tadd (const number s,
const FullMatrix<number2> &B);
* of <tt>this</tt> or
* <tt>src</tt>.
*/
- template<typename number2>
+ template <typename number2>
void Tadd (const FullMatrix<number2> &src,
const number factor,
const size_type dst_offset_i = 0,
* and are indeed ignored in the
* implementation.
*/
- template <typename number2>
+ template <typename number2, typename index_type>
void add (const size_type row,
- const size_type n_cols,
- const size_type *col_indices,
+ const unsigned int n_cols,
+ const index_type *col_indices,
const number2 *values,
const bool elide_zero_values = true,
const bool col_indices_are_sorted = false);
* Assignment <tt>*this =
* a*A</tt>.
*/
- template<typename number2>
+ template <typename number2>
void equ (const number a,
const FullMatrix<number2> &A);
* Assignment <tt>*this = a*A +
* b*B</tt>.
*/
- template<typename number2>
+ template <typename number2>
void equ (const number a,
const FullMatrix<number2> &A,
const number b,
* Assignment <tt>*this = a*A +
* b*B + c*C</tt>.
*/
- template<typename number2>
+ template <typename number2>
void equ (const number a,
const FullMatrix<number2> &A,
const number b,
* usually results in considerable
* performance gains.
*/
- template<typename number2>
+ template <typename number2>
void mmult (FullMatrix<number2> &C,
const FullMatrix<number2> &B,
const bool adding=false) const;
* BLAS usually results in considerable
* performance gains.
*/
- template<typename number2>
+ template <typename number2>
void Tmmult (FullMatrix<number2> &C,
const FullMatrix<number2> &B,
const bool adding=false) const;
* usually results in considerable
* performance gains.
*/
- template<typename number2>
+ template <typename number2>
void mTmult (FullMatrix<number2> &C,
const FullMatrix<number2> &B,
const bool adding=false) const;
* BLAS usually results in considerable
* performance gains.
*/
- template<typename number2>
+ template <typename number2>
void TmTmult (FullMatrix<number2> &C,
const FullMatrix<number2> &B,
const bool adding=false) const;
* Source and destination must
* not be the same vector.
*/
- template<typename number2>
+ template <typename number2>
void vmult (Vector<number2> &w,
const Vector<number2> &v,
const bool adding=false) const;
* Source and destination must
* not be the same vector.
*/
- template<typename number2>
+ template <typename number2>
void vmult_add (Vector<number2> &w,
const Vector<number2> &v) const;
* Source and destination must
* not be the same vector.
*/
- template<typename number2>
+ template <typename number2>
void Tvmult (Vector<number2> &w,
const Vector<number2> &v,
const bool adding=false) const;
* Source and destination must
* not be the same vector.
*/
- template<typename number2>
+ template <typename number2>
void Tvmult_add (Vector<number2> &w,
const Vector<number2> &v) const;
* <i>dst</i> must not be the same
* vector.
*/
- template<typename number2, typename number3>
+ template <typename number2, typename number3>
number residual (Vector<number2> &dst,
const Vector<number2> &x,
const Vector<number3> &b) const;
* same object for @p dst and @p
* src.
*/
- template<typename number2>
+ template <typename number2>
void forward (Vector<number2> &dst,
const Vector<number2> &src) const;
* same object for @p dst and @p
* src.
*/
- template<typename number2>
+ template <typename number2>
void backward (Vector<number2> &dst,
const Vector<number2> &src) const;
template <typename number>
-template <typename MatrixType>
+template <typename MatrixType, typename index_type>
inline
void
FullMatrix<number>::extract_submatrix_from (const MatrixType &matrix,
- const std::vector<size_type> &row_index_set,
- const std::vector<size_type> &column_index_set)
+ const std::vector<index_type> &row_index_set,
+ const std::vector<index_type> &column_index_set)
{
AssertDimension(row_index_set.size(), this->n_rows());
AssertDimension(column_index_set.size(), this->n_cols());
template <typename number>
-template <typename MatrixType>
+template <typename MatrixType, typename index_type>
inline
void
-FullMatrix<number>::scatter_matrix_to (const std::vector<size_type> &row_index_set,
- const std::vector<size_type> &column_index_set,
+FullMatrix<number>::scatter_matrix_to (const std::vector<index_type> &row_index_set,
+ const std::vector<index_type> &column_index_set,
MatrixType &matrix) const
{
AssertDimension(row_index_set.size(), this->n_rows());
template <typename number>
-template<typename number2>
+template <typename number2>
void
FullMatrix<number>::vmult_add (Vector<number2> &w,
const Vector<number2> &v) const
template <typename number>
-template<typename number2>
+template <typename number2>
void
FullMatrix<number>::Tvmult_add (Vector<number2> &w,
const Vector<number2> &v) const
template <typename number>
-template <typename number2>
+template <typename number2, typename index_type>
inline
void
-FullMatrix<number>::add (const size_type row,
- const size_type n_cols,
- const size_type *col_indices,
- const number2 *values,
+FullMatrix<number>::add (const size_type row,
+ const unsigned int n_cols,
+ const index_type *col_indices,
+ const number2 *values,
const bool,
const bool)
{
inline void
syev (const char *jobz, const char *uplo, const int *n, double *A, const int *lda, double *w, double *work, const int *lwork, int *info)
{
- dsyev_ (char*jobz,char*uplo,int*n,double*A,int*lda,double*w,double*work,int*lwork,int*info);
+ dsyev_ (char *jobz,char *uplo,int *n,double*A,int *lda,double*w,double*work,int *lwork,int *info);
}
#else
inline void
inline void
syev (const char *jobz, const char *uplo, const int *n, float *A, const int *lda, float *w, float *work, const int *lwork, int *info)
{
- ssyev_ (char*jobz,char*uplo,int*n,double*A,int*lda,double*w,double*work,int*lwork,int*info);
+ ssyev_ (char *jobz,char *uplo,int *n,double*A,int *lda,double*w,double*work,int *lwork,int *info);
}
#else
inline void
*
* Default value is one.
*/
- size_type block_size;
+ unsigned int block_size;
/**
* If true, plot
* structure to their default
* values.
*/
- Options (const bool show_absolute_values = false,
- const size_type block_size = 1,
- const bool discontinuous = false);
+ Options (const bool show_absolute_values = false,
+ const unsigned int block_size = 1,
+ const bool discontinuous = false);
};
/**
return std::fabs(get_element (matrix, i, j));
else
return get_element (matrix, i, j);
- };
+ }
// if blocksize greater than one,
// then compute average of elements
double average = 0;
size_type n_elements = 0;
for (size_type row=i*options.block_size;
- row < std::min(matrix.m(), (i+1)*options.block_size); ++row)
+ row < std::min(size_type(matrix.m()),
+ size_type((i+1)*options.block_size)); ++row)
for (size_type col=j*options.block_size;
- col < std::min(matrix.m(), (j+1)*options.block_size); ++col, ++n_elements)
+ col < std::min(size_type(matrix.m()),
+ size_type((j+1)*options.block_size)); ++col, ++n_elements)
if (options.show_absolute_values == true)
average += std::fabs(get_element (matrix, row, col));
else
template <typename Number>
inline
BlockVector<Number>::BlockVector (const std::vector<IndexSet> &local_ranges,
- const std::vector<IndexSet> &ghost_indices,
- const MPI_Comm communicator)
+ const std::vector<IndexSet> &ghost_indices,
+ const MPI_Comm communicator)
{
std::vector<size_type> sizes(local_ranges.size());
for (unsigned int i=0; i<local_ranges.size(); ++i)
template <typename Number>
inline
BlockVector<Number>::BlockVector (const std::vector<IndexSet> &local_ranges,
- const MPI_Comm communicator)
+ const MPI_Comm communicator)
{
std::vector<size_type> sizes(local_ranges.size());
for (unsigned int i=0; i<local_ranges.size(); ++i)
// we only allow assignment to vectors with the same number of blocks
// or to an empty BlockVector
Assert (this->n_blocks() == 0 || this->n_blocks() == v.n_blocks(),
- ExcDimensionMismatch(this->n_blocks(), v.n_blocks()));
+ ExcDimensionMismatch(this->n_blocks(), v.n_blocks()));
if (this->n_blocks() != v.n_blocks())
reinit(v.n_blocks(), true);
while (indices_begin != indices_end)
{
*values_begin = operator()(*indices_begin);
- indices_begin++; values_begin++;
+ indices_begin++;
+ values_begin++;
}
}
const size_type row,
const size_type index);
- /**
- * Copy constructor.
- */
- Accessor (const Accessor &a);
+ /**
+ * Copy constructor.
+ */
+ Accessor (const Accessor &a);
/**
* Row number of the element
// we only allow assignment to vectors with the same number of blocks
// or to an empty BlockVector
Assert (n_blocks() == 0 || n_blocks() == v.n_blocks(),
- ExcDimensionMismatch(n_blocks(), v.n_blocks()));
+ ExcDimensionMismatch(n_blocks(), v.n_blocks()));
if (this->n_blocks() != v.n_blocks())
reinit(v.n_blocks());
// if we are dealing
// with a parallel vector
if (ghosted )
- {
-
- int ierr;
-
- // there is the possibility
- // that the vector has
- // ghost elements. in that
- // case, we first need to
- // figure out which
- // elements we own locally,
- // then get a pointer to
- // the elements that are
- // stored here (both the
- // ones we own as well as
- // the ghost elements). in
- // this array, the locally
- // owned elements come
- // first followed by the
- // ghost elements whose
- // position we can get from
- // an index set
- PetscInt begin, end, i;
- ierr = VecGetOwnershipRange (vector, &begin, &end);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
+ {
+
+ int ierr;
+
+ // there is the possibility
+ // that the vector has
+ // ghost elements. in that
+ // case, we first need to
+ // figure out which
+ // elements we own locally,
+ // then get a pointer to
+ // the elements that are
+ // stored here (both the
+ // ones we own as well as
+ // the ghost elements). in
+ // this array, the locally
+ // owned elements come
+ // first followed by the
+ // ghost elements whose
+ // position we can get from
+ // an index set
+ PetscInt begin, end, i;
+ ierr = VecGetOwnershipRange (vector, &begin, &end);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
+
+ Vec locally_stored_elements = PETSC_NULL;
+ ierr = VecGhostGetLocalForm(vector, &locally_stored_elements);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
+
+ PetscInt lsize;
+ ierr = VecGetSize(locally_stored_elements, &lsize);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
+
+ PetscScalar *ptr;
+ ierr = VecGetArray(locally_stored_elements, &ptr);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
+
+ for (i = 0; i < n_idx; i++)
+ {
+ const unsigned int index = *(indices_begin+i);
+ if ( index>=static_cast<unsigned int>(begin)
+ && index<static_cast<unsigned int>(end) )
+ {
+ //local entry
+ *(values_begin+i) = *(ptr+index-begin);
+ }
+ else
+ {
+ //ghost entry
+ const unsigned int ghostidx
+ = ghost_indices.index_within_set(index);
+
+ Assert(ghostidx+end-begin<(unsigned int)lsize, ExcInternalError());
+ *(values_begin+i) = *(ptr+ghostidx+end-begin);
+ }
+ }
+
+ ierr = VecRestoreArray(locally_stored_elements, &ptr);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
+
+ ierr = VecGhostRestoreLocalForm(vector, &locally_stored_elements);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
- Vec locally_stored_elements = PETSC_NULL;
- ierr = VecGhostGetLocalForm(vector, &locally_stored_elements);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
-
- PetscInt lsize;
- ierr = VecGetSize(locally_stored_elements, &lsize);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
-
- PetscScalar *ptr;
- ierr = VecGetArray(locally_stored_elements, &ptr);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
-
- for (i = 0; i < n_idx; i++) {
- const unsigned int index = *(indices_begin+i);
- if ( index>=static_cast<unsigned int>(begin)
- && index<static_cast<unsigned int>(end) )
- {
- //local entry
- *(values_begin+i) = *(ptr+index-begin);
- }
- else
- {
- //ghost entry
- const unsigned int ghostidx
- = ghost_indices.index_within_set(index);
-
- Assert(ghostidx+end-begin<(unsigned int)lsize, ExcInternalError());
- *(values_begin+i) = *(ptr+ghostidx+end-begin);
- }
}
-
- ierr = VecRestoreArray(locally_stored_elements, &ptr);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
-
- ierr = VecGhostRestoreLocalForm(vector, &locally_stored_elements);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
-
- }
// if the vector is local or the
// caller, then simply access the
// element we are interested in
else
- {
- int ierr;
+ {
+ int ierr;
- PetscInt begin, end;
- ierr = VecGetOwnershipRange (vector, &begin, &end);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
+ PetscInt begin, end;
+ ierr = VecGetOwnershipRange (vector, &begin, &end);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
- PetscScalar *ptr;
- ierr = VecGetArray(vector, &ptr);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
+ PetscScalar *ptr;
+ ierr = VecGetArray(vector, &ptr);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
- for (PetscInt i = 0; i < n_idx; i++) {
- const unsigned int index = *(indices_begin+i);
+ for (PetscInt i = 0; i < n_idx; i++)
+ {
+ const unsigned int index = *(indices_begin+i);
- Assert(index>=static_cast<unsigned int>(begin)
- && index<static_cast<unsigned int>(end), ExcInternalError());
+ Assert(index>=static_cast<unsigned int>(begin)
+ && index<static_cast<unsigned int>(end), ExcInternalError());
- *(values_begin+i) = *(ptr+index-begin);
- }
+ *(values_begin+i) = *(ptr+index-begin);
+ }
- ierr = VecRestoreArray(vector, &ptr);
- AssertThrow (ierr == 0, ExcPETScError(ierr));
+ ierr = VecRestoreArray(vector, &ptr);
+ AssertThrow (ierr == 0, ExcPETScError(ierr));
- }
+ }
}
#endif // DOXYGEN
* @author Ralf Hartmann, 1999
*/
template <class MATRIX = SparseMatrix<double>,
- class VECTOR = dealii::Vector<double> >
+ class VECTOR = dealii::Vector<double> >
class PreconditionSelector : public Subscriptor
{
public:
*/
void
solve (const unsigned int n_eigenpairs,
- unsigned int *n_converged);
+ unsigned int *n_converged);
/**
* Access the real parts of solutions for a solved eigenvector
* preconditioners.
*/
class AdditionalData
-{};
+ {};
/**
*/
template <class STREAM>
void print (STREAM &out,
- const bool across = false,
- const bool diagonal_first = true) const;
+ const bool across = false,
+ const bool diagonal_first = true) const;
/**
* Print the matrix in the usual format, i.e. as a matrix and not as a list
template <class STREAM>
inline
void SparseMatrix<number>::print (STREAM &out,
- const bool across,
- const bool diagonal_first) const
+ const bool across,
+ const bool diagonal_first) const
{
Assert (cols != 0, ExcNotInitialized());
Assert (val != 0, ExcNotInitialized());
* task scheduler.
*/
template <typename number,
- typename InVector,
- typename OutVector>
+ typename InVector,
+ typename OutVector>
void vmult_on_subrange (const size_type begin_row,
const size_type end_row,
const number *values,
* scheduler.
*/
template <typename number,
- typename InVector>
+ typename InVector>
number matrix_norm_sqr_on_subrange (const size_type begin_row,
const size_type end_row,
const number *values,
* scheduler.
*/
template <typename number,
- typename InVector>
+ typename InVector>
number matrix_scalar_product_on_subrange (const size_type begin_row,
const size_type end_row,
const number *values,
* scheduler.
*/
template <typename number,
- typename InVector,
- typename OutVector>
+ typename InVector,
+ typename OutVector>
number residual_sqr_on_subrange (const size_type begin_row,
const size_type end_row,
const number *values,
/**
* similar to the function above, but includes support for
* BlockCompressedSimpleSparsityPattern.
- * @p owned_set_per_cpu is typically DoFHandler::locally_owned_dofs_per_processor
+ * @p owned_set_per_cpu is typically DoFHandler::locally_owned_dofs_per_processor
* and @p myrange are locally_relevant_dofs.
*/
template <class CSP_t>
* be ignored.
*/
BlockVector (const std::vector<IndexSet> ¶llel_partitioning,
- const std::vector<IndexSet> &ghost_values,
- const MPI_Comm &communicator);
+ const std::vector<IndexSet> &ghost_values,
+ const MPI_Comm &communicator);
/**
inline
BlockVector::BlockVector (const std::vector<IndexSet> ¶llel_partitioning,
- const std::vector<IndexSet> &ghost_values,
- const MPI_Comm &communicator)
+ const std::vector<IndexSet> &ghost_values,
+ const MPI_Comm &communicator)
{
reinit(parallel_partitioning, ghost_values, communicator);
}
* Apply the transpose preconditioner.
*/
virtual void Tvmult (VectorBase &dst,
- const VectorBase &src) const;
+ const VectorBase &src) const;
/**
* Apply the preconditioner on
const VectorBase &src) const;
/**
- * Apply the preconditioner on deal.II data structures
- * instead of the ones provided in the Trilinos wrapper class,
+ * Apply the preconditioner on deal.II data structures
+ * instead of the ones provided in the Trilinos wrapper class,
* i.e., dst = src.
*/
void vmult (dealii::Vector<double> &dst,
const dealii::Vector<double> &src) const;
/**
- * Apply the transpose preconditioner on deal.II data structures
+ * Apply the transpose preconditioner on deal.II data structures
* instead of the ones provided in the Trilinos wrapper class,
* i.e. dst = src.
*/
const dealii::Vector<double> &src) const;
/**
- * Apply the preconditioner on deal.II parallel data structures
+ * Apply the preconditioner on deal.II parallel data structures
* instead of the ones provided in the Trilinos wrapper class,
* i.e., dst = src.
*/
const dealii::parallel::distributed::Vector<double> &src) const;
/**
- * Apply the transpose preconditioner on deal.II parallel data structures
+ * Apply the transpose preconditioner on deal.II parallel data structures
* instead of the ones provided in the Trilinos wrapper class,
* i.e., dst = src.
*/
const ForwardIterator indices_end,
OutputIterator values_begin) const
{
- while (indices_begin != indices_end) {
- *values_begin = operator()(*indices_begin);
- indices_begin++; values_begin++;
- }
+ while (indices_begin != indices_end)
+ {
+ *values_begin = operator()(*indices_begin);
+ indices_begin++;
+ values_begin++;
+ }
}
}
-
+
#endif // DOXYGEN
}
const ForwardIterator indices_end,
OutputIterator values_begin) const
{
- while (indices_begin != indices_end) {
- *values_begin = operator()(*indices_begin);
- indices_begin++; values_begin++;
- }
+ while (indices_begin != indices_end)
+ {
+ *values_begin = operator()(*indices_begin);
+ indices_begin++;
+ values_begin++;
+ }
}
// The code returns the result as the last argument in order to make
// spawning tasks simpler and use automatic template deduction.
template <typename Operation, typename Number, typename Number2,
- typename ResultType, typename size_type>
+ typename ResultType, typename size_type>
void accumulate (const Operation &op,
const Number *X,
const Number2 *Y,
r2 = op(X, Y, power);
for (size_type j=1; j<8; ++j)
r2 += op(X, Y, power);
- // no break
+ // no break
case 2:
r1 = op(X, Y, power);
for (size_type j=1; j<8; ++j)
r1 += op(X, Y, power);
r1 += r2;
- // no break
+ // no break
case 1:
r2 = op(X, Y, power);
for (size_type j=1; j<8; ++j)
r2 += op(X, Y, power);
- // no break
+ // no break
default:
for (size_type j=0; j<remainder_inner; ++j)
r0 += op(X, Y, power);
// locally owned plus the number of ghosts
const unsigned int index_range = (vector_partitioner->local_range().second-
vector_partitioner->local_range().first)
- + vector_partitioner->ghost_indices().n_elements();
+ + vector_partitioner->ghost_indices().n_elements();
for (std::size_t i=0; i<dof_indices.size(); ++i)
AssertIndexRange (dof_indices[i], index_range);
else
{
const unsigned int *it = begin_indices (block),
- * end_cell = end_indices (block);
+ * end_cell = end_indices (block);
for ( ; it != end_cell; ++it)
if (row_lengths[*it] > 0)
{
{
out << "Entries row " << row << ": ";
const unsigned int *glob_indices = begin_indices(row),
- *end_row = end_indices(row);
+ *end_row = end_indices(row);
unsigned int index = 0;
const std::pair<unsigned short,unsigned short>
*con_it = begin_indicators(row),
* @author Katharina Kormann and Martin Kronbichler, 2010, 2011
*/
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
class FEEvaluationBase
{
public:
* @author Katharina Kormann and Martin Kronbichler, 2010, 2011
*/
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
class FEEvaluationAccess :
public FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
{
* @author Katharina Kormann and Martin Kronbichler, 2010, 2011
*/
template <int dim, int fe_degree, int n_q_points_1d = fe_degree+1,
- int n_components_ = 1, typename Number = double >
+ int n_components_ = 1, typename Number = double >
class FEEvaluationGeneral :
public FEEvaluationAccess<dim,
Utilities::fixed_int_power<fe_degree+1,dim>::value,
* @author Katharina Kormann and Martin Kronbichler, 2010, 2011
*/
template <int dim, int fe_degree, int n_q_points_1d = fe_degree+1,
- int n_components_ = 1, typename Number = double >
+ int n_components_ = 1, typename Number = double >
class FEEvaluation :
public FEEvaluationGeneral<dim,fe_degree,n_q_points_1d,n_components_,Number>
{
/*----------------------- FEEvaluationBase ----------------------------------*/
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
::FEEvaluationBase (const MatrixFree<dim,Number> &data_in,
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
void
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
unsigned int
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
internal::MatrixFreeFunctions::CellType
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
VectorType &vec,
Number &res) const
{
- res = vector_access (const_cast<const VectorType&>(vec), index);
+ res = vector_access (const_cast<const VectorType &>(vec), index);
}
void pre_constraints (const Number &,
VectorType &vec,
Number &res) const
{
- res += weight * vector_access (const_cast<const VectorType&>(vec), index);
+ res += weight * vector_access (const_cast<const VectorType &>(vec), index);
}
void post_constraints (const Number &sum,
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType, typename VectorOperation>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
template<typename VectorType>
inline
void
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components, typename Number>
+ int n_components, typename Number>
inline
const VectorizedArray<Number> *
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components,Number>::
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components, typename Number>
+ int n_components, typename Number>
inline
VectorizedArray<Number> *
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components,Number>::
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components, typename Number>
+ int n_components, typename Number>
inline
const VectorizedArray<Number> *
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components,Number>::
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components, typename Number>
+ int n_components, typename Number>
inline
VectorizedArray<Number> *
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components,Number>::
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components, typename Number>
+ int n_components, typename Number>
inline
const VectorizedArray<Number> *
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components,Number>::
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components, typename Number>
+ int n_components, typename Number>
inline
VectorizedArray<Number> *
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components,Number>::
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components, typename Number>
+ int n_components, typename Number>
inline
const VectorizedArray<Number> *
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components,Number>::
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components, typename Number>
+ int n_components, typename Number>
inline
VectorizedArray<Number> *
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components,Number>::
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
Tensor<1,n_components_,VectorizedArray<Number> >
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
Tensor<1,n_components_,VectorizedArray<Number> >
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
Tensor<1,n_components_,Tensor<1,dim,VectorizedArray<Number> > >
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
Tensor<1,n_components_,Tensor<2,dim,VectorizedArray<Number> > >
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
Tensor<1,n_components_,Tensor<1,dim,VectorizedArray<Number> > >
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
Tensor<1,n_components_,VectorizedArray<Number> >
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
void
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
void
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
void
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
Tensor<1,n_components_,VectorizedArray<Number> >
FEEvaluationBase<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
template <int dim, int dofs_per_cell_, int n_q_points_,
- int n_components_, typename Number>
+ int n_components_, typename Number>
inline
FEEvaluationAccess<dim,dofs_per_cell_,n_q_points_,n_components_,Number>
::FEEvaluationAccess (const MatrixFree<dim,Number> &data_in,
}
template <int dim, int dofs_per_cell_, int n_q_points_,
- typename Number>
+ typename Number>
inline
void
FEEvaluationAccess<dim,dofs_per_cell_,n_q_points_,dim,Number>
/*----------------------- FEEvaluationGeneral -------------------------------*/
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
inline
FEEvaluationGeneral<dim,fe_degree,n_q_points_1d,n_components_,Number>
::FEEvaluationGeneral (const MatrixFree<dim,Number> &data_in,
{
proposed_quad_comp = no;
break;
- }
+ }
if (proposed_dof_comp != numbers::invalid_unsigned_int &&
proposed_quad_comp != numbers::invalid_unsigned_int)
{
// like the functions below and corresponds to a usual matrix-matrix
// product
template <int dim, int fe_degree, int n_q_points_1d, typename Number,
- int direction, bool dof_to_quad, bool add>
+ int direction, bool dof_to_quad, bool add>
inline
void
apply_tensor_product (const Number *shape_data,
// fe_degree+1 degrees of freedom per direction and not n_q_points_1d for
// those directions lower than the one currently applied
template <int dim, int fe_degree, typename Number, int face_direction,
- bool dof_to_quad, bool add>
+ bool dof_to_quad, bool add>
inline
void
apply_tensor_product_face (const Number *shape_data,
// ones and in addition use the symmetry in entries to reduce the number of
// read operations.
template <int dim, int fe_degree, int n_q_points_1d, typename Number,
- int direction, bool dof_to_quad, bool add>
+ int direction, bool dof_to_quad, bool add>
inline
void
apply_tensor_product_values (const Number *shape_values,
// zeros and ones and in addition use the symmetry in entries to
// reduce the number of read operations.
template <int dim, int fe_degree, int n_q_points_1d, typename Number,
- int direction, bool dof_to_quad, bool add>
+ int direction, bool dof_to_quad, bool add>
inline
void
apply_tensor_product_gradients (const Number *shape_gradients,
// form assuming the symmetries of unit cell shape hessians for
// finite elements in FEEvaluation
template <int dim, int fe_degree, int n_q_points_1d, typename Number,
- int direction, bool dof_to_quad, bool add>
+ int direction, bool dof_to_quad, bool add>
inline
void
apply_tensor_product_hessians (const Number *shape_hessians,
// [ 2.82 -1.528 2.673 0 -13.51 ]
// [-1 0.518 -0.75 2.482 10 ]
template <int dim, int fe_degree, typename Number,
- int direction, bool dof_to_quad, bool add>
+ int direction, bool dof_to_quad, bool add>
inline
void
apply_tensor_product_gradients_gl (const Number *shape_gradients,
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
inline
void
FEEvaluationGeneral<dim,fe_degree,n_q_points_1d,n_components_,Number>
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
inline
void
FEEvaluationGeneral<dim,fe_degree,n_q_points_1d,n_components_,Number>
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
inline
Point<dim,VectorizedArray<Number> >
FEEvaluationGeneral<dim,fe_degree,n_q_points_1d,n_components_,Number>
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
template <int direction, bool dof_to_quad, bool add>
inline
void
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
template <int direction, bool dof_to_quad, bool add>
inline
void
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
template <int direction, bool dof_to_quad, bool add>
inline
void
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
inline
FEEvaluation<dim,fe_degree,n_q_points_1d,n_components_,Number>
::FEEvaluation (const MatrixFree<dim,Number> &data_in,
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
inline
void
FEEvaluation<dim,fe_degree,n_q_points_1d,n_components_,Number>
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
inline
void
FEEvaluation<dim,fe_degree,n_q_points_1d,n_components_,Number>
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
template <int direction, bool dof_to_quad, bool add>
inline
void
// for all other orders, we choose even-odd
if (fe_degree > 1 || n_q_points_1d > 3)
internal::apply_tensor_product_evenodd<dim,fe_degree,n_q_points_1d,
- VectorizedArray<Number>, direction, dof_to_quad, add, 0>
- (shape_val_evenodd, in, out);
+ VectorizedArray<Number>, direction, dof_to_quad, add, 0>
+ (shape_val_evenodd, in, out);
else
internal::apply_tensor_product_values<dim,fe_degree,n_q_points_1d,
- VectorizedArray<Number>, direction, dof_to_quad, add>
- (this->data.shape_values.begin(), in, out);
+ VectorizedArray<Number>, direction, dof_to_quad, add>
+ (this->data.shape_values.begin(), in, out);
}
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
template <int direction, bool dof_to_quad, bool add>
inline
void
{
if (fe_degree > 1 || n_q_points_1d > 3)
internal::apply_tensor_product_evenodd<dim,fe_degree,n_q_points_1d,
- VectorizedArray<Number>, direction, dof_to_quad, add, 1>
- (shape_gra_evenodd, in, out);
+ VectorizedArray<Number>, direction, dof_to_quad, add, 1>
+ (shape_gra_evenodd, in, out);
else
internal::apply_tensor_product_gradients<dim,fe_degree,n_q_points_1d,
- VectorizedArray<Number>, direction, dof_to_quad, add>
- (this->data.shape_gradients.begin(), in, out);
+ VectorizedArray<Number>, direction, dof_to_quad, add>
+ (this->data.shape_gradients.begin(), in, out);
}
// the same symmetry relations hold. However, it is not possible to omit some
// values that are zero for the values
template <int dim, int fe_degree, int n_q_points_1d, int n_components_,
- typename Number>
+ typename Number>
template <int direction, bool dof_to_quad, bool add>
inline
void
{
if (fe_degree > 1 || n_q_points_1d > 3)
internal::apply_tensor_product_evenodd<dim,fe_degree,n_q_points_1d,
- VectorizedArray<Number>, direction, dof_to_quad, add, 2>
- (shape_hes_evenodd, in, out);
+ VectorizedArray<Number>, direction, dof_to_quad, add, 2>
+ (shape_hes_evenodd, in, out);
else
internal::apply_tensor_product_hessians<dim,fe_degree,n_q_points_1d,
- VectorizedArray<Number>, direction, dof_to_quad, add>
- (this->data.shape_hessians.begin(), in, out);
+ VectorizedArray<Number>, direction, dof_to_quad, add>
+ (this->data.shape_hessians.begin(), in, out);
}
for (types::global_dof_index i=start_index; i<end_index; ++i)
if (constraint[no]->is_constrained(i)==true)
dof_info[no].constrained_dofs.
- push_back(static_cast<unsigned int>(i-start_index));
+ push_back(static_cast<unsigned int>(i-start_index));
}
}
const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
const std_cxx1x::function<void (DOFINFO &, DOFINFO &,
typename INFOBOX::CellInfo &,
- typename INFOBOX::CellInfo &)>& face_worker,
+ typename INFOBOX::CellInfo &)> &face_worker,
const bool cells_first,
const bool unique_faces_only)
{
const std_cxx1x::function<void (DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker,
const std_cxx1x::function<void (DOFINFO &, DOFINFO &,
typename INFOBOX::CellInfo &,
- typename INFOBOX::CellInfo &)>& face_worker,
+ typename INFOBOX::CellInfo &)> &face_worker,
ASSEMBLER &assembler,
bool cells_first = true,
bool unique_faces_only = true)
for (unsigned int j=0; j<i1.size(); ++j)
for (unsigned int k=0; k<i2.size(); ++k)
if (std::fabs(M(k,j)) >= threshold)
- if (!mg_constrained_dofs->at_refinement_edge(level, i2[k]))
+ if (!mg_constrained_dofs->at_refinement_edge(level, i2[k]))
G.add(i1[j], i2[k], M(k,j));
}
}
AssertDimension(M.m(), i1.size());
AssertDimension(M.n(), i2.size());
Assert(mg_constrained_dofs != 0, ExcInternalError());
-
+
for (unsigned int j=0; j<i1.size(); ++j)
- for (unsigned int k=0; k<i2.size(); ++k)
- if (std::fabs(M(j,k)) >= threshold)
- // Enter values into matrix only if j corresponds to a
- // degree of freedom on the refinemenent edge, k does
- // not, and both are not on the boundary. This is part
- // the difference between the complete matrix with no
- // boundary condition at the refinement edge and and
- // the matrix assembled above by assemble().
-
- // Thus the logic is: enter the row if it is
- // constrained by hanging node constraints (actually,
- // the whole refinement edge), but not if it is
- // constrained by a boundary constraint.
- if (mg_constrained_dofs->at_refinement_edge(level, i1[j]) &&
- !mg_constrained_dofs->at_refinement_edge(level, i2[k]))
- {
- if (mg_constrained_dofs->set_boundary_values())
- {
- if ((!mg_constrained_dofs->at_refinement_edge_boundary(level, i1[j]) &&
- !mg_constrained_dofs->at_refinement_edge_boundary(level, i2[k]))
- ||
- (mg_constrained_dofs->at_refinement_edge_boundary(level, i1[j]) &&
- mg_constrained_dofs->at_refinement_edge_boundary(level, i2[k]) &&
- i1[j] == i2[k]))
- G.add(i1[j], i2[k], M(j,k));
- }
- else
- G.add(i1[j], i2[k], M(j,k));
- }
+ for (unsigned int k=0; k<i2.size(); ++k)
+ if (std::fabs(M(j,k)) >= threshold)
+ // Enter values into matrix only if j corresponds to a
+ // degree of freedom on the refinemenent edge, k does
+ // not, and both are not on the boundary. This is part
+ // the difference between the complete matrix with no
+ // boundary condition at the refinement edge and and
+ // the matrix assembled above by assemble().
+
+ // Thus the logic is: enter the row if it is
+ // constrained by hanging node constraints (actually,
+ // the whole refinement edge), but not if it is
+ // constrained by a boundary constraint.
+ if (mg_constrained_dofs->at_refinement_edge(level, i1[j]) &&
+ !mg_constrained_dofs->at_refinement_edge(level, i2[k]))
+ {
+ if (mg_constrained_dofs->set_boundary_values())
+ {
+ if ((!mg_constrained_dofs->at_refinement_edge_boundary(level, i1[j]) &&
+ !mg_constrained_dofs->at_refinement_edge_boundary(level, i2[k]))
+ ||
+ (mg_constrained_dofs->at_refinement_edge_boundary(level, i1[j]) &&
+ mg_constrained_dofs->at_refinement_edge_boundary(level, i2[k]) &&
+ i1[j] == i2[k]))
+ G.add(i1[j], i2[k], M(j,k));
+ }
+ else
+ G.add(i1[j], i2[k], M(j,k));
+ }
}
-
-
+
+
template <class MATRIX>
inline void
MGMatrixSimple<MATRIX>::assemble_out(
AssertDimension(M.n(), i1.size());
AssertDimension(M.m(), i2.size());
Assert(mg_constrained_dofs != 0, ExcInternalError());
-
+
for (unsigned int j=0; j<i1.size(); ++j)
- for (unsigned int k=0; k<i2.size(); ++k)
- if (std::fabs(M(k,j)) >= threshold)
- if (mg_constrained_dofs->at_refinement_edge(level, i1[j]) &&
- !mg_constrained_dofs->at_refinement_edge(level, i2[k]))
- {
- if (mg_constrained_dofs->set_boundary_values())
- {
- if ((!mg_constrained_dofs->at_refinement_edge_boundary(level, i1[j]) &&
- !mg_constrained_dofs->at_refinement_edge_boundary(level, i2[k]))
- ||
- (mg_constrained_dofs->at_refinement_edge_boundary(level, i1[j]) &&
- mg_constrained_dofs->at_refinement_edge_boundary(level, i2[k]) &&
- i1[j] == i2[k]))
- G.add(i1[j], i2[k], M(k,j));
- }
- else
- G.add(i1[j], i2[k], M(k,j));
- }
+ for (unsigned int k=0; k<i2.size(); ++k)
+ if (std::fabs(M(k,j)) >= threshold)
+ if (mg_constrained_dofs->at_refinement_edge(level, i1[j]) &&
+ !mg_constrained_dofs->at_refinement_edge(level, i2[k]))
+ {
+ if (mg_constrained_dofs->set_boundary_values())
+ {
+ if ((!mg_constrained_dofs->at_refinement_edge_boundary(level, i1[j]) &&
+ !mg_constrained_dofs->at_refinement_edge_boundary(level, i2[k]))
+ ||
+ (mg_constrained_dofs->at_refinement_edge_boundary(level, i1[j]) &&
+ mg_constrained_dofs->at_refinement_edge_boundary(level, i2[k]) &&
+ i1[j] == i2[k]))
+ G.add(i1[j], i2[k], M(k,j));
+ }
+ else
+ G.add(i1[j], i2[k], M(k,j));
+ }
}
-
+
template <class MATRIX>
template <class DOFINFO>
ResidualSimple<VECTOR>::initialize(c);
}
-
+
template <class MATRIX, class VECTOR>
template <class DOFINFO>
inline void
namespace mg
{
-/**
- * Handler and storage for all five SparseMatrix object involved in
- * using multigrid with local refinement.
- *
- * @author Baerbel Janssen, Guido Kanschat
- * @date 2013
- */
+ /**
+ * Handler and storage for all five SparseMatrix object involved in
+ * using multigrid with local refinement.
+ *
+ * @author Baerbel Janssen, Guido Kanschat
+ * @date 2013
+ */
template <typename number>
class SparseMatrixCollection : public Subscriptor
{
- public:
- void resize(const unsigned int minlevel, const unsigned int maxlevel);
-
- template <class DH>
- void reinit(const DH& dof_handler);
-
- void set_zero();
-
- MGLevelObject<SparsityPattern> sparsity;
- MGLevelObject<SparsityPattern> sparsity_edge;
-
- MGLevelObject<SparseMatrix<number> > matrix;
- MGLevelObject<SparseMatrix<number> > matrix_down;
- MGLevelObject<SparseMatrix<number> > matrix_up;
- MGLevelObject<SparseMatrix<number> > matrix_in;
- MGLevelObject<SparseMatrix<number> > matrix_out;
+ public:
+ void resize(const unsigned int minlevel, const unsigned int maxlevel);
+
+ template <class DH>
+ void reinit(const DH &dof_handler);
+
+ void set_zero();
+
+ MGLevelObject<SparsityPattern> sparsity;
+ MGLevelObject<SparsityPattern> sparsity_edge;
+
+ MGLevelObject<SparseMatrix<number> > matrix;
+ MGLevelObject<SparseMatrix<number> > matrix_down;
+ MGLevelObject<SparseMatrix<number> > matrix_up;
+ MGLevelObject<SparseMatrix<number> > matrix_in;
+ MGLevelObject<SparseMatrix<number> > matrix_out;
};
template <typename number>
template <class DH>
void
- SparseMatrixCollection<number>::reinit(const DH& dof_handler)
+ SparseMatrixCollection<number>::reinit(const DH &dof_handler)
{
AssertIndexRange(sparsity.max_level(), dof_handler.get_tria().n_levels());
-
+
for (unsigned int level=sparsity.min_level();
- level<=sparsity.max_level();++level)
+ level<=sparsity.max_level(); ++level)
{
- CompressedSparsityPattern c_sparsity(dof_handler.n_dofs(level));
- MGTools::make_flux_sparsity_pattern(dof_handler, c_sparsity, level);
- sparsity[level].copy_from(c_sparsity);
- matrix[level].reinit(sparsity[level]);
- matrix_in[level].reinit(sparsity[level]);
- matrix_out[level].reinit(sparsity[level]);
- if (level>0)
- {
- CompressedSparsityPattern ci_sparsity;
- ci_sparsity.reinit(dof_handler.n_dofs(level-1), dof_handler.n_dofs(level));
- MGTools::make_flux_sparsity_pattern_edge(dof_handler, ci_sparsity, level);
- sparsity_edge[level].copy_from(ci_sparsity);
- matrix_up[level].reinit(sparsity_edge[level]);
- matrix_down[level].reinit(sparsity_edge[level]);
- }
+ CompressedSparsityPattern c_sparsity(dof_handler.n_dofs(level));
+ MGTools::make_flux_sparsity_pattern(dof_handler, c_sparsity, level);
+ sparsity[level].copy_from(c_sparsity);
+ matrix[level].reinit(sparsity[level]);
+ matrix_in[level].reinit(sparsity[level]);
+ matrix_out[level].reinit(sparsity[level]);
+ if (level>0)
+ {
+ CompressedSparsityPattern ci_sparsity;
+ ci_sparsity.reinit(dof_handler.n_dofs(level-1), dof_handler.n_dofs(level));
+ MGTools::make_flux_sparsity_pattern_edge(dof_handler, ci_sparsity, level);
+ sparsity_edge[level].copy_from(ci_sparsity);
+ matrix_up[level].reinit(sparsity_edge[level]);
+ matrix_down[level].reinit(sparsity_edge[level]);
+ }
}
}
matrix_up = 0.;
matrix_down = 0.;
}
-
+
}
DEAL_II_NAMESPACE_CLOSE
* we are to work on.
*/
template <class DerivativeDescription, int dim,
- template <int, int> class DH, class InputVector, int spacedim>
+ template <int, int> class DH, class InputVector, int spacedim>
static void
approximate_derivative (const Mapping<dim,spacedim> &mapping,
const DH<dim,spacedim> &dof,
* on the cell.
*/
template <class DerivativeDescription, int dim,
- template <int, int> class DH, class InputVector, int spacedim>
+ template <int, int> class DH, class InputVector, int spacedim>
static void
approximate (SynchronousIterators<std_cxx1x::tuple<FilteredIterator<typename DH<dim,spacedim>::active_cell_iterator>,
- Vector<float>::iterator> > const &cell,
+ Vector<float>::iterator> > const &cell,
const Mapping<dim,spacedim> &mapping,
const DH<dim,spacedim> &dof,
const InputVector &solution,
* derivative tensor.
*/
template <class DerivativeDescription, int dim,
- template <int, int> class DH, class InputVector, int spacedim>
+ template <int, int> class DH, class InputVector, int spacedim>
static void
approximate_cell (const Mapping<dim,spacedim> &mapping,
const DH<dim,spacedim> &dof,
* @author Luca Heltai, 2006, Markus Buerg, 2012, Wolfgang Bangerth, 2013
*/
template <int dim,
- typename DH=DoFHandler<dim>,
- typename VECTOR=Vector<double> >
+ typename DH=DoFHandler<dim>,
+ typename VECTOR=Vector<double> >
class FEFieldFunction : public Function<dim>
{
public:
* constraints object.
*/
template <int dim, int spacedim,
- template <int,int> class DH,
- class VECTOR>
+ template <int,int> class DH,
+ class VECTOR>
void
interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
const VECTOR &u1,
* at hanging nodes.
*/
template <int dim, int spacedim,
- template <int,int> class DH,
- class VECTOR>
+ template <int,int> class DH,
+ class VECTOR>
void
interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
const VECTOR &u1,
* destination DoFHandler.
*/
template <int dim, int spacedim,
- template <int,int> class DH,
- class VECTOR>
+ template <int,int> class DH,
+ class VECTOR>
void
interpolate_to_different_mesh (const InterGridMap<DH<dim, spacedim> > &intergridmap,
const VECTOR &u1,
VECTOR &vec,
const bool enforce_zero_boundary = false,
const hp::QCollection<dim-1> &q_boundary = hp::QCollection<dim-1>(dim > 1 ?
- QGauss<dim-1>(2) :
- Quadrature<dim-1>(0)),
+ QGauss<dim-1>(2) :
+ Quadrature<dim-1>(0)),
const bool project_to_boundary_first = false);
/**
VECTOR &vec,
const bool enforce_zero_boundary = false,
const hp::QCollection<dim-1> &q_boundary = hp::QCollection<dim-1>(dim > 1 ?
- QGauss<dim-1>(2) :
- Quadrature<dim-1>(0)),
+ QGauss<dim-1>(2) :
+ Quadrature<dim-1>(0)),
const bool project_to_boundary_first = false);
/**
const bool fe_is_system = (n_components != 1);
typename DH<dim,spacedim>::active_cell_iterator cell = dof.begin_active(),
- endc = dof.end();
+ endc = dof.end();
// For FESystems many of the
// unit_support_points will appear
hp::MappingCollection<dim,spacedim> mapping_collection (mapping);
hp::FEValues<dim,spacedim> fe_values (mapping_collection,
- fe, support_quadrature, update_quadrature_points);
+ fe, support_quadrature, update_quadrature_points);
for (; cell!=endc; ++cell)
if (cell->is_locally_owned())
template <int dim, int spacedim,
- template <int,int> class DH,
- class Vector>
+ template <int,int> class DH,
+ class Vector>
void
interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
const Vector &u1,
template <int dim, int spacedim,
- template <int,int> class DH,
- class Vector>
+ template <int,int> class DH,
+ class Vector>
void
interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
const Vector &u1,
template <int dim, int spacedim,
- template <int,int> class DH,
- class Vector>
+ template <int,int> class DH,
+ class Vector>
void
interpolate_to_different_mesh (const InterGridMap<DH<dim, spacedim> > &intergridmap,
const Vector &u1,
template <int,int> class M_or_MC,
template <int> class Q_or_QC>
void project_compute_b_v (const M_or_MC<dim, spacedim> &mapping,
- const DH<dim,spacedim> &dof,
- const Function<spacedim> &function,
- const bool enforce_zero_boundary,
- const Q_or_QC<dim-1> &q_boundary,
- const bool project_to_boundary_first,
- std::map<types::global_dof_index,double> &boundary_values)
+ const DH<dim,spacedim> &dof,
+ const Function<spacedim> &function,
+ const bool enforce_zero_boundary,
+ const Q_or_QC<dim-1> &q_boundary,
+ const bool project_to_boundary_first,
+ std::map<types::global_dof_index,double> &boundary_values)
{
if (enforce_zero_boundary == true)
// no need to project boundary
template <int,int> class M_or_MC,
template <int> class Q_or_QC>
void do_project (const M_or_MC<dim, spacedim> &mapping,
- const DH<dim,spacedim> &dof,
- const ConstraintMatrix &constraints,
- const Q_or_QC<dim> &quadrature,
- const Function<spacedim> &function,
- Vector &vec_result,
- const bool enforce_zero_boundary,
- const Q_or_QC<dim-1> &q_boundary,
- const bool project_to_boundary_first)
+ const DH<dim,spacedim> &dof,
+ const ConstraintMatrix &constraints,
+ const Q_or_QC<dim> &quadrature,
+ const Function<spacedim> &function,
+ Vector &vec_result,
+ const bool enforce_zero_boundary,
+ const Q_or_QC<dim-1> &q_boundary,
+ const bool project_to_boundary_first)
{
Assert (dof.get_fe().n_components() == function.n_components,
ExcDimensionMismatch(dof.get_fe().n_components(),
const bool project_to_boundary_first)
{
do_project (mapping, dof, constraints, quadrature,
- function, vec_result,
- enforce_zero_boundary, q_boundary,
- project_to_boundary_first);
+ function, vec_result,
+ enforce_zero_boundary, q_boundary,
+ project_to_boundary_first);
}
const bool project_to_boundary_first)
{
do_project (mapping, dof, constraints, quadrature,
- function, vec_result,
- enforce_zero_boundary, q_boundary,
- project_to_boundary_first);
+ function, vec_result,
+ enforce_zero_boundary, q_boundary,
+ project_to_boundary_first);
}
template <int,int> class M_or_MC>
static inline
void do_interpolate_boundary_values (const M_or_MC<DH::dimension, DH::space_dimension> &,
- const DH &dof,
- const typename FunctionMap<DH::space_dimension>::type &function_map,
- std::map<types::global_dof_index,double> &boundary_values,
- const ComponentMask &component_mask,
- const dealii::internal::int2type<1>)
+ const DH &dof,
+ const typename FunctionMap<DH::space_dimension>::type &function_map,
+ std::map<types::global_dof_index,double> &boundary_values,
+ const ComponentMask &component_mask,
+ const dealii::internal::int2type<1>)
{
const unsigned int dim = DH::dimension;
const unsigned int spacedim=DH::space_dimension;
static inline
void
do_interpolate_boundary_values (const M_or_MC<DH::dimension, DH::space_dimension> &mapping,
- const DH &dof,
- const typename FunctionMap<DH::space_dimension>::type &function_map,
- std::map<types::global_dof_index,double> &boundary_values,
- const ComponentMask &component_mask,
- const dealii::internal::int2type<DH::dimension>)
+ const DH &dof,
+ const typename FunctionMap<DH::space_dimension>::type &function_map,
+ std::map<types::global_dof_index,double> &boundary_values,
+ const ComponentMask &component_mask,
+ const dealii::internal::int2type<DH::dimension>)
{
const unsigned int dim = DH::dimension;
const unsigned int spacedim=DH::space_dimension;
:
(dim == 2 ?
(i<2*fe.dofs_per_vertex ? i : i+2*fe.dofs_per_vertex)
+ :
+ (dim == 3 ?
+ (i<4*fe.dofs_per_vertex ?
+ i
:
- (dim == 3 ?
- (i<4*fe.dofs_per_vertex ?
- i
- :
- (i<4*fe.dofs_per_vertex+4*fe.dofs_per_line ?
- i+4*fe.dofs_per_vertex
- :
- i+4*fe.dofs_per_vertex+8*fe.dofs_per_line))
+ (i<4*fe.dofs_per_vertex+4*fe.dofs_per_line ?
+ i+4*fe.dofs_per_vertex
:
- numbers::invalid_unsigned_int)));
+ i+4*fe.dofs_per_vertex+8*fe.dofs_per_line))
+ :
+ numbers::invalid_unsigned_int)));
Assert (cell_i < fe.dofs_per_cell, ExcInternalError());
// make sure that if this is not a primitive
}
else
// fe has only one component, so save some computations
- {
+ {
// get only the one component that this function has
dof_values_scalar.resize (fe.dofs_per_face);
function_map.find(boundary_component)->second
const ComponentMask &component_mask_)
{
do_interpolate_boundary_values (mapping, dof, function_map, boundary_values,
- component_mask_,
- dealii::internal::int2type<DH::dimension>());
+ component_mask_,
+ dealii::internal::int2type<DH::dimension>());
}
const ComponentMask &component_mask_)
{
do_interpolate_boundary_values (mapping, dof, function_map, boundary_values,
- component_mask_,
- dealii::internal::int2type<dim>());
+ component_mask_,
+ dealii::internal::int2type<dim>());
}
template <int> class Q_or_QC>
void
do_project_boundary_values (const M_or_MC<dim, spacedim> &mapping,
- const DH<dim, spacedim> &dof,
- const typename FunctionMap<spacedim>::type &boundary_functions,
- const Q_or_QC<dim-1> &q,
- std::map<types::global_dof_index,double> &boundary_values,
- std::vector<unsigned int> component_mapping)
+ const DH<dim, spacedim> &dof,
+ const typename FunctionMap<spacedim>::type &boundary_functions,
+ const Q_or_QC<dim-1> &q,
+ std::map<types::global_dof_index,double> &boundary_values,
+ std::vector<unsigned int> component_mapping)
{
// in 1d, projection onto the 0d end points == interpolation
if (dim == 1)
return;
}
- //TODO:[?] In project_boundary_values, no condensation of sparsity
- // structures, matrices and right hand sides or distribution of
- // solution vectors is performed. This is ok for dim<3 because then
- // there are no constrained nodes on the boundary, but is not
- // acceptable for higher dimensions. Fix this.
+ //TODO:[?] In project_boundary_values, no condensation of sparsity
+ // structures, matrices and right hand sides or distribution of
+ // solution vectors is performed. This is ok for dim<3 because then
+ // there are no constrained nodes on the boundary, but is not
+ // acceptable for higher dimensions. Fix this.
if (component_mapping.size() == 0)
{
// but it needs to be implemented
if (dim>=3)
{
- #ifdef DEBUG
- // Assert that there are no hanging nodes at the boundary
+#ifdef DEBUG
+ // Assert that there are no hanging nodes at the boundary
int level = -1;
for (typename DH<dim,spacedim>::active_cell_iterator cell = dof.begin_active();
cell != dof.end(); ++cell)
}
}
}
- #endif
+#endif
}
sparsity.compress();
std::vector<unsigned int> component_mapping)
{
do_project_boundary_values (mapping, dof,
- boundary_functions,
- q, boundary_values,
- component_mapping);
+ boundary_functions,
+ q, boundary_values,
+ component_mapping);
}
std::vector<unsigned int> component_mapping)
{
project_boundary_values (hp::StaticMappingQ1<dim,spacedim>::mapping_collection, dof,
- boundary_function,
- q, boundary_values,
- component_mapping);
+ boundary_function,
+ q, boundary_values,
+ component_mapping);
}
template <int dim>
- std::ostream & operator << (std::ostream &out,
- const VectorDoFTuple<dim> &vdt)
+ std::ostream &operator << (std::ostream &out,
+ const VectorDoFTuple<dim> &vdt)
{
for (unsigned int d=0; d<dim; ++d)
- out << vdt.dof_indices[d] << (d < dim-1 ? " " : "");
+ out << vdt.dof_indices[d] << (d < dim-1 ? " " : "");
return out;
}
-= tol;
tangentials[q_point]
= (fe_values.get_mapping ()
- .transform_unit_to_real_cell (cell,
- shifted_reference_point_1)
- -
- fe_values.get_mapping ()
- .transform_unit_to_real_cell (cell,
- shifted_reference_point_2))
+ .transform_unit_to_real_cell (cell,
+ shifted_reference_point_1)
+ -
+ fe_values.get_mapping ()
+ .transform_unit_to_real_cell (cell,
+ shifted_reference_point_2))
/ tol;
tangentials[q_point]
/= std::sqrt (tangentials[q_point].square ());
fe_collection,
face_quadrature_collection,
update_q_points |
- update_normal_vectors);
+ update_normal_vectors);
// have a map that stores normal vectors for each vector-dof tuple we want
// to constrain. since we can get at the same vector dof tuple more than
vector_dofs.dof_indices[0] = face_dofs[i];
Assert(first_vector_component+dim<=fe.n_components(),
- ExcMessage("Error: the finite element does not have enough components "
- "to define a normal direction."));
+ ExcMessage("Error: the finite element does not have enough components "
+ "to define a normal direction."));
for (unsigned int k=0; k<fe.dofs_per_face; ++k)
if ((k != i)
// to check that they are small *relative to something
// else*). we do this and then normalize the length of the
// vector back to one, just to be on the safe side
- //
- // one more point: we would like to use the "real" normal
- // vector here, as provided by the boundary description
- // and as opposed to what we get from the FEValues object.
- // we do this in the immediately next line, but as is
- // obvious, the boundary only has a vague idea which side
- // of a cell it is on -- indicated by the face number. in
- // other words, it may provide the inner or outer normal.
- // by and large, there is no harm from this, since the
- // tangential vector we compute is still the same. however,
- // we do average over normal vectors from adjacent cells
- // and if they have recorded normal vectors from the inside
- // once and from the outside the other time, then this
- // averaging is going to run into trouble. as a consequence
- // we ask the mapping after all for its normal vector,
- // but we only ask it so that we can possibly correct the
- // sign of the normal vector provided by the boundary
- // if they should point in different directions. this is the
- // case in tests/deal.II/no_flux_11.
+ //
+ // one more point: we would like to use the "real" normal
+ // vector here, as provided by the boundary description
+ // and as opposed to what we get from the FEValues object.
+ // we do this in the immediately next line, but as is
+ // obvious, the boundary only has a vague idea which side
+ // of a cell it is on -- indicated by the face number. in
+ // other words, it may provide the inner or outer normal.
+ // by and large, there is no harm from this, since the
+ // tangential vector we compute is still the same. however,
+ // we do average over normal vectors from adjacent cells
+ // and if they have recorded normal vectors from the inside
+ // once and from the outside the other time, then this
+ // averaging is going to run into trouble. as a consequence
+ // we ask the mapping after all for its normal vector,
+ // but we only ask it so that we can possibly correct the
+ // sign of the normal vector provided by the boundary
+ // if they should point in different directions. this is the
+ // case in tests/deal.II/no_flux_11.
Point<dim> normal_vector
= (cell->face(face_no)->get_boundary()
.normal_vector (fe_values.quadrature_point(i)));
- if (normal_vector * fe_values.normal_vector(i) < 0)
- normal_vector *= -1;
+ if (normal_vector * fe_values.normal_vector(i) < 0)
+ normal_vector *= -1;
Assert (std::fabs(normal_vector.norm() - 1) < 1e-14,
ExcInternalError());
for (unsigned int d=0; d<dim; ++d)
std::make_pair (normal_vector,
cell)));
#ifdef DEBUG_NO_NORMAL_FLUX
- std::cout << "Adding normal vector:" << std::endl
- << " dofs=" << vector_dofs << std::endl
- << " cell=" << cell << " at " << cell->center() << std::endl
- << " normal=" << normal_vector << std::endl;
+ std::cout << "Adding normal vector:" << std::endl
+ << " dofs=" << vector_dofs << std::endl
+ << " cell=" << cell << " at " << cell->center() << std::endl
+ << " normal=" << normal_vector << std::endl;
#endif
}
}
same_dof_range[1] = dof_to_normals_map.end();
#ifdef DEBUG_NO_NORMAL_FLUX
- std::cout << "For dof indices <" << p->first << ">, found the following normals"
- << std::endl;
+ std::cout << "For dof indices <" << p->first << ">, found the following normals"
+ << std::endl;
for (typename DoFToNormalsMap::const_iterator
q = same_dof_range[0];
q != same_dof_range[1]; ++q)
- std::cout << " " << q->second.first
- << " from cell " << q->second.second
- << std::endl;
+ std::cout << " " << q->second.first
+ << " from cell " << q->second.second
+ << std::endl;
#endif
Assert (cell_to_normals_map.size() >= 1, ExcInternalError());
#ifdef DEBUG_NO_NORMAL_FLUX
- std::cout << " cell_to_normals_map:" << std::endl;
+ std::cout << " cell_to_normals_map:" << std::endl;
for (typename CellToNormalsMap::const_iterator
x = cell_to_normals_map.begin();
x != cell_to_normals_map.end(); ++x)
- std::cout << " " << x->first << " -> ("
- << x->second.first << ',' << x->second.second << ')'
- << std::endl;
+ std::cout << " " << x->first << " -> ("
+ << x->second.first << ',' << x->second.second << ')'
+ << std::endl;
#endif
// count the maximum number of contributions from each cell
switch (max_n_contributions_per_cell)
{
- // first deal with the case that a number of cells all have
- // registered that they have a normal vector defined at the
- // location of a given vector dof, and that each of them have
- // encountered this vector dof exactly once while looping over all
- // their faces. as stated in the documentation, this is the case
- // where we want to simply average over all normal vectors
- //
- // the typical case is in 2d where multiple cells meet at one
- // vertex sitting on the boundary. same in 3d for a vertex that
- // is associated with only one of the boundary indicators passed
- // to this function
+ // first deal with the case that a number of cells all have
+ // registered that they have a normal vector defined at the
+ // location of a given vector dof, and that each of them have
+ // encountered this vector dof exactly once while looping over all
+ // their faces. as stated in the documentation, this is the case
+ // where we want to simply average over all normal vectors
+ //
+ // the typical case is in 2d where multiple cells meet at one
+ // vertex sitting on the boundary. same in 3d for a vertex that
+ // is associated with only one of the boundary indicators passed
+ // to this function
case 1:
{
// if this is dim-1 for all cells (if a single cell has
// contributed dim, or if all adjacent cells have contributed 1
// normal vector, this is already handled above).
- //
- // we only implement the case that all cells contribute
- // dim-1 because we assume that we are following an edge
- // of the domain (think: we are looking at a vertex
- // located on one of the edges of a refined cube where the
- // boundary indicators of the two adjacent faces of the
- // cube are both listed in the set of boundary indicators
- // passed to this function). in that case, all cells along
- // that edge of the domain are assumed to have contributed
- // dim-1 normal vectors. however, there are cases where
- // this assumption is not justified (see the lengthy
- // explanation in test no_flux_12.cc) and in those cases
- // we simply ignore the cell that contributes only
- // once. this is also discussed at length in the
- // documentation of this function.
+ //
+ // we only implement the case that all cells contribute
+ // dim-1 because we assume that we are following an edge
+ // of the domain (think: we are looking at a vertex
+ // located on one of the edges of a refined cube where the
+ // boundary indicators of the two adjacent faces of the
+ // cube are both listed in the set of boundary indicators
+ // passed to this function). in that case, all cells along
+ // that edge of the domain are assumed to have contributed
+ // dim-1 normal vectors. however, there are cases where
+ // this assumption is not justified (see the lengthy
+ // explanation in test no_flux_12.cc) and in those cases
+ // we simply ignore the cell that contributes only
+ // once. this is also discussed at length in the
+ // documentation of this function.
//
// for each contributing cell compute the tangential vector that
// remains unconstrained
++contribution)
{
#ifdef DEBUG_NO_NORMAL_FLUX
- std::cout << " Treating edge case with dim-1 contributions." << std::endl
- << " Looking at cell " << contribution->first
- << " which has contributed these normal vectors:"
- << std::endl;
- for (typename std::list<Tensor<1,dim> >::const_iterator
- t = contribution->second.begin();
- t != contribution->second.end();
- ++t)
- std::cout << " " << *t << std::endl;
+ std::cout << " Treating edge case with dim-1 contributions." << std::endl
+ << " Looking at cell " << contribution->first
+ << " which has contributed these normal vectors:"
+ << std::endl;
+ for (typename std::list<Tensor<1,dim> >::const_iterator
+ t = contribution->second.begin();
+ t != contribution->second.end();
+ ++t)
+ std::cout << " " << *t << std::endl;
#endif
- // as mentioned above, simply ignore cells that only
- // contribute once
+ // as mentioned above, simply ignore cells that only
+ // contribute once
if (contribution->second.size() < dim-1)
- continue;
+ continue;
Tensor<1,dim> normals[dim-1];
{
template <int dim, template <int, int> class DH, int spacedim>
void
- compute_normal_flux_constraints (const DH<dim,spacedim>&dof_handler,
+ compute_normal_flux_constraints (const DH<dim,spacedim> &dof_handler,
const unsigned int first_vector_component,
const std::set<types::boundary_id> &boundary_ids,
ConstraintMatrix &constraints,
std::max(n_scalar_indices,
fe.face_system_to_component_index(i).second+1);
cell_vector_dofs[fe.face_system_to_component_index(i).second]
- [fe.face_system_to_component_index(i).first-first_vector_component]
+ [fe.face_system_to_component_index(i).first-first_vector_component]
= face_dofs[i];
}
// can find constrained ones
unsigned int n_total_constraints_found = 0;
for (typename std::set<std_cxx1x::array<types::global_dof_index,dim>,
- PointComparator<dim> >::const_iterator it=vector_dofs.begin();
- it!=vector_dofs.end(); ++it)
+ PointComparator<dim> >::const_iterator it=vector_dofs.begin();
+ it!=vector_dofs.end(); ++it)
{
unsigned int n_constraints = 0;
bool is_constrained[dim];
normal[d] = 1.;
}
AssertIndexRange(constrained_index, dim);
- const std::vector<std::pair<types::global_dof_index, double> >* constrained
+ const std::vector<std::pair<types::global_dof_index, double> > *constrained
= no_normal_flux_constraints.get_constraint_entries((*it)[constrained_index]);
// find components to which this index is constrained to
Assert(constrained != 0, ExcInternalError());
double sum = 0;
for (unsigned int k=0; k<n_components; ++k)
sum += data.psi_values[q](k) * data.psi_values[q](k) *
- data.weight_vectors[q](k);
+ data.weight_vectors[q](k);
diff += sum * fe_values.JxW(q);
}
// Compute the root only, if no derivative values are added later
double sum = 0;
for (unsigned int k=0; k<n_components; ++k)
sum += (data.psi_grads[q][k] * data.psi_grads[q][k]) *
- data.weight_vectors[q](k);
+ data.weight_vectors[q](k);
diff += sum * fe_values.JxW(q);
}
diff = std::sqrt(diff);
case W1infty_seminorm:
case W1infty_norm:
- {
- double t = 0;
- for (unsigned int q=0; q<n_q_points; ++q)
- for (unsigned int k=0; k<n_components; ++k)
- for (unsigned int d=0; d<dim; ++d)
- t = std::max(t, std::abs(data.psi_grads[q][k][d]) *
- data.weight_vectors[q](k));
+ {
+ double t = 0;
+ for (unsigned int q=0; q<n_q_points; ++q)
+ for (unsigned int k=0; k<n_components; ++k)
+ for (unsigned int d=0; d<dim; ++d)
+ t = std::max(t, std::abs(data.psi_grads[q][k][d]) *
+ data.weight_vectors[q](k));
- // then add seminorm to norm if that had previously been computed
- diff += t;
- }
- break;
+ // then add seminorm to norm if that had previously been computed
+ diff += t;
+ }
+ break;
default:
break;
}
case W1infty_seminorm:
update_flags |= UpdateFlags (update_gradients);
if (spacedim == dim+1)
- update_flags |= UpdateFlags (update_normal_vectors);
+ update_flags |= UpdateFlags (update_normal_vectors);
break;
case W1infty_norm:
update_flags |= UpdateFlags (update_gradients);
if (spacedim == dim+1)
- update_flags |= UpdateFlags (update_normal_vectors);
- // no break!
+ update_flags |= UpdateFlags (update_normal_vectors);
+ // no break!
default:
update_flags |= UpdateFlags (update_values);
Point<dim> q1, q2, q3, q4;
Vector<double>
v1(this->n_components), v2(this->n_components),
- v3(this->n_components), v4(this->n_components);
+ v3(this->n_components), v4(this->n_components);
const double h_inv_12=1./(12*h);
for (unsigned int i=0; i<dim; ++i)
{
template <>
void DataOutBase::write_svg<1,1> (const std::vector<Patch<1,1> > &patches,
- const std::vector<std::string> &data_names,
- const std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
- const SvgFlags &flags,
- std::ostream &out)
+ const std::vector<std::string> &data_names,
+ const std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> > &vector_data_ranges,
+ const SvgFlags &flags,
+ std::ostream &out)
{
AssertThrow (false, ExcNotImplemented());
}
MPI_Info_create(&info);
MPI_File fh;
err = MPI_File_open(comm, const_cast<char *>(filename),
- MPI_MODE_CREATE | MPI_MODE_WRONLY, info, &fh);
+ MPI_MODE_CREATE | MPI_MODE_WRONLY, info, &fh);
AssertThrow(err==0, ExcMessage("Unable to open file with MPI_File_open!"));
#endif
}
-const char* ExceptionBase::what() const throw()
+const char *ExceptionBase::what() const throw()
{
// If no error c_string was generated so far, do it now:
if (what_str == "")
namespace fparser
{
class FunctionParser: public ::FunctionParser
-{};
+ {};
}
#else
namespace fparser
{
class FunctionParser
-{};
+ {};
}
#endif
GeometryInfo<dim>::
alternating_form_at_vertices
#ifndef DEAL_II_CONSTEXPR_BUG
- (const Point<spacedim> (&vertices)[vertices_per_cell],
- Tensor<spacedim-dim,spacedim> (&forms)[vertices_per_cell])
+(const Point<spacedim> (&vertices)[vertices_per_cell],
+ Tensor<spacedim-dim,spacedim> (&forms)[vertices_per_cell])
#else
- (const Point<spacedim> *vertices,
- Tensor<spacedim-dim,spacedim> *forms)
+(const Point<spacedim> *vertices,
+ Tensor<spacedim-dim,spacedim> *forms)
#endif
{
// for each of the vertices,
{
// Implement a minimalistic stream buffer that only stores the fact
// whether overflow or sync was called
- public:
- QueryStreambuf()
- : flushed_(false), newline_written_(false)
- {
- }
- bool flushed() { return flushed_; }
- bool newline_written() { return newline_written_; }
- private:
- int_type overflow(int_type ch)
- {
- newline_written_ = true;
- return ch;
- }
- int sync()
- {
- flushed_ = true;
- return 0;
- }
- bool flushed_;
- bool newline_written_;
+ public:
+ QueryStreambuf()
+ : flushed_(false), newline_written_(false)
+ {
+ }
+ bool flushed()
+ {
+ return flushed_;
+ }
+ bool newline_written()
+ {
+ return newline_written_;
+ }
+ private:
+ int_type overflow(int_type ch)
+ {
+ newline_written_ = true;
+ return ch;
+ }
+ int sync()
+ {
+ flushed_ = true;
+ return 0;
+ }
+ bool flushed_;
+ bool newline_written_;
} query_streambuf;
{
void max_reduce ( const void *in_lhs_,
void *inout_rhs_,
int *len,
- MPI_Datatype * )
+ MPI_Datatype *)
{
const MinMaxAvg *in_lhs = static_cast<const MinMaxAvg *>(in_lhs_);
MinMaxAvg *inout_rhs = static_cast<MinMaxAvg *>(inout_rhs_);
// when running PETSc, because we initialize MPI ourselves before calling
// PetscInitialize
#ifdef DEAL_II_WITH_MPI
- int mpi_err = 0;
+ int mpi_err = 0;
int MPI_has_been_started = 0;
MPI_Initialized(&MPI_has_been_started);
void MultithreadInfo::set_thread_limit(const unsigned int max_threads)
{
Assert(n_max_threads==numbers::invalid_unsigned_int,
- ExcMessage("Calling set_thread_limit() more than once is not supported!"));
+ ExcMessage("Calling set_thread_limit() more than once is not supported!"));
unsigned int max_threads_env = numbers::invalid_unsigned_int;
char *penv;
// the whole filename specified, including (possibly)
// the suffix
{
- real_name = *path + filename;
- if (debug > 1)
- deallog << "PathSearch[" << cls << "] trying "
- << real_name << std::endl;
- FILE *fp = fopen(real_name.c_str(), open_mode);
- if (fp != 0)
- {
- if (debug > 0)
- deallog << "PathSearch[" << cls << "] opened "
- << real_name << std::endl;
- fclose(fp);
- return real_name;
- }
+ real_name = *path + filename;
+ if (debug > 1)
+ deallog << "PathSearch[" << cls << "] trying "
+ << real_name << std::endl;
+ FILE *fp = fopen(real_name.c_str(), open_mode);
+ if (fp != 0)
+ {
+ if (debug > 0)
+ deallog << "PathSearch[" << cls << "] opened "
+ << real_name << std::endl;
+ fclose(fp);
+ return real_name;
+ }
}
// try again with the suffix appended, unless there is
real_name = *path + filename + suffix;
if (debug > 1)
deallog << "PathSearch[" << cls << "] trying "
- << real_name << std::endl;
+ << real_name << std::endl;
FILE *fp = fopen(real_name.c_str(), open_mode);
if (fp != 0)
{
if (debug > 0)
deallog << "PathSearch[" << cls << "] opened "
- << real_name << std::endl;
+ << real_name << std::endl;
fclose(fp);
return real_name;
}
}
break;
- // manually implement size 1 (values only), size 2 (value + first
- // derivative), and size 3 (up to second derivative) since they
- // might be called often. then, we can unroll the loop.
+ // manually implement size 1 (values only), size 2 (value + first
+ // derivative), and size 3 (up to second derivative) since they
+ // might be called often. then, we can unroll the loop.
case 1:
values[0] = 1;
for (unsigned int i=0; i<n_supp; ++i)
template <int dim>
Quadrature<dim>::Quadrature (const Quadrature<dim != 1 ? 1 : 0> &q)
- :
- Subscriptor(),
- quadrature_points (Utilities::fixed_power<dim>(q.size())),
- weights (Utilities::fixed_power<dim>(q.size()))
+:
+Subscriptor(),
+ quadrature_points (Utilities::fixed_power<dim>(q.size())),
+ weights (Utilities::fixed_power<dim>(q.size()))
{
Assert (dim <= 3, ExcNotImplemented());
out << std::flush;
return;
}
-
+
case simple_table_with_separate_column_description:
{
// write the captions
out << std::flush;
return;
}
-
+
case table_with_separate_column_description:
{
// writing the captions for table_with_separate_column_description
}
break;
}
-
+
case table_with_headers:
{
// This format output supercolumn headers and aligns them centered
out << '\n';
break;
}
-
+
default:
Assert (false, ExcInternalError());
}
-
+
// finally output the data itself for
// table_with_headers or table_with_separate_column_description:
for (unsigned int i=0; i<nrows; ++i)
int face_left,
int face_right,
int orientation)
- = p4est_connectivity_join_faces;
+ = p4est_connectivity_join_faces;
#endif
void (&functions<2>::connectivity_destroy) (p4est_connectivity_t *connectivity)
= p4est_connectivity_save;
int (&functions<2>::connectivity_is_valid) (types<2>::connectivity
- *connectivity)
+ *connectivity)
= p4est_connectivity_is_valid;
types<2>::connectivity *
= p8est_connectivity_save;
int (&functions<3>::connectivity_is_valid) (types<3>::connectivity
- *connectivity)
+ *connectivity)
= p8est_connectivity_is_valid;
types<3>::connectivity *
std::vector<unsigned int> &vertex_touch_count,
std::vector<std::list<
std::pair<typename Triangulation<dim,spacedim>::active_cell_iterator,unsigned int> > >
- & vertex_to_cell)
+ &vertex_to_cell)
{
vertex_touch_count.resize (triangulation.n_vertices());
vertex_to_cell.resize (triangulation.n_vertices());
std::vector<unsigned int> &edge_touch_count,
std::vector<std::list<
std::pair<typename Triangulation<dim,spacedim>::active_cell_iterator,unsigned int> > >
- & edge_to_cell)
+ &edge_to_cell)
{
Assert (triangulation.n_levels() == 1, ExcInternalError());
const std::vector<unsigned int> &vertex_touch_count,
const std::vector<std::list<
std::pair<typename Triangulation<dim,spacedim>::active_cell_iterator,unsigned int> > >
- & vertex_to_cell,
+ &vertex_to_cell,
const std::vector<types::global_dof_index> &coarse_cell_to_p4est_tree_permutation,
const bool set_vertex_info,
typename internal::p4est::types<dim>::connectivity *connectivity)
Triangulation<dim,spacedim>::
load(const char *filename)
{
- if (parallel_ghost != 0) {
- dealii::internal::p4est::functions<dim>::ghost_destroy (parallel_ghost);
- parallel_ghost = 0;
- }
+ if (parallel_ghost != 0)
+ {
+ dealii::internal::p4est::functions<dim>::ghost_destroy (parallel_ghost);
+ parallel_ghost = 0;
+ }
dealii::internal::p4est::functions<dim>::destroy (parallel_forest);
parallel_forest = 0;
dealii::internal::p4est::functions<dim>::connectivity_destroy (connectivity);
// this command changes the distribution for some reason, so we
// will leave it in here.
dealii::internal::p4est::functions<dim>::
- partition (parallel_forest,
- /* prepare coarsening */ 1,
- /* weight_callback */ NULL);
+ partition (parallel_forest,
+ /* prepare coarsening */ 1,
+ /* weight_callback */ NULL);
}
num_ett = std::accumulate (edge_touch_count.begin(),
edge_touch_count.end(),
0);
-
+
// now create a connectivity object with the right sizes for all arrays
const bool set_vertex_info
#ifdef DEBUG
// function. Note that the smoothing flag is used in the normal
// refinement process.
typename Triangulation<dim,spacedim>::MeshSmoothing
- save_smooth = this->smooth_grid;
+ save_smooth = this->smooth_grid;
// We will refine manually to match the p4est further down, which
// obeys a level difference of 2 at each vertex (see the balance call
parallel_ghost = 0;
}
parallel_ghost = dealii::internal::p4est::functions<dim>::ghost_new (parallel_forest,
- (dim == 2
- ?
- typename dealii::internal::p4est::types<dim>::
- balance_type(P4EST_CONNECT_CORNER)
- :
- typename dealii::internal::p4est::types<dim>::
- balance_type(P8EST_CONNECT_CORNER)));
+ (dim == 2
+ ?
+ typename dealii::internal::p4est::types<dim>::
+ balance_type(P4EST_CONNECT_CORNER)
+ :
+ typename dealii::internal::p4est::types<dim>::
+ balance_type(P8EST_CONNECT_CORNER)));
Assert (parallel_ghost, ExcInternalError());
Assert(cell->neighbor(f)->active(), ExcInternalError());
Assert(cell->neighbor(f)->subdomain_id() != numbers::artificial_subdomain_id, ExcInternalError());
Assert(cell->neighbor(f)->level_subdomain_id() == numbers::artificial_subdomain_id
- || cell->neighbor(f)->level_subdomain_id() == cell->neighbor(f)->subdomain_id(), ExcInternalError());
+ || cell->neighbor(f)->level_subdomain_id() == cell->neighbor(f)->subdomain_id(), ExcInternalError());
cell->neighbor(f)->set_level_subdomain_id(cell->neighbor(f)->subdomain_id());
}
}
register_data_attach (const std::size_t size,
const std_cxx1x::function<void(const cell_iterator &,
const CellStatus,
- void *)> & pack_callback)
+ void *)> &pack_callback)
{
Assert(size>0, ExcMessage("register_data_attach(), size==0"));
Assert(attached_data_pack_callbacks.size()==n_attached_datas,
notify_ready_to_unpack (const unsigned int offset,
const std_cxx1x::function<void (const cell_iterator &,
const CellStatus,
- const void *)> & unpack_callback)
+ const void *)> &unpack_callback)
{
Assert (offset < attached_data_size, ExcMessage ("invalid offset in notify_ready_to_unpack()"));
Assert (n_attached_datas > 0, ExcMessage ("notify_ready_to_unpack() called too often"));
struct find_ghosts
{
typename dealii::parallel::distributed::Triangulation<dim,spacedim> *triangulation;
- sc_array_t * subids;
+ sc_array_t *subids;
std::map<unsigned int, std::set<dealii::types::subdomain_id> >
*vertices_with_ghost_neighbors;
};
template <int dim, int spacedim>
void
find_ghosts_corner
- (typename dealii::internal::p4est::iter<dim>::corner_info * info,
+ (typename dealii::internal::p4est::iter<dim>::corner_info *info,
void *user_data)
{
int i, j;
int nsides = info->sides.elem_count;
- typename dealii::internal::p4est::iter<dim>::corner_side * sides =
+ typename dealii::internal::p4est::iter<dim>::corner_side *sides =
(typename dealii::internal::p4est::iter<dim>::corner_side *)
(info->sides.array);
struct find_ghosts<dim,spacedim> *fg = static_cast<struct find_ghosts<dim,spacedim> *>(user_data);
*vertices_with_ghost_neighbors = fg->vertices_with_ghost_neighbors;
subids->elem_count = 0;
- for (i = 0; i < nsides; i++) {
- if (sides[i].is_ghost) {
- typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].quad));
- Assert (cell->is_ghost(), ExcMessage ("ghost quad did not find ghost cell"));
- dealii::types::subdomain_id *subid =
- static_cast<dealii::types::subdomain_id *>(sc_array_push (subids));
- *subid = cell->subdomain_id();
+ for (i = 0; i < nsides; i++)
+ {
+ if (sides[i].is_ghost)
+ {
+ typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].quad));
+ Assert (cell->is_ghost(), ExcMessage ("ghost quad did not find ghost cell"));
+ dealii::types::subdomain_id *subid =
+ static_cast<dealii::types::subdomain_id *>(sc_array_push (subids));
+ *subid = cell->subdomain_id();
+ }
}
- }
- if (!subids->elem_count) {
- return;
- }
+ if (!subids->elem_count)
+ {
+ return;
+ }
nsubs = (int) subids->elem_count;
subdomain_ids = (dealii::types::subdomain_id *) (subids->array);
- for (i = 0; i < nsides; i++) {
- if (!sides[i].is_ghost) {
- typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].quad));
+ for (i = 0; i < nsides; i++)
+ {
+ if (!sides[i].is_ghost)
+ {
+ typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].quad));
- Assert (!cell->is_ghost(), ExcMessage ("local quad found ghost cell"));
+ Assert (!cell->is_ghost(), ExcMessage ("local quad found ghost cell"));
- for (j = 0; j < nsubs; j++) {
- (*vertices_with_ghost_neighbors)[cell->vertex_index(sides[i].corner)]
- .insert (subdomain_ids[j]);
- }
+ for (j = 0; j < nsubs; j++)
+ {
+ (*vertices_with_ghost_neighbors)[cell->vertex_index(sides[i].corner)]
+ .insert (subdomain_ids[j]);
+ }
+ }
}
- }
subids->elem_count = 0;
}
template <int dim, int spacedim>
void
find_ghosts_edge
- (typename dealii::internal::p4est::iter<dim>::edge_info * info,
+ (typename dealii::internal::p4est::iter<dim>::edge_info *info,
void *user_data)
{
int i, j, k;
int nsides = info->sides.elem_count;
- typename dealii::internal::p4est::iter<dim>::edge_side * sides =
+ typename dealii::internal::p4est::iter<dim>::edge_side *sides =
(typename dealii::internal::p4est::iter<dim>::edge_side *)
(info->sides.array);
struct find_ghosts<dim,spacedim> *fg = static_cast<struct find_ghosts<dim,spacedim> *>(user_data);
*vertices_with_ghost_neighbors = fg->vertices_with_ghost_neighbors;
subids->elem_count = 0;
- for (i = 0; i < nsides; i++) {
- if (sides[i].is_hanging) {
- for (j = 0; j < 2; j++) {
- if (sides[i].is.hanging.is_ghost[j]) {
- typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].is.hanging.quad[j]));
- dealii::types::subdomain_id *subid =
- static_cast<dealii::types::subdomain_id *>(sc_array_push (subids));
- *subid = cell->subdomain_id();
+ for (i = 0; i < nsides; i++)
+ {
+ if (sides[i].is_hanging)
+ {
+ for (j = 0; j < 2; j++)
+ {
+ if (sides[i].is.hanging.is_ghost[j])
+ {
+ typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].is.hanging.quad[j]));
+ dealii::types::subdomain_id *subid =
+ static_cast<dealii::types::subdomain_id *>(sc_array_push (subids));
+ *subid = cell->subdomain_id();
+ }
+ }
}
- }
}
- }
- if (!subids->elem_count) {
- return;
- }
+ if (!subids->elem_count)
+ {
+ return;
+ }
nsubs = (int) subids->elem_count;
subdomain_ids = (dealii::types::subdomain_id *) (subids->array);
- for (i = 0; i < nsides; i++) {
- if (sides[i].is_hanging) {
- for (j = 0; j < 2; j++) {
- if (!sides[i].is.hanging.is_ghost[j]) {
- typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].is.hanging.quad[j]));
+ for (i = 0; i < nsides; i++)
+ {
+ if (sides[i].is_hanging)
+ {
+ for (j = 0; j < 2; j++)
+ {
+ if (!sides[i].is.hanging.is_ghost[j])
+ {
+ typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].is.hanging.quad[j]));
- for (k = 0; k < nsubs; k++) {
- (*vertices_with_ghost_neighbors)[cell->vertex_index(p8est_edge_corners[sides[i].edge][1^j])]
- .insert (subdomain_ids[k]);
- }
+ for (k = 0; k < nsubs; k++)
+ {
+ (*vertices_with_ghost_neighbors)[cell->vertex_index(p8est_edge_corners[sides[i].edge][1^j])]
+ .insert (subdomain_ids[k]);
+ }
+ }
+ }
}
- }
}
- }
subids->elem_count = 0;
}
template <int dim, int spacedim>
void
find_ghosts_face
- (typename dealii::internal::p4est::iter<dim>::face_info * info,
+ (typename dealii::internal::p4est::iter<dim>::face_info *info,
void *user_data)
{
int i, j, k;
int nsides = info->sides.elem_count;
- typename dealii::internal::p4est::iter<dim>::face_side * sides =
+ typename dealii::internal::p4est::iter<dim>::face_side *sides =
(typename dealii::internal::p4est::iter<dim>::face_side *)
(info->sides.array);
struct find_ghosts<dim,spacedim> *fg = static_cast<struct find_ghosts<dim,spacedim> *>(user_data);
int limit = (dim == 2) ? 2 : 4;
subids->elem_count = 0;
- for (i = 0; i < nsides; i++) {
- if (sides[i].is_hanging) {
- for (j = 0; j < limit; j++) {
- if (sides[i].is.hanging.is_ghost[j]) {
- typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].is.hanging.quad[j]));
- dealii::types::subdomain_id *subid =
- static_cast<dealii::types::subdomain_id *>(sc_array_push (subids));
- *subid = cell->subdomain_id();
+ for (i = 0; i < nsides; i++)
+ {
+ if (sides[i].is_hanging)
+ {
+ for (j = 0; j < limit; j++)
+ {
+ if (sides[i].is.hanging.is_ghost[j])
+ {
+ typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].is.hanging.quad[j]));
+ dealii::types::subdomain_id *subid =
+ static_cast<dealii::types::subdomain_id *>(sc_array_push (subids));
+ *subid = cell->subdomain_id();
+ }
+ }
}
- }
}
- }
- if (!subids->elem_count) {
- return;
- }
+ if (!subids->elem_count)
+ {
+ return;
+ }
nsubs = (int) subids->elem_count;
subdomain_ids = (dealii::types::subdomain_id *) (subids->array);
- for (i = 0; i < nsides; i++) {
- if (sides[i].is_hanging) {
- for (j = 0; j < limit; j++) {
- if (!sides[i].is.hanging.is_ghost[j]) {
- typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].is.hanging.quad[j]));
+ for (i = 0; i < nsides; i++)
+ {
+ if (sides[i].is_hanging)
+ {
+ for (j = 0; j < limit; j++)
+ {
+ if (!sides[i].is.hanging.is_ghost[j])
+ {
+ typename dealii::parallel::distributed::Triangulation<dim,spacedim>::cell_iterator cell = cell_from_quad (triangulation, sides[i].treeid, *(sides[i].is.hanging.quad[j]));
- for (k = 0; k < nsubs; k++) {
- if (dim == 2) {
- (*vertices_with_ghost_neighbors)[cell->vertex_index(p4est_face_corners[sides[i].face][(limit - 1)^j])]
- .insert (subdomain_ids[k]);
- }
- else {
- (*vertices_with_ghost_neighbors)[cell->vertex_index(p8est_face_corners[sides[i].face][(limit - 1)^j])]
- .insert (subdomain_ids[k]);
+ for (k = 0; k < nsubs; k++)
+ {
+ if (dim == 2)
+ {
+ (*vertices_with_ghost_neighbors)[cell->vertex_index(p4est_face_corners[sides[i].face][(limit - 1)^j])]
+ .insert (subdomain_ids[k]);
+ }
+ else
+ {
+ (*vertices_with_ghost_neighbors)[cell->vertex_index(p8est_face_corners[sides[i].face][(limit - 1)^j])]
+ .insert (subdomain_ids[k]);
+ }
+ }
+ }
}
- }
}
- }
}
- }
subids->elem_count = 0;
}
void
Triangulation<1,1>::
fill_vertices_with_ghost_neighbors
- (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
- &vertices_with_ghost_neighbors)
+ (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
+ &vertices_with_ghost_neighbors)
{
Assert (false, ExcNotImplemented());
}
void
Triangulation<1,2>::
fill_vertices_with_ghost_neighbors
- (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
- &vertices_with_ghost_neighbors)
+ (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
+ &vertices_with_ghost_neighbors)
{
Assert (false, ExcNotImplemented());
}
void
Triangulation<1,3>::
fill_vertices_with_ghost_neighbors
- (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
- &vertices_with_ghost_neighbors)
+ (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
+ &vertices_with_ghost_neighbors)
{
Assert (false, ExcNotImplemented());
}
void
Triangulation<2,2>::
fill_vertices_with_ghost_neighbors
- (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
- &vertices_with_ghost_neighbors)
+ (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
+ &vertices_with_ghost_neighbors)
{
struct find_ghosts<2,2> fg;
void
Triangulation<2,3>::
fill_vertices_with_ghost_neighbors
- (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
- &vertices_with_ghost_neighbors)
+ (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
+ &vertices_with_ghost_neighbors)
{
struct find_ghosts<2,3> fg;
void
Triangulation<3,3>::
fill_vertices_with_ghost_neighbors
- (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
- &vertices_with_ghost_neighbors)
+ (std::map<unsigned int, std::set<dealii::types::subdomain_id> >
+ &vertices_with_ghost_neighbors)
{
struct find_ghosts<3,3> fg;
template<int dim, int spacedim>
void
Triangulation<dim,spacedim>::add_periodicity
- (const std::vector<GridTools::PeriodicFacePair<cell_iterator> >&
- periodicity_vector)
+ (const std::vector<GridTools::PeriodicFacePair<cell_iterator> > &
+ periodicity_vector)
{
- #if DEAL_II_P4EST_VERSION_GTE(0,3,4,1)
+#if DEAL_II_P4EST_VERSION_GTE(0,3,4,1)
Assert (triangulation_has_content == true,
ExcMessage ("The triangulation is empty!"));
Assert (this->n_levels() == 1,
ExcMessage ("The triangulation is refined!"));
-
+
typedef std::vector<GridTools::PeriodicFacePair<cell_iterator> >
- FaceVector;
+ FaceVector;
typename FaceVector::const_iterator it, periodic_end;
it = periodicity_vector.begin();
periodic_end = periodicity_vector.end();
-
+
for (; it<periodic_end; ++it)
- {
- const cell_iterator first_cell = it->cell[0];
- const cell_iterator second_cell = it->cell[1];
- const unsigned int face_left = it->face_idx[0];
- const unsigned int face_right = it->face_idx[1];
-
- //respective cells of the matching faces in p4est
- const unsigned int tree_left
- = coarse_cell_to_p4est_tree_permutation[std::distance(this->begin(),
- first_cell)];
- const unsigned int tree_right
- = coarse_cell_to_p4est_tree_permutation[std::distance(this->begin(),
- second_cell)];
-
- //TODO Add support for non default orientation.
- Assert(it->orientation == 1,
- ExcMessage("Found a face match with non standard orientation. "
- "This function is only suitable for meshes with "
- "cells in default orientation"));
-
- dealii::internal::p4est::functions<dim>::
+ {
+ const cell_iterator first_cell = it->cell[0];
+ const cell_iterator second_cell = it->cell[1];
+ const unsigned int face_left = it->face_idx[0];
+ const unsigned int face_right = it->face_idx[1];
+
+ //respective cells of the matching faces in p4est
+ const unsigned int tree_left
+ = coarse_cell_to_p4est_tree_permutation[std::distance(this->begin(),
+ first_cell)];
+ const unsigned int tree_right
+ = coarse_cell_to_p4est_tree_permutation[std::distance(this->begin(),
+ second_cell)];
+
+ //TODO Add support for non default orientation.
+ Assert(it->orientation == 1,
+ ExcMessage("Found a face match with non standard orientation. "
+ "This function is only suitable for meshes with "
+ "cells in default orientation"));
+
+ dealii::internal::p4est::functions<dim>::
connectivity_join_faces (connectivity,
tree_left,
tree_right,
face_right,
/* orientation */ 0);
- /* The orientation parameter above describes the difference between
- * the cell on the left and the cell on the right would number of the
- * corners of the face. In the periodic domains most users will want,
- * this orientation will be 0, i.e. the two cells would number the
- * corners the same way. More exotic periodicity, like moebius strips
- * or converting an unstructured quad/hex mesh into a periodic domain,
- * are not supported right now, and undefined behavior will occur if
- * users try to make them periodic. This may be addressed at a later
- * date.
- */
- }
-
-
+ /* The orientation parameter above describes the difference between
+ * the cell on the left and the cell on the right would number of the
+ * corners of the face. In the periodic domains most users will want,
+ * this orientation will be 0, i.e. the two cells would number the
+ * corners the same way. More exotic periodicity, like moebius strips
+ * or converting an unstructured quad/hex mesh into a periodic domain,
+ * are not supported right now, and undefined behavior will occur if
+ * users try to make them periodic. This may be addressed at a later
+ * date.
+ */
+ }
+
+
Assert(dealii::internal::p4est::functions<dim>::connectivity_is_valid
- (connectivity) == 1, ExcInternalError());
-
+ (connectivity) == 1, ExcInternalError());
+
// now create a forest out of the connectivity data structure
dealii::internal::p4est::functions<dim>::destroy (parallel_forest);
parallel_forest
= dealii::internal::p4est::functions<dim>::
- new_forest (mpi_communicator,
- connectivity,
- /* minimum initial number of quadrants per tree */ 0,
- /* minimum level of upfront refinement */ 0,
- /* use uniform upfront refinement */ 1,
- /* user_data_size = */ 0,
- /* user_data_constructor = */ NULL,
- /* user_pointer */ this);
+ new_forest (mpi_communicator,
+ connectivity,
+ /* minimum initial number of quadrants per tree */ 0,
+ /* minimum level of upfront refinement */ 0,
+ /* use uniform upfront refinement */ 1,
+ /* user_data_size = */ 0,
+ /* user_data_constructor = */ NULL,
+ /* user_pointer */ this);
try
- {
- copy_local_forest_to_triangulation ();
- }
+ {
+ copy_local_forest_to_triangulation ();
+ }
catch (const typename Triangulation<dim>::DistortedCellList &)
- {
- // the underlying triangulation should not be checking for distorted
- // cells
- AssertThrow (false, ExcInternalError());
- }
-
- #else
+ {
+ // the underlying triangulation should not be checking for distorted
+ // cells
+ AssertThrow (false, ExcInternalError());
+ }
+
+#else
Assert(false, ExcMessage ("Need p4est version >= 0.3.4.1!"));
- #endif
+#endif
}
const std::vector<types::global_dof_index> perm = triangulation->get_p4est_tree_to_coarse_cell_permutation ();
types::global_dof_index dealii_index = perm[treeidx];
- for (i = 0; i < l; i++) {
- typename dealii::Triangulation<dim,spacedim>::cell_iterator cell (triangulation, i, dealii_index);
- child_id = internal::p4est::functions<dim>::quadrant_ancestor_id (&quad, i + 1);
- Assert (cell->has_children (), ExcMessage ("p4est quadrant does not correspond to a cell!"));
- dealii_index = cell->child_index(child_id);
- }
+ for (i = 0; i < l; i++)
+ {
+ typename dealii::Triangulation<dim,spacedim>::cell_iterator cell (triangulation, i, dealii_index);
+ child_id = internal::p4est::functions<dim>::quadrant_ancestor_id (&quad, i + 1);
+ Assert (cell->has_children (), ExcMessage ("p4est quadrant does not correspond to a cell!"));
+ dealii_index = cell->child_index(child_id);
+ }
typename dealii::Triangulation<dim,spacedim>::cell_iterator out_cell (triangulation, l, dealii_index);
namespace internal
{
template<int dim, int spacedim>
- std::string policy_to_string(const dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> & policy)
+ std::string policy_to_string(const dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> &policy)
{
std::string policy_name;
if (dynamic_cast<const typename dealii::internal::DoFHandler::Policy::Sequential<dim,spacedim>*>(&policy))
- policy_name = "Policy::Sequential<";
+ policy_name = "Policy::Sequential<";
+ else if (dynamic_cast<const typename dealii::internal::DoFHandler::Policy::ParallelDistributed<dim,spacedim>*>(&policy))
+ policy_name = "Policy::ParallelDistributed<";
else
- if (dynamic_cast<const typename dealii::internal::DoFHandler::Policy::ParallelDistributed<dim,spacedim>*>(&policy))
- policy_name = "Policy::ParallelDistributed<";
- else
- AssertThrow(false, ExcNotImplemented());
+ AssertThrow(false, ExcNotImplemented());
policy_name += Utilities::int_to_string(dim)+
- ","+Utilities::int_to_string(spacedim)+">";
+ ","+Utilities::int_to_string(spacedim)+">";
return policy_name;
}
16*dof_handler.selected_fe->dofs_per_quad;
break;
- // the following numbers are not based on actual counting but by
- // extrapolating the number sequences from the previous ones (for
- // example, for dofs_per_vertex, the sequence above is 19, 21, 28,
- // 30, 37, and is continued as follows):
+ // the following numbers are not based on actual counting but by
+ // extrapolating the number sequences from the previous ones (for
+ // example, for dofs_per_vertex, the sequence above is 19, 21, 28,
+ // 30, 37, and is continued as follows):
case 9:
max_couplings=39*dof_handler.selected_fe->dofs_per_vertex +
59*dof_handler.selected_fe->dofs_per_line +
//have us as a neighbor. In this case we and the children are active.
if (dealii_cell->active())
{
- for (unsigned int f=0;f<GeometryInfo<dim>::faces_per_cell;++f)
+ for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
{
if (dealii_cell->at_boundary(f))
continue;
:
(dim == 2 ?
(i<2*fe.dofs_per_vertex ? i : i+2*fe.dofs_per_vertex)
+ :
+ (dim == 3 ?
+ (i<4*fe.dofs_per_vertex ?
+ i
:
- (dim == 3 ?
- (i<4*fe.dofs_per_vertex ?
- i
- :
- (i<4*fe.dofs_per_vertex+4*fe.dofs_per_line ?
- i+4*fe.dofs_per_vertex
- :
- i+4*fe.dofs_per_vertex+8*fe.dofs_per_line))
+ (i<4*fe.dofs_per_vertex+4*fe.dofs_per_line ?
+ i+4*fe.dofs_per_vertex
:
- numbers::invalid_unsigned_int)));
+ i+4*fe.dofs_per_vertex+8*fe.dofs_per_line))
+ :
+ numbers::invalid_unsigned_int)));
if (fe.is_primitive (cell_index))
- {
+ {
if (component_mask[fe.face_system_to_component_index(i).first]
== true)
selected_dofs.add_index (face_dof_indices[i]);
continue;
for (unsigned int dof=0; dof!=fe.dofs_per_line; ++dof)
dofs_on_children.push_back(
- this_face->child(child)->dof_index(dof, fe_index));
+ this_face->child(child)->dof_index(dof, fe_index));
}
// note: can get fewer DoFs when we have artificial cells
Assert(dofs_on_children.size() <= n_dofs_on_children, ExcInternalError());
if (cell->neighbor_child_on_subface (face, child)->is_artificial())
continue;
for (unsigned int dof=0; dof!=fe.dofs_per_quad; ++dof)
- dofs_on_children.push_back(
- this_face->child(child)->dof_index(dof, fe_index));
+ dofs_on_children.push_back(
+ this_face->child(child)->dof_index(dof, fe_index));
}
// note: can get fewer DoFs when we have artificial cells:
// there, we have FESystem(FE_Q(1),FE_DGQ(0)) vs.
// FESystem(FE_Q(1),FE_DGQ(1)). neither of them
// dominates the other.
- //
- // a final possibility is that we have something like
- // FESystem(FE_Q(1),FE_Q(1)) vs
- // FESystem(FE_Q(1),FE_Nothing()), see
- // hp/fe_nothing_18/19.
- //
- // in any case, the point is that it doesn't
+ //
+ // a final possibility is that we have something like
+ // FESystem(FE_Q(1),FE_Q(1)) vs
+ // FESystem(FE_Q(1),FE_Nothing()), see
+ // hp/fe_nothing_18/19.
+ //
+ // in any case, the point is that it doesn't
// matter. there is nothing to do here.
break;
}
face_1->get_dof_indices(dofs_1, face_1_index);
face_2->get_dof_indices(dofs_2, face_2_index);
- for (unsigned int i=0; i < dofs_per_face; i++) {
- if (dofs_1[i] == numbers::invalid_dof_index ||
- dofs_2[i] == numbers::invalid_dof_index) {
- /* If either of these faces have no indices, stop. This is so
- * that there is no attempt to match artificial cells of
- * parallel distributed triangulations.
- *
- * While it seems like we ought to be able to avoid even calling
- * set_periodicity_constraints for artificial faces, this
- * situation can arise when a face that is being made periodic
- * is only partially touched by the local subdomain.
- * make_periodicity_constraints will be called recursively even
- * for the section of the face that is not touched by the local
- * subdomain.
- *
- * Until there is a better way to determine if the cells that
- * neighbor a face are artificial, we simply test to see if the
- * face does not have a valid dof initialization.
- */
- return;
+ for (unsigned int i=0; i < dofs_per_face; i++)
+ {
+ if (dofs_1[i] == numbers::invalid_dof_index ||
+ dofs_2[i] == numbers::invalid_dof_index)
+ {
+ /* If either of these faces have no indices, stop. This is so
+ * that there is no attempt to match artificial cells of
+ * parallel distributed triangulations.
+ *
+ * While it seems like we ought to be able to avoid even calling
+ * set_periodicity_constraints for artificial faces, this
+ * situation can arise when a face that is being made periodic
+ * is only partially touched by the local subdomain.
+ * make_periodicity_constraints will be called recursively even
+ * for the section of the face that is not touched by the local
+ * subdomain.
+ *
+ * Until there is a better way to determine if the cells that
+ * neighbor a face are artificial, we simply test to see if the
+ * face does not have a valid dof initialization.
+ */
+ return;
+ }
}
- }
// Well, this is a hack:
//
// orientation:
const unsigned int j =
cell_to_rotated_face_index[fe.face_to_cell_index(identity_constraint_target,
- 0, /* It doesn't really matter, just assume
+ 0, /* It doesn't really matter, just assume
* we're on the first face...
*/
face_orientation, face_flip, face_rotation)];
ExcMessage ("The boundary indicators b_id1 and b_id2 must be"
"different to denote different boundaries."));
- typedef std::vector<GridTools::PeriodicFacePair
- <typename DH::cell_iterator> > FaceVector;
+ std::vector<GridTools::PeriodicFacePair
+ <typename DH::cell_iterator> > matched_faces;
// Collect matching periodic cells on the coarsest level:
- FaceVector matched_faces =
- GridTools::collect_periodic_faces(dof_handler, b_id1, b_id2,
- direction, offset);
+ GridTools::collect_periodic_faces(dof_handler, b_id1, b_id2, direction,
+ matched_faces, offset);
make_periodicity_constraints<DH>
- (matched_faces, constraint_matrix, component_mask);
+ (matched_faces, constraint_matrix, component_mask);
}
Assert(dim == space_dim,
ExcNotImplemented());
- typedef std::vector<GridTools::PeriodicFacePair
- <typename DH::cell_iterator> > FaceVector;
+ std::vector<GridTools::PeriodicFacePair
+ <typename DH::cell_iterator> > matched_faces;
// Collect matching periodic cells on the coarsest level:
- const FaceVector matched_faces =
- GridTools::collect_periodic_faces(dof_handler, b_id,
- direction, offset);
+ GridTools::collect_periodic_faces(dof_handler, b_id, direction,
+ matched_faces, offset);
make_periodicity_constraints<DH>
- (matched_faces, constraint_matrix, component_mask);
+ (matched_faces, constraint_matrix, component_mask);
}
void
make_periodicity_constraints
(const std::vector<GridTools::PeriodicFacePair<typename DH::cell_iterator> >
- &periodic_faces,
+ &periodic_faces,
dealii::ConstraintMatrix &constraint_matrix,
const ComponentMask &component_mask)
{
// And apply the low level make_periodicity_constraints function to
// every matching pair:
- for(; it!=end_periodic; ++it)
- {
- typedef typename DH::face_iterator FaceIterator;
- const FaceIterator face_1 = it->cell[0]->face(it->face_idx[0]);
- const FaceIterator face_2 = it->cell[1]->face(it->face_idx[1]);
+ for (; it!=end_periodic; ++it)
+ {
+ typedef typename DH::face_iterator FaceIterator;
+ const FaceIterator face_1 = it->cell[0]->face(it->face_idx[0]);
+ const FaceIterator face_2 = it->cell[1]->face(it->face_idx[1]);
- Assert(face_1->at_boundary() && face_2->at_boundary(),
- ExcInternalError());
+ Assert(face_1->at_boundary() && face_2->at_boundary(),
+ ExcInternalError());
- Assert (face_1 != face_2,
- ExcInternalError());
+ Assert (face_1 != face_2,
+ ExcInternalError());
- make_periodicity_constraints(face_1,
- face_2,
- constraint_matrix,
- component_mask,
- it->orientation[0],
- it->orientation[1],
- it->orientation[2]);
- }
+ make_periodicity_constraints(face_1,
+ face_2,
+ constraint_matrix,
+ component_mask,
+ it->orientation[0],
+ it->orientation[1],
+ it->orientation[2]);
+ }
}
*/
template <int dim, int spacedim>
void compute_intergrid_weights_3 (
- const typename dealii::DoFHandler<dim,spacedim>::active_cell_iterator &cell,
- const Assembler::Scratch &,
- Assembler::CopyData<dim,spacedim> ©_data,
- const unsigned int coarse_component,
- const FiniteElement<dim,spacedim> &coarse_fe,
- const InterGridMap<dealii::DoFHandler<dim,spacedim> > &coarse_to_fine_grid_map,
- const std::vector<dealii::Vector<double> > ¶meter_dofs,
- const std::vector<types::global_dof_index> &weight_mapping)
+ const typename dealii::DoFHandler<dim,spacedim>::active_cell_iterator &cell,
+ const Assembler::Scratch &,
+ Assembler::CopyData<dim,spacedim> ©_data,
+ const unsigned int coarse_component,
+ const FiniteElement<dim,spacedim> &coarse_fe,
+ const InterGridMap<dealii::DoFHandler<dim,spacedim> > &coarse_to_fine_grid_map,
+ const std::vector<dealii::Vector<double> > ¶meter_dofs,
+ const std::vector<types::global_dof_index> &weight_mapping)
{
// for each cell on the parameter grid: find out which degrees of
// freedom on the fine grid correspond in which way to the degrees
// parameter grid cell
cell->get_dof_indices (copy_data.parameter_dof_indices);
- // reset the output array to a pristine state
- copy_data.global_parameter_representation.clear ();
+ // reset the output array to a pristine state
+ copy_data.global_parameter_representation.clear ();
// loop over all dofs on this cell and check whether they are
// interesting for us
= coarse_fe.system_to_component_index(local_dof).second;
copy_data.global_parameter_representation.push_back(
- dealii::Vector<double> (n_fine_dofs));
+ dealii::Vector<double> (n_fine_dofs));
// distribute the representation of
// @p{local_parameter_dof} on the parameter grid cell
*/
template <int dim,int spacedim>
void copy_intergrid_weights_3(const Assembler::CopyData<dim,spacedim> ©_data,
- const unsigned int coarse_component,
+ const unsigned int coarse_component,
const FiniteElement<dim,spacedim> &coarse_fe,
- const std::vector<types::global_dof_index> &weight_mapping,
+ const std::vector<types::global_dof_index> &weight_mapping,
std::vector<std::map<types::global_dof_index, float> > &weights)
{
unsigned int pos = 0;
if (coarse_fe.system_to_component_index(local_dof).first
==
coarse_component)
- {
+ {
// now that we've got the global representation of each
// parameter dof, we've only got to clobber the non-zero
// entries in that vector and store the result
// several threads operating on different intergrid
// weights, have only one mutex for all of them
for (types::global_dof_index i=0; i<copy_data.global_parameter_representation[pos].size();
- ++i)
+ ++i)
// set this weight if it belongs to a parameter dof.
if (weight_mapping[i] != numbers::invalid_dof_index)
{
Assembler::CopyData<dim,spacedim> copy_data;
WorkStream::run(coarse_grid.begin_active(),
- coarse_grid.end(),
- std_cxx1x::bind(&compute_intergrid_weights_3<dim,spacedim>,
- std_cxx1x::_1,
- std_cxx1x::_2,
- std_cxx1x::_3,
- coarse_component,
- std_cxx1x::cref(coarse_grid.get_fe()),
- std_cxx1x::cref(coarse_to_fine_grid_map),
- std_cxx1x::cref(parameter_dofs),
- std_cxx1x::cref(weight_mapping)),
- std_cxx1x::bind(©_intergrid_weights_3<dim,spacedim>,
- std_cxx1x::_1,
- coarse_component,
- std_cxx1x::cref(coarse_grid.get_fe()),
- std_cxx1x::cref(weight_mapping),
- std_cxx1x::ref(weights)),
- scratch,
- copy_data);
+ coarse_grid.end(),
+ std_cxx1x::bind(&compute_intergrid_weights_3<dim,spacedim>,
+ std_cxx1x::_1,
+ std_cxx1x::_2,
+ std_cxx1x::_3,
+ coarse_component,
+ std_cxx1x::cref(coarse_grid.get_fe()),
+ std_cxx1x::cref(coarse_to_fine_grid_map),
+ std_cxx1x::cref(parameter_dofs),
+ std_cxx1x::cref(weight_mapping)),
+ std_cxx1x::bind(©_intergrid_weights_3<dim,spacedim>,
+ std_cxx1x::_1,
+ coarse_component,
+ std_cxx1x::cref(coarse_grid.get_fe()),
+ std_cxx1x::cref(weight_mapping),
+ std_cxx1x::ref(weights)),
+ scratch,
+ copy_data);
}
if (!cell->is_artificial()
&&
cell->at_boundary ())
- {
- const FiniteElement<dim,spacedim> &fe = cell->get_fe();
+ {
+ const FiniteElement<dim,spacedim> &fe = cell->get_fe();
- // get global indices of dofs on the cell
- cell_dofs.resize (fe.dofs_per_cell);
- cell->get_dof_indices (cell_dofs);
+ // get global indices of dofs on the cell
+ cell_dofs.resize (fe.dofs_per_cell);
+ cell->get_dof_indices (cell_dofs);
- for (unsigned int face_no = 0; face_no < GeometryInfo<dim>::faces_per_cell;
- ++face_no)
- {
- const typename DH<dim,spacedim>::face_iterator face = cell->face(face_no);
-
- // if face is on the boundary and satisfies the correct
- // boundary id property
- if (face->at_boundary ()
- &&
- ((boundary_indicator == numbers::invalid_boundary_id)
- ||
- (face->boundary_indicator() == boundary_indicator)))
- {
- // get indices and physical location on this face
- face_dofs.resize (fe.dofs_per_face);
- face->get_dof_indices (face_dofs, cell->active_fe_index());
+ for (unsigned int face_no = 0; face_no < GeometryInfo<dim>::faces_per_cell;
+ ++face_no)
+ {
+ const typename DH<dim,spacedim>::face_iterator face = cell->face(face_no);
+
+ // if face is on the boundary and satisfies the correct
+ // boundary id property
+ if (face->at_boundary ()
+ &&
+ ((boundary_indicator == numbers::invalid_boundary_id)
+ ||
+ (face->boundary_indicator() == boundary_indicator)))
+ {
+ // get indices and physical location on this face
+ face_dofs.resize (fe.dofs_per_face);
+ face->get_dof_indices (face_dofs, cell->active_fe_index());
- // enter those dofs into the list that match the component
- // signature.
- for (unsigned int i=0; i<face_dofs.size(); ++i)
- {
- // Find out if a dof has a contribution in this
- // component, and if so, add it to the list
- const std::vector<types::global_dof_index>::iterator it_index_on_cell
- = std::find (cell_dofs.begin(), cell_dofs.end(), face_dofs[i]);
- Assert (it_index_on_cell != cell_dofs.end(), ExcInvalidIterator());
- const unsigned int index_on_cell = std::distance(cell_dofs.begin(),
- it_index_on_cell);
- const ComponentMask &nonzero_component_array
- = cell->get_fe().get_nonzero_components (index_on_cell);
- bool nonzero = false;
- for (unsigned int c=0; c<n_components; ++c)
- if (nonzero_component_array[c] && component_mask[c])
- {
- nonzero = true;
- break;
- }
+ // enter those dofs into the list that match the component
+ // signature.
+ for (unsigned int i=0; i<face_dofs.size(); ++i)
+ {
+ // Find out if a dof has a contribution in this
+ // component, and if so, add it to the list
+ const std::vector<types::global_dof_index>::iterator it_index_on_cell
+ = std::find (cell_dofs.begin(), cell_dofs.end(), face_dofs[i]);
+ Assert (it_index_on_cell != cell_dofs.end(), ExcInvalidIterator());
+ const unsigned int index_on_cell = std::distance(cell_dofs.begin(),
+ it_index_on_cell);
+ const ComponentMask &nonzero_component_array
+ = cell->get_fe().get_nonzero_components (index_on_cell);
+ bool nonzero = false;
+ for (unsigned int c=0; c<n_components; ++c)
+ if (nonzero_component_array[c] && component_mask[c])
+ {
+ nonzero = true;
+ break;
+ }
- if (nonzero)
- zero_boundary_constraints.add_line (face_dofs[i]);
- }
- }
- }
- }
+ if (nonzero)
+ zero_boundary_constraints.add_line (face_dofs[i]);
+ }
+ }
+ }
+ }
}
system_to_component_table.resize(this->dofs_per_cell);
face_system_to_component_table.resize(this->dofs_per_face);
for (unsigned int j=0 ; j<this->dofs_per_cell ; ++j)
- system_to_component_table[j] = std::pair<unsigned,unsigned>(0,j);
+ system_to_component_table[j] = std::pair<unsigned,unsigned>(0,j);
for (unsigned int j=0 ; j<this->dofs_per_face ; ++j)
- face_system_to_component_table[j] = std::pair<unsigned,unsigned>(0,j);
+ face_system_to_component_table[j] = std::pair<unsigned,unsigned>(0,j);
}
-
+
for (unsigned int j=0 ; j<this->dofs_per_cell ; ++j)
system_to_base_table[j] = std::make_pair(std::make_pair(0U,0U),j);
for (unsigned int j=0 ; j<this->dofs_per_face ; ++j)
face_system_to_base_table[j] = std::make_pair(std::make_pair(0U,0U),j);
-
+
// Fill with default value; may be changed by constructor of derived class.
base_to_block_indices.reinit(1,1);
{
switch (direction)
{
- // Rotate xy-plane
- // counter-clockwise
+ // Rotate xy-plane
+ // counter-clockwise
case 'z':
for (unsigned int iz=0; iz<((dim>2) ? n:1); ++iz)
for (unsigned int j=0; j<n; ++j)
numbers[l++] = k;
}
break;
- // Rotate xy-plane
- // clockwise
+ // Rotate xy-plane
+ // clockwise
case 'Z':
for (unsigned int iz=0; iz<((dim>2) ? n:1); ++iz)
for (unsigned int iy=0; iy<n; ++iy)
numbers[k] = l++;
}
break;
- // Rotate yz-plane
- // counter-clockwise
+ // Rotate yz-plane
+ // counter-clockwise
case 'x':
Assert (dim>2, ExcDimensionMismatch (dim,3));
for (unsigned int iz=0; iz<n; ++iz)
numbers[l++] = k;
}
break;
- // Rotate yz-plane
- // clockwise
+ // Rotate yz-plane
+ // clockwise
case 'X':
Assert (dim>2, ExcDimensionMismatch (dim,3));
for (unsigned int iz=0; iz<n; ++iz)
for (unsigned int iy=0; iy <= ((codim>1) ? this->degree : 0) ; ++iy)
for (unsigned int ix=0; ix<=this->degree; ++ix)
{
- Point<codim> p;
-
+ Point<codim> p;
+
p(0) = points[ix][0];
if (codim>1)
p(1) = points[iy][0];
(typename FiniteElement<dim,spacedim>::
ExcInterpolationNotImplemented ()));
- // generate a quadrature with the unit face support points.
+ // generate a quadrature with the unit face support points.
const Quadrature<dim-1> face_quadrature (source_fe->get_unit_face_support_points ());
// Rule of thumb for FP accuracy, that can be expected for a given
:
FE_PolyFace<PolynomialSpace<dim-1>, dim, spacedim>
(PolynomialSpace<dim-1>(Polynomials::Legendre::generate_complete_basis(degree)),
- FiniteElementData<dim>(get_dpo_vector(degree), 1, degree, FiniteElementData<dim>::L2),
- std::vector<bool>(1,true))
+ FiniteElementData<dim>(get_dpo_vector(degree), 1, degree, FiniteElementData<dim>::L2),
+ std::vector<bool>(1,true))
{}
const double eps = 2e-13*(this->degree+1)*(dim-1);
FullMatrix<double> mass (face_quadrature.size(), source_fe->dofs_per_face);
-
+
for (unsigned int k = 0; k < face_quadrature.size(); ++k)
{
const Point<dim-1> p =
for (unsigned int k = 0; k < face_quadrature.size(); ++k)
{
const Point<dim-1> p = numbers::invalid_unsigned_int ?
- face_quadrature.point(k) :
- GeometryInfo<dim-1>::child_to_cell_coordinates (face_quadrature.point(k),
- subface);
+ face_quadrature.point(k) :
+ GeometryInfo<dim-1>::child_to_cell_coordinates (face_quadrature.point(k),
+ subface);
v_in(k) = this->poly_space.compute_value(i, p);
}
const double result = H.least_squares(v_out, v_in);
// be done for the face orientation flag in 3D.
const Quadrature<dim> subface_quadrature
= subface == numbers::invalid_unsigned_int
- ?
- QProjector<dim>::project_to_face (quad_face_support, 0)
- :
- QProjector<dim>::project_to_subface (quad_face_support, 0, subface);
+ ?
+ QProjector<dim>::project_to_face (quad_face_support, 0)
+ :
+ QProjector<dim>::project_to_subface (quad_face_support, 0, subface);
for (unsigned int i=0; i<source_fe->dofs_per_face; ++i)
{
const Point<dim> &p = subface_quadrature.point (i);
// face orientation, face flips, etc
unsigned int adjusted_dof_index_on_line;
switch (dim)
- {
- case 1:
- Assert (false, ExcInternalError());
-
- case 2:
- // in 2d, only face_flip has a meaning. if it is set, consider
- // dofs in reverse order
- if (face_flip == false)
+ {
+ case 1:
+ Assert (false, ExcInternalError());
+
+ case 2:
+ // in 2d, only face_flip has a meaning. if it is set, consider
+ // dofs in reverse order
+ if (face_flip == false)
+ adjusted_dof_index_on_line = dof_index_on_line;
+ else
+ adjusted_dof_index_on_line = this->dofs_per_line - dof_index_on_line - 1;
+ break;
+
+ case 3:
+ // in 3d, things are difficult. someone will have to think
+ // about how this code here should look like, by drawing a bunch
+ // of pictures of how all the faces can look like with the various
+ // flips and rotations.
+ //
+ // that said, the Q2 case is easy enough to implement, as is the case
+ // where everything is in standard orientation
+ Assert ((this->dofs_per_line <= 1) ||
+ ((face_orientation == true) &&
+ (face_flip == false) &&
+ (face_rotation == false)),
+ ExcNotImplemented());
adjusted_dof_index_on_line = dof_index_on_line;
- else
- adjusted_dof_index_on_line = this->dofs_per_line - dof_index_on_line - 1;
- break;
-
- case 3:
- // in 3d, things are difficult. someone will have to think
- // about how this code here should look like, by drawing a bunch
- // of pictures of how all the faces can look like with the various
- // flips and rotations.
- //
- // that said, the Q2 case is easy enough to implement, as is the case
- // where everything is in standard orientation
- Assert ((this->dofs_per_line <= 1) ||
- ((face_orientation == true) &&
- (face_flip == false) &&
- (face_rotation == false)),
- ExcNotImplemented());
- adjusted_dof_index_on_line = dof_index_on_line;
- break;
- }
+ break;
+ }
return (this->first_line_index
+ GeometryInfo<dim>::face_to_cell_lines(face, face_line,
template <int dim, int spacedim>
FESystem<dim,spacedim>::InternalData::InternalData(const unsigned int n_base_elements,
const bool compute_hessians)
-:
+ :
compute_hessians (compute_hessians),
base_fe_datas(n_base_elements),
base_fe_values_datas(n_base_elements)
const unsigned int
base_face_to_cell_index
- = this->base_element(face_base_index.first.first).face_to_cell_index (face_base_index.second,
- face,
- face_orientation,
- face_flip,
- face_rotation);
+ = this->base_element(face_base_index.first.first).face_to_cell_index (face_base_index.second,
+ face,
+ face_orientation,
+ face_flip,
+ face_rotation);
// it would be nice if we had a base_to_system_index function, but
// all that exists is a component_to_system_index function. we can't do
start_indices[i] = k;
k += block_data[i];
}
-
+
for (unsigned int i=0; i<element.dofs_per_cell; ++i)
{
std::pair<unsigned int, types::global_dof_index>
namespace FETools
{
template <int dim, int spacedim,
- template <int, int> class DH1,
- template <int, int> class DH2,
- class InVector, class OutVector>
+ template <int, int> class DH1,
+ template <int, int> class DH2,
+ class InVector, class OutVector>
void
interpolate(const DH1<dim, spacedim> &dof1,
const InVector &u1,
template <int dim, int spacedim,
- template <int, int> class DH1,
- template <int, int> class DH2,
- class InVector, class OutVector>
+ template <int, int> class DH1,
+ template <int, int> class DH2,
+ class InVector, class OutVector>
void
interpolate (const DH1<dim, spacedim> &dof1,
const InVector &u1,
template <int dim,
- template <int> class DH,
- class InVector, class OutVector, int spacedim>
+ template <int> class DH,
+ class InVector, class OutVector, int spacedim>
void
back_interpolate(const DH<dim> &dof1,
const InVector &u1,
// ---------------------------------------------------------------------
#include <deal.II/base/memory_consumption.h>
+#include <deal.II/base/multithread_info.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/lac/vector.h>
#include <deal.II/lac/block_vector.h>
FEValuesBase<dim,spacedim>::check_cell_similarity
(const typename Triangulation<dim,spacedim>::cell_iterator &cell)
{
- // case that there has not been any cell
- // before
+ // Unfortunately, the detection of simple geometries with CellSimilarity is
+ // sensitive to the first cell detected. When doing this with multiple
+ // threads, each thread will get its own scratch data object with an
+ // FEValues object in the implementation framework from late 2013, which is
+ // initialized to the first cell the thread sees. As this number might
+ // different between different runs (after all, the tasks are scheduled
+ // dynamically onto threads), this slight deviation leads to difference in
+ // roundoff errors that propagate through the program. Therefore, we need to
+ // disable CellSimilarity in case there is more than one thread in the
+ // problem. This will likely not affect many MPI test cases as there
+ // multithreading is disabled on default, but in many other situations
+ // because we rarely explicitly set the number of threads.
+ //
+ // TODO: Is it reasonable to introduce a flag "unsafe" in the constructor of
+ // FEValues to re-enable this feature?
+ if (multithread_info.n_threads() > 1)
+ {
+ cell_similarity = CellSimilarity::none;
+ return;
+ }
+
+ // case that there has not been any cell before
if (this->present_cell.get() == 0)
cell_similarity = CellSimilarity::none;
else
- // in MappingQ, data can have been
- // modified during the last call. Then,
- // we can't use that data on the new
- // cell.
+ // in MappingQ, data can have been modified during the last call. Then, we
+ // can't use that data on the new cell.
if (cell_similarity == CellSimilarity::invalid_next_cell)
cell_similarity = CellSimilarity::none;
else
!= cell->direction_flag() )
cell_similarity = CellSimilarity::inverted_translation;
}
- // TODO: here, one could implement other
- // checks for similarity, e.g. for
+ // TODO: here, one could implement other checks for similarity, e.g. for
// children of a parallelogram.
}
(typeid(*present_cell.get()) == typeid(Type)))
{
// call destructor of the old object
- static_cast<const Type*>(present_cell.get())->~Type();
+ static_cast<const Type *>(present_cell.get())->~Type();
// then construct a new object in-place
new(const_cast<void *>(static_cast<const void *>(present_cell.get()))) Type(new_cell);
// Qp mapping of cells at the boundary.
const QGaussLobatto<1> points(degree+1);
tensor_pols = new TensorProductPolynomials<dim>
- (Polynomials::generate_complete_Lagrange_basis(points.get_points()));
+ (Polynomials::generate_complete_Lagrange_basis(points.get_points()));
Assert (n_shape_functions==tensor_pols->n(),
ExcInternalError());
Assert(n_inner+n_outer==n_shape_functions, ExcInternalError());
double const *loqv_ptr=0;
switch (degree)
{
- // for degree==1, we shouldn't have to compute any support points, since
- // all of them are on the vertices
+ // for degree==1, we shouldn't have to compute any support points, since
+ // all of them are on the vertices
case 2:
{
for (unsigned int point=0; point<n_q_points; ++point)
for (unsigned int i=0; i<n_inner; ++i)
for (unsigned int j=0; j<n_inner; ++j)
- {
- long double res = 0.;
- for (unsigned int l=0; l<dim; ++l)
- res += (long double)quadrature_data.derivative(point, n_outer+i)[l] *
- (long double)quadrature_data.derivative(point, n_outer+j)[l];
+ {
+ long double res = 0.;
+ for (unsigned int l=0; l<dim; ++l)
+ res += (long double)quadrature_data.derivative(point, n_outer+i)[l] *
+ (long double)quadrature_data.derivative(point, n_outer+j)[l];
- S(i,j) += res * (long double)quadrature.weight(point);
- }
+ S(i,j) += res * (long double)quadrature.weight(point);
+ }
// Compute the components of T to be the product of gradients of inner and
// outer shape functions.
for (unsigned int point=0; point<n_q_points; ++point)
for (unsigned int i=0; i<n_inner; ++i)
for (unsigned int k=0; k<n_outer; ++k)
- {
- long double res = 0.;
- for (unsigned int l=0; l<dim; ++l)
- res += (long double)quadrature_data.derivative(point, n_outer+i)[l] *
- (long double)quadrature_data.derivative(point, k)[l];
-
- T(i,k) += res *(long double)quadrature.weight(point);
- }
+ {
+ long double res = 0.;
+ for (unsigned int l=0; l<dim; ++l)
+ res += (long double)quadrature_data.derivative(point, n_outer+i)[l] *
+ (long double)quadrature_data.derivative(point, k)[l];
+
+ T(i,k) += res *(long double)quadrature.weight(point);
+ }
FullMatrix<long double> S_1(n_inner);
S_1.invert(S);
// early out if we already have our point
if (f.square() < 1e-24 * cell->diameter() * cell->diameter())
return p_unit;
-
+
// we need to compare the position of the computed p(x) against the given
// point 'p'. We will terminate the iteration and return 'x' if they are
// less than eps apart. The question is how to choose eps -- or, put maybe
#ifdef DEBUG_TRANSFORM_REAL_TO_UNIT_CELL
std::cout << "Newton iteration " << newton_iteration << std::endl;
#endif
-
+
// f'(x)
Tensor<2,spacedim> df;
for (unsigned int k=0; k<mdata.n_shape_functions; ++k)
#ifdef DEBUG_TRANSFORM_REAL_TO_UNIT_CELL
std::cout << " delta=" << delta << std::endl;
#endif
-
+
// do a line search
double step_length = 1;
do
const Point<spacedim> f_trial = p_real_trial-p;
#ifdef DEBUG_TRANSFORM_REAL_TO_UNIT_CELL
- std::cout << " step_length=" << step_length << std::endl
- << " ||f || =" << f.norm() << std::endl
- << " ||f*|| =" << f_trial.norm() << std::endl
- << " ||f*||_A =" << (df_inverse * f_trial).norm() << std::endl;
+ std::cout << " step_length=" << step_length << std::endl
+ << " ||f || =" << f.norm() << std::endl
+ << " ||f*|| =" << f_trial.norm() << std::endl
+ << " ||f*||_A =" << (df_inverse * f_trial).norm() << std::endl;
#endif
-
+
// see if we are making progress with the current step length
// and if not, reduce it by a factor of two and try again
- //
- // strictly speaking, we should probably use the same norm as we use
- // for the outer algorithm. in practice, line search is just a
- // crutch to find a "reasonable" step length, and so using the l2
- // norm is probably just fine
+ //
+ // strictly speaking, we should probably use the same norm as we use
+ // for the outer algorithm. in practice, line search is just a
+ // crutch to find a "reasonable" step length, and so using the l2
+ // norm is probably just fine
if (f_trial.norm() < f.norm())
{
p_real = p_real_trial;
else if (step_length > 0.05)
step_length /= 2;
else
- AssertThrow (false,
- (typename Mapping<dim,spacedim>::ExcTransformationFailed()));
+ AssertThrow (false,
+ (typename Mapping<dim,spacedim>::ExcTransformationFailed()));
}
while (true);
++newton_iteration;
if (newton_iteration > newton_iteration_limit)
- AssertThrow (false,
- (typename Mapping<dim,spacedim>::ExcTransformationFailed()));
+ AssertThrow (false,
+ (typename Mapping<dim,spacedim>::ExcTransformationFailed()));
last_f_weighted_norm = (df_inverse * f).norm();
}
while (last_f_weighted_norm > eps);
-
+
return p_unit;
}
switch (dim)
{
- // A line (1d parallelepiped)
+ // A line (1d parallelepiped)
case 1:
vertices[1] = corners[0];
break;
- // A parallelogram (2d parallelepiped)
+ // A parallelogram (2d parallelepiped)
case 2:
// assign corners to vertices:
vertices[1] = corners[0];
vertices[3] = vertices[1] + vertices[2];
break;
- // A parallelepiped (3d parallelepiped)
+ // A parallelepiped (3d parallelepiped)
case 3:
// assign corners to vertices:
vertices[1] = corners[0];
// Determine number of cells and vertices
const unsigned int
n_cells = static_cast<unsigned int>(std::ceil (half_length /
- std::max (radius_0,
- radius_1)));
+ std::max (radius_0,
+ radius_1)));
const unsigned int n_vertices = 4 * (n_cells + 1);
std::vector<Point<3> > vertices_tmp(n_vertices);
text[2] = "ASCII";
text[3] = "DATASET UNSTRUCTURED_GRID";
- for(unsigned int i = 0;i < 4;i++)//Checking for the match between initial strings/text in the file.
+ for (unsigned int i = 0; i < 4; i++) //Checking for the match between initial strings/text in the file.
{
getline(in,line);
in>>no_vertices;// taking the no. of vertices
in.ignore(256, '\n');//ignoring the number beside the total no. of points.
- for(unsigned int count = 0; count < no_vertices; count++)//loop to read three values till the no . vertices is satisfied
+ for (unsigned int count = 0; count < no_vertices; count++) //loop to read three values till the no . vertices is satisfied
{
- // VTK format always specifies vertex coordinates with 3 components
- Point<3> x;
+ // VTK format always specifies vertex coordinates with 3 components
+ Point<3> x;
in >> x(0) >> x(1) >> x(2);
vertices.push_back(Point<spacedim>());
- for (unsigned int d=0; d<spacedim; ++d)
- vertices.back()(d) = x(d);
+ for (unsigned int d=0; d<spacedim; ++d)
+ vertices.back()(d) = x(d);
vertex_indices[count] = count;
}
if (dim == 3)
{
- for(unsigned int count = 0; count < total_cells; count++)
+ for (unsigned int count = 0; count < total_cells; count++)
{
in>>type;
- if(type == 8)
+ if (type == 8)
{
cells.push_back(CellData<dim>());
- for(j = 0; j < type; j++)//loop to feed data
+ for (j = 0; j < type; j++) //loop to feed data
in >> cells.back().vertices[j];
cells.back().material_id = 0;
- for(j = 0; j < type; j++)//loop to feed the data of the vertices to the cell
+ for (j = 0; j < type; j++) //loop to feed the data of the vertices to the cell
{
cells.back().vertices[j] = vertex_indices[cells.back().vertices[j]];
}
subcelldata.boundary_quads.push_back(CellData<2>());
int no_quads = 0;
- for(j = 0; j < type; j++)//loop to feed the data to the boundary
+ for (j = 0; j < type; j++) //loop to feed the data to the boundary
{
in >> subcelldata.boundary_quads.back().vertices[j];
}
subcelldata.boundary_quads.back().material_id = 0;
- for(unsigned int j = 0; j < type; j++)
+ for (unsigned int j = 0; j < type; j++)
{
subcelldata.boundary_quads.back().vertices[j] = vertex_indices[subcelldata.boundary_quads.back().vertices[j]];
}
else if (dim == 2)
{
- for(unsigned int count = 0; count < total_cells; count++)
+ for (unsigned int count = 0; count < total_cells; count++)
{
in>>type;
- if(type == 4)
+ if (type == 4)
{
cells.push_back(CellData<dim>());
- for(j = 0; j < type; j++)//loop to feed data
+ for (j = 0; j < type; j++) //loop to feed data
in >> cells.back().vertices[j];
cells.back().material_id = 0;
- for(j = 0; j < type; j++)//loop to feed the data of the vertices to the cell
+ for (j = 0; j < type; j++) //loop to feed the data of the vertices to the cell
{
cells.back().vertices[j] = vertex_indices[cells.back().vertices[j]];
}
no_cells++;
}
- else if(type == 2)
+ else if (type == 2)
{
//If this is encountered, the pointer comes out of the loop
//and starts processing boundaries.
subcelldata.boundary_lines.push_back(CellData<1>());
int no_lines = 0;
- for(j = 0; j < type; j++)//loop to feed the data to the boundary
+ for (j = 0; j < type; j++) //loop to feed the data to the boundary
{
in >> subcelldata.boundary_lines.back().vertices[j];
}
subcelldata.boundary_lines.back().material_id = 0;
- for(unsigned int j = 0; j < type; j++)
+ for (unsigned int j = 0; j < type; j++)
{
subcelldata.boundary_lines.back().vertices[j] = vertex_indices[subcelldata.boundary_lines.back().vertices[j]];
}
{
in.ignore(256, '\n');
- while(!in.eof())
+ while (!in.eof())
{
in>>keyword_3;
- if(std::strcmp(keyword_3,"12") && std::strcmp(keyword_3,"9"))
+ if (std::strcmp(keyword_3,"12") && std::strcmp(keyword_3,"9"))
{
break;
}
in.ignore(256, '\n');
- for(unsigned int i = 0;i < 2;i++)
+ for (unsigned int i = 0; i < 2; i++)
{
getline(in,linenew);
- if(linenew.compare(textnew[i]) == 0)
+ if (linenew.compare(textnew[i]) == 0)
{}
else
AssertThrow (false,
textnew[i] + "> section"));
}
- for(unsigned int i = 0; i < no_cells; i++)//assigning IDs to cells.
+ for (unsigned int i = 0; i < no_cells; i++) //assigning IDs to cells.
{
int id;
in>>id;
if (dim == 3)
{
- for(unsigned int i = 0; i < no_quads; i++)//assigning IDs to bounds.
+ for (unsigned int i = 0; i < no_quads; i++) //assigning IDs to bounds.
{
int id;
in>>id;
}
else if (dim == 2)
{
- for(unsigned int i = 0; i < no_lines; i++)//assigning IDs to bounds.
+ for (unsigned int i = 0; i < no_lines; i++) //assigning IDs to bounds.
{
int id;
in>>id;
cells,
subcelldata);
- if(dim == spacedim)
+ if (dim == spacedim)
GridReordering<dim, spacedim>::invert_all_cells_of_negative_grid(vertices,
- cells);
+ cells);
GridReordering<dim, spacedim>::reorder_cells(cells);
tria->create_triangulation_compatibility(vertices,
return;
case vtk:
- read_vtk (in);
- return;
+ read_vtk (in);
+ return;
case unv:
read_unv (in);
for (unsigned int i=0; i<vertices.size(); ++i)
if (vertex_used[i])
- out << '\t' << vertices[i] << '\n';
+ out << '\t' << vertices[i] << '\n';
// write cells or faces
const bool write_cells = dx_flags.write_cells;
}
+template<>
+void
+GridReordering<1,3>::reorder_cells (std::vector<CellData<1> > &)
+{
+ // there should not be much to do
+ // in 1d...
+}
+
+
+template<>
+void
+GridReordering<1,3>::invert_all_cells_of_negative_grid(const std::vector<Point<3> > &,
+ std::vector<CellData<1> > &)
+{
+ // nothing to be done in 1d
+}
+
+
namespace internal
{
namespace GridReordering2d
}
AssertThrow (best_cell.first.state() == IteratorState::valid,
- ExcPointNotFound<spacedim>(p));
+ ExcPointNotFound<spacedim>(p));
return best_cell;
}
}
AssertThrow (best_cell.first.state() == IteratorState::valid,
- ExcPointNotFound<spacedim>(p));
+ ExcPointNotFound<spacedim>(p));
return best_cell;
}
// pointer/index clashes when saving/restoring them. The following approach
// works, but this map can get quite big. Not sure about more efficient solutions.
std::map< std::pair<unsigned int,unsigned int>, unsigned int >
- indexmap;
+ indexmap;
unsigned int index = 0;
for (typename Triangulation<dim,spacedim>::active_cell_iterator
cell = triangulation.begin_active();
(cell->neighbor(f)->has_children() == false))
{
unsigned int other_index = indexmap.find(
- std::pair<unsigned int,unsigned int>(cell->neighbor(f)->level(),cell->neighbor(f)->index()))->second;
+ std::pair<unsigned int,unsigned int>(cell->neighbor(f)->level(),cell->neighbor(f)->index()))->second;
cell_connectivity.add (index, other_index);
cell_connectivity.add (other_index, index);
}
* Internally used in collect_periodic_faces
*/
template<typename CellIterator>
- std::vector<PeriodicFacePair<CellIterator> >
- match_periodic_face_pairs
- (std::set<std::pair<CellIterator, unsigned int> > &pairs1,
- std::set<std::pair<typename identity<CellIterator>::type, unsigned int> > &pairs2,
- const int direction,
- const dealii::Tensor<1,CellIterator::AccessorType::space_dimension> &offset)
+ void
+ match_periodic_face_pairs
+ (std::set<std::pair<CellIterator, unsigned int> > &pairs1,
+ std::set<std::pair<typename identity<CellIterator>::type, unsigned int> > &pairs2,
+ const int direction,
+ std::vector<PeriodicFacePair<CellIterator> > &matched_pairs,
+ const dealii::Tensor<1,CellIterator::AccessorType::space_dimension> &offset)
{
static const int space_dim = CellIterator::AccessorType::space_dimension;
Assert (0<=direction && direction<space_dim,
Assert (pairs1.size() == pairs2.size(),
ExcMessage ("Unmatched faces on periodic boundaries"));
- typename std::vector<PeriodicFacePair<CellIterator> > matched_faces;
+ unsigned int n_matches = 0;
// Match with a complexity of O(n^2). This could be improved...
std::bitset<3> orientation;
typedef typename std::set
- <std::pair<CellIterator, unsigned int> >::const_iterator PairIterator;
+ <std::pair<CellIterator, unsigned int> >::const_iterator PairIterator;
for (PairIterator it1 = pairs1.begin(); it1 != pairs1.end(); ++it1)
{
for (PairIterator it2 = pairs2.begin(); it2 != pairs2.end(); ++it2)
// remove the matched cell in pairs2 to speed up the
// matching:
const PeriodicFacePair<CellIterator> matched_face
- = {{cell1, cell2},{face_idx1, face_idx2}, orientation};
- matched_faces.push_back(matched_face);
+ = {{cell1, cell2},{face_idx1, face_idx2}, orientation};
+ matched_pairs.push_back(matched_face);
pairs2.erase(it2);
+ ++n_matches;
break;
}
}
}
- AssertThrow (matched_faces.size() == pairs1.size() && pairs2.size() == 0,
+ //Assure that all faces are matched
+ AssertThrow (n_matches == pairs1.size() && pairs2.size() == 0,
ExcMessage ("Unmatched faces on periodic boundaries"));
-
- return matched_faces;
}
template<typename CONTAINER>
- std::vector<PeriodicFacePair<typename CONTAINER::cell_iterator> >
+ void
collect_periodic_faces
- (const CONTAINER &container,
- const types::boundary_id b_id1,
- const types::boundary_id b_id2,
- const int direction,
- const dealii::Tensor<1,CONTAINER::space_dimension> &offset)
+ (const CONTAINER &container,
+ const types::boundary_id b_id1,
+ const types::boundary_id b_id2,
+ const int direction,
+ std::vector<PeriodicFacePair<typename CONTAINER::cell_iterator> > &matched_pairs,
+ const dealii::Tensor<1,CONTAINER::space_dimension> &offset)
{
static const int dim = CONTAINER::dimension;
static const int space_dim = CONTAINER::space_dimension;
{
const typename CONTAINER::face_iterator face = cell->face(i);
if (face->at_boundary() && face->boundary_indicator() == b_id1)
- {
- const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair1
- = std::make_pair(cell, i);
- pairs1.insert(pair1);
- }
+ {
+ const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair1
+ = std::make_pair(cell, i);
+ pairs1.insert(pair1);
+ }
if (face->at_boundary() && face->boundary_indicator() == b_id2)
- {
- const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair2
- = std::make_pair(cell, i);
- pairs2.insert(pair2);
- }
+ {
+ const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair2
+ = std::make_pair(cell, i);
+ pairs2.insert(pair2);
+ }
}
}
ExcMessage ("Unmatched faces on periodic boundaries"));
// and call match_periodic_face_pairs that does the actual matching:
- return match_periodic_face_pairs(pairs1, pairs2, direction, offset);
+ match_periodic_face_pairs(pairs1, pairs2, direction, matched_pairs, offset);
}
template<typename CONTAINER>
- std::vector<PeriodicFacePair<typename CONTAINER::cell_iterator> >
- collect_periodic_faces (const CONTAINER &container,
- const types::boundary_id b_id,
- const int direction,
- const dealii::Tensor<1,CONTAINER::space_dimension> &offset)
+ void
+ collect_periodic_faces
+ (const CONTAINER &container,
+ const types::boundary_id b_id,
+ const int direction,
+ std::vector<PeriodicFacePair<typename CONTAINER::cell_iterator> > &matched_pairs,
+ const dealii::Tensor<1,CONTAINER::space_dimension> &offset)
{
static const int dim = CONTAINER::dimension;
static const int space_dim = CONTAINER::space_dimension;
for (typename CONTAINER::cell_iterator cell = container.begin(0);
cell != container.end(0); ++cell)
- {
- const typename CONTAINER::face_iterator face_1 = cell->face(2*direction);
- const typename CONTAINER::face_iterator face_2 = cell->face(2*direction+1);
-
- if (face_1->at_boundary() && face_1->boundary_indicator() == b_id)
- {
- const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair1
- = std::make_pair(cell, 2*direction);
- pairs1.insert(pair1);
- }
-
- if (face_2->at_boundary() && face_2->boundary_indicator() == b_id)
- {
- const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair2
- = std::make_pair(cell, 2*direction+1);
- pairs2.insert(pair2);
- }
- }
+ {
+ const typename CONTAINER::face_iterator face_1 = cell->face(2*direction);
+ const typename CONTAINER::face_iterator face_2 = cell->face(2*direction+1);
+
+ if (face_1->at_boundary() && face_1->boundary_indicator() == b_id)
+ {
+ const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair1
+ = std::make_pair(cell, 2*direction);
+ pairs1.insert(pair1);
+ }
+
+ if (face_2->at_boundary() && face_2->boundary_indicator() == b_id)
+ {
+ const std::pair<typename CONTAINER::cell_iterator, unsigned int> pair2
+ = std::make_pair(cell, 2*direction+1);
+ pairs2.insert(pair2);
+ }
+ }
Assert (pairs1.size() == pairs2.size(),
ExcMessage ("Unmatched faces on periodic boundaries"));
- // and call match_periodic_face_pairs that does the actual matching:
- typedef std::vector<PeriodicFacePair<typename CONTAINER::cell_iterator> >
- FaceVector;
+#ifdef DEBUG
+ const unsigned int size_old = matched_pairs.size();
+#endif
- FaceVector matching = match_periodic_face_pairs(pairs1, pairs2,
- direction, offset);
+ // and call match_periodic_face_pairs that does the actual matching:
+ match_periodic_face_pairs(pairs1, pairs2, direction, matched_pairs, offset);
#ifdef DEBUG
- for (typename FaceVector::iterator pairing = matching.begin();
- pairing != matching.end(); ++pairing)
- {
- Assert(pairing->orientation == 1,
- ExcMessage("Found a face match with non standard orientation. "
- "This function is only suitable for meshes with cells "
- "in default orientation"));
- }
+ //check for standard orientation
+ const unsigned int size_new = matched_pairs.size();
+ for (unsigned int i = size_old; i < size_new; ++i)
+ {
+ Assert(matched_pairs[i].orientation == 1,
+ ExcMessage("Found a face match with non standard orientation. "
+ "This function is only suitable for meshes with cells "
+ "in default orientation"));
+ }
#endif
-
- return matching;
}
#if deal_II_dimension >= 2
template
- std::vector<PeriodicFacePair<X::cell_iterator> >
- collect_periodic_faces<X>
- (const X &,
- const types::boundary_id,
- const types::boundary_id,
- const int,
- const Tensor<1,X::space_dimension> &);
+ void collect_periodic_faces<X> (const X &,
+ const types::boundary_id,
+ const types::boundary_id,
+ const int,
+ std::vector<PeriodicFacePair<X::cell_iterator> > &,
+ const Tensor<1,X::space_dimension> &);
template
- std::vector<PeriodicFacePair<X::cell_iterator> >
- collect_periodic_faces<X>
- (const X &,
- const types::boundary_id,
- const int,
- const Tensor<1,X::space_dimension> &);
+ void collect_periodic_faces<X> (const X &,
+ const types::boundary_id,
+ const int,
+ std::vector<PeriodicFacePair<X::cell_iterator> > &,
+ const Tensor<1,X::space_dimension> &);
#endif
namespace GridTools \{
template
- std::vector<PeriodicFacePair<parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension>::cell_iterator> >
+ void
collect_periodic_faces<parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension> >
(const parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension> &,
const types::boundary_id,
const types::boundary_id,
const int,
+ std::vector<PeriodicFacePair<parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension>::cell_iterator> > &,
const Tensor<1,parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension>::space_dimension> &);
template
- std::vector<PeriodicFacePair<parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension>::cell_iterator> >
+ void
collect_periodic_faces<parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension> >
(const parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension> &,
const types::boundary_id,
const int,
+ std::vector<PeriodicFacePair<parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension>::cell_iterator> > &,
const Tensor<1,parallel::distributed::Triangulation<deal_II_dimension, deal_II_space_dimension>::space_dimension> &);
\}
if (points[n_intermediate_points].get() == 0)
{
std_cxx1x::shared_ptr<QGaussLobatto<1> >
- quadrature (new QGaussLobatto<1>(n_intermediate_points+2));
+ quadrature (new QGaussLobatto<1>(n_intermediate_points+2));
points[n_intermediate_points] = quadrature;
}
}
RefinementCase<G::dimension>::no_refinement);
}
+ // first reserve, then resize. Otherwise the std library can decide to allocate
+ // more entries.
+ boundary_or_material_id.reserve (new_size);
boundary_or_material_id.resize (new_size);
+ user_data.reserve (new_size);
+ user_data.resize (new_size);
+
manifold_id.reserve (new_size);
manifold_id.insert (manifold_id.end(),
new_size-manifold_id.size(),
numbers::flat_manifold_id);
- user_data.resize (new_size);
}
if (n_unused_singles==0)
4*new_size-children.size(),
-1);
- // for the following two fields, we know exactly how many elements
- // we need, so first reserve then resize (resize itself, at least
- // with some compiler libraries, appears to round up the size it
- // actually reserves)
+ // for the following two fields, we know exactly how many elements
+ // we need, so first reserve then resize (resize itself, at least
+ // with some compiler libraries, appears to round up the size it
+ // actually reserves)
boundary_or_material_id.reserve (new_size);
boundary_or_material_id.resize (new_size);
active_fe_backup(dof_handler.levels.size ());
for (unsigned int level = 0; level<dof_handler.levels.size (); ++level)
std::swap (dof_handler.levels[level]->active_fe_indices,
- active_fe_backup[level]);
+ active_fe_backup[level]);
// delete all levels and set them up
// newly, since vectors are
// non-invalid value later on
dof_handler.faces->lines.dof_offsets
= std::vector<unsigned int> (dof_handler.tria->n_raw_lines(),
- (unsigned int)(-1));
+ (unsigned int)(-1));
dof_handler.faces->lines.dofs
= std::vector<types::global_dof_index> (n_line_slots,
DoFHandler<dim,spacedim>::invalid_dof_index);
{
dof_handler.faces->quads.dof_offsets
= std::vector<unsigned int>
- (dof_handler.tria->n_raw_quads(),
- (unsigned int)(-1));
+ (dof_handler.tria->n_raw_quads(),
+ (unsigned int)(-1));
dof_handler.faces->quads.dofs
= std::vector<types::global_dof_index> (n_quad_slots,
DoFHandler<dim,spacedim>::invalid_dof_index);
dofs_on_face.resize (dofs_per_face);
cell->face(f)->get_dof_indices (dofs_on_face,
- cell->active_fe_index());
+ cell->active_fe_index());
for (unsigned int i=0; i<dofs_per_face; ++i)
boundary_dofs.insert(dofs_on_face[i]);
};
// find the next cell active on this level
unsigned int next_cell = cell+1;
while ((next_cell<dof_offsets.size()) &&
- (dof_offsets[next_cell] == (offset_type)(-1)))
+ (dof_offsets[next_cell] == (offset_type)(-1)))
++next_cell;
const unsigned int next_offset = (next_cell < dof_offsets.size() ?
- dof_offsets[next_cell] :
- dof_indices.size());
+ dof_offsets[next_cell] :
+ dof_indices.size());
Assert (next_offset-dof_offsets[cell] == fe_collection[active_fe_indices[cell]].template n_dofs_per_object<dim>(),
ExcInternalError());
// find the next cell active on this level
unsigned int next_cell = cell+1;
while ((next_cell<dof_offsets.size()) &&
- (dof_offsets[next_cell] == (offset_type)(-1)))
+ (dof_offsets[next_cell] == (offset_type)(-1)))
++next_cell;
const unsigned int next_offset = (next_cell < dof_offsets.size() ?
- dof_offsets[next_cell] :
- dof_indices.size());
+ dof_offsets[next_cell] :
+ dof_indices.size());
Assert (next_offset-dof_offsets[cell] == fe_collection[active_fe_indices[cell]].template n_dofs_per_object<dim>(),
ExcInternalError());
// find the next cell active on this level
unsigned int next_cell = cell+1;
while ((next_cell<dof_offsets.size()) &&
- (dof_offsets[next_cell] == (offset_type)(-1)))
+ (dof_offsets[next_cell] == (offset_type)(-1)))
++next_cell;
const unsigned int next_offset = (next_cell < dof_offsets.size() ?
- dof_offsets[next_cell] :
- dof_indices.size());
+ dof_offsets[next_cell] :
+ dof_indices.size());
// set offset for this cell
new_dof_offsets[cell] = new_dof_indices.size();
DoFLevel::memory_consumption () const
{
return (MemoryConsumption::memory_consumption (active_fe_indices) +
- MemoryConsumption::memory_consumption (dof_indices) +
+ MemoryConsumption::memory_consumption (dof_indices) +
MemoryConsumption::memory_consumption (dof_offsets) +
MemoryConsumption::memory_consumption (cell_cache_offsets) +
MemoryConsumption::memory_consumption(cell_dof_indices_cache));
ConstraintMatrix::resolve_indices (std::vector<types::global_dof_index> &indices) const
{
const unsigned int indices_size = indices.size();
- const std::vector<std::pair<types::global_dof_index,double> > * line_ptr;
+ const std::vector<std::pair<types::global_dof_index,double> > *line_ptr;
for (unsigned int i=0; i<indices_size; ++i)
{
line_ptr = get_constraint_entries(indices[i]);
#include "constraint_matrix.inst"
+// allocate scratch data. Cannot use the generic template instantiation
+// because we need to provide an initializer object of type
+// internals::ConstraintMatrixData<Number> that can be passed to the
+// constructor of scratch_data (it won't allow one to be constructed in place).
+namespace internals
+{
+#define SCRATCH_INITIALIZER(Number,Name) \
+ ConstraintMatrixData<Number>::ScratchData scratch_data_initializer_##Name; \
+ template<> Threads::ThreadLocalStorage<ConstraintMatrixData<Number>::ScratchData> \
+ ConstraintMatrixData<Number>::scratch_data(scratch_data_initializer_##Name)
+
+ SCRATCH_INITIALIZER(double,double);
+ SCRATCH_INITIALIZER(float,float);
+ SCRATCH_INITIALIZER(long double,ldouble);
+ SCRATCH_INITIALIZER(std::complex<double>,cdouble);
+ SCRATCH_INITIALIZER(std::complex<float>,cfloat);
+ SCRATCH_INITIALIZER(std::complex<long double>,cldouble);
+#undef SCRATCH_INITIALIZER
+}
+
+
DEAL_II_NAMESPACE_CLOSE
template
void FullMatrix<S1>::fill<S2> (
- const FullMatrix<S2>&, types::global_dof_index, types::global_dof_index, types::global_dof_index, types::global_dof_index);
+ const FullMatrix<S2>&, size_type, size_type, size_type, size_type);
template
void FullMatrix<S1>::add<S2> (const S1, const FullMatrix<S2>&);
template
const S1, const FullMatrix<S2>&);
template
void FullMatrix<S1>::add<S2> (
- const FullMatrix<S2>&, S1, types::global_dof_index, types::global_dof_index, types::global_dof_index, types::global_dof_index);
+ const FullMatrix<S2>&, S1, size_type, size_type, size_type, size_type);
template
void FullMatrix<S1>::Tadd<S2> (const S1, const FullMatrix<S2>&);
template
void FullMatrix<S1>::Tadd<S2> (
- const FullMatrix<S2>&, S1, types::global_dof_index, types::global_dof_index, types::global_dof_index, types::global_dof_index);
+ const FullMatrix<S2>&, S1, size_type, size_type, size_type, size_type);
template
void FullMatrix<S1>::equ<S2> (const S1, const FullMatrix<S2>&);
template
{
template
void FullMatrix<S1>::fill<S2> (
- const FullMatrix<S2>&, types::global_dof_index, types::global_dof_index, types::global_dof_index, types::global_dof_index);
+ const FullMatrix<S2>&, size_type, size_type, size_type, size_type);
template
void FullMatrix<S1>::add<S2> (const S1, const FullMatrix<S2>&);
template
const S1, const FullMatrix<S2>&);
template
void FullMatrix<S1>::add<S2> (
- const FullMatrix<S2>&, S1, types::global_dof_index, types::global_dof_index, types::global_dof_index, types::global_dof_index);
+ const FullMatrix<S2>&, S1, size_type, size_type, size_type, size_type);
template
void FullMatrix<S1>::Tadd<S2> (const S1, const FullMatrix<S2>&);
template
void FullMatrix<S1>::Tadd<S2> (
- const FullMatrix<S2>&, S1, types::global_dof_index, types::global_dof_index,
- types::global_dof_index, types::global_dof_index);
+ const FullMatrix<S2>&, S1, size_type, size_type,
+ size_type, size_type);
template
void FullMatrix<S1>::equ<S2> (const S1, const FullMatrix<S2>&);
template
DEAL_II_NAMESPACE_OPEN
-MatrixOut::Options::Options (const bool show_absolute_values,
- const size_type block_size,
- const bool discontinuous)
+MatrixOut::Options::Options (const bool show_absolute_values,
+ const unsigned int block_size,
+ const bool discontinuous)
:
show_absolute_values (show_absolute_values),
block_size (block_size),
// transformation and target the wanted eigenvalues
if (transformation)
{
- // set transformation type if any
- transformation->set_context (solver_data->eps);
-
- // set target eigenvalues to solve for
- ierr = EPSSetTarget (solver_data->eps, target_eigenvalue);
- AssertThrow (ierr == 0, ExcSLEPcError(ierr));
+ // set transformation type if any
+ transformation->set_context (solver_data->eps);
+
+ // set target eigenvalues to solve for
+ ierr = EPSSetTarget (solver_data->eps, target_eigenvalue);
+ AssertThrow (ierr == 0, ExcSLEPcError(ierr));
}
// set which portion of the eigenspectrum to solve for
// get number of converged eigenstates
ierr = EPSGetConverged (solver_data->eps,
- reinterpret_cast<PetscInt*>(n_converged));
+ reinterpret_cast<PetscInt *>(n_converged));
AssertThrow (ierr == 0, ExcSLEPcError(ierr));
PetscInt n_iterations = 0;
// get the residual norm of the most extreme eigenvalue if and
// only if at least one eigenvector has converged.
if ((*n_converged)>0)
- {
- ierr = EPSComputeResidualNorm (solver_data->eps, 0, &residual_norm);
- AssertThrow (ierr == 0, ExcSLEPcError(ierr));
- }
+ {
+ ierr = EPSComputeResidualNorm (solver_data->eps, 0, &residual_norm);
+ AssertThrow (ierr == 0, ExcSLEPcError(ierr));
+ }
// check the solver state
const SolverControl::State state
const bool m_log_history,
const bool m_log_result)
:
- SolverControl (n, tolerance, m_log_history, m_log_result){}
+ SolverControl (n, tolerance, m_log_history, m_log_result) {}
IterationNumberControl::~IterationNumberControl()
template <class Matrix>
void SparseDirectMUMPS::initialize_matrix (const Matrix &matrix)
{
- Assert(matrix.n() == matrix.m(), ExcMessage("Matrix needs to be square."));
+ Assert(matrix.n() == matrix.m(), ExcMessage("Matrix needs to be square."));
// Check we haven't been here before:
}
-template <class CSP_t>
-void distribute_sparsity_pattern(CSP_t &csp,
+ template <class CSP_t>
+ void distribute_sparsity_pattern(CSP_t &csp,
const std::vector<IndexSet> &owned_set_per_cpu,
const MPI_Comm &mpi_comm,
const IndexSet &myrange)
-{
- size_type myid = Utilities::MPI::this_mpi_process(mpi_comm);
+ {
+ size_type myid = Utilities::MPI::this_mpi_process(mpi_comm);
- typedef std::map<size_type, std::vector<size_type> > map_vec_t;
- map_vec_t send_data;
+ typedef std::map<size_type, std::vector<size_type> > map_vec_t;
+ map_vec_t send_data;
- {
- unsigned int dest_cpu=0;
+ {
+ unsigned int dest_cpu=0;
- size_type n_local_rel_rows = myrange.n_elements();
- for (size_type row_idx=0; row_idx<n_local_rel_rows; ++row_idx)
- {
- size_type row=myrange.nth_index_in_set(row_idx);
+ size_type n_local_rel_rows = myrange.n_elements();
+ for (size_type row_idx=0; row_idx<n_local_rel_rows; ++row_idx)
+ {
+ size_type row=myrange.nth_index_in_set(row_idx);
- // calculate destination CPU, note that we start the search
- // at last destination cpu, because even if the owned ranges
- // are not contiguous, they hopefully consist of large blocks
- while (!owned_set_per_cpu[dest_cpu].is_element(row))
- {
- ++dest_cpu;
- if (dest_cpu==owned_set_per_cpu.size()) // wrap around
+ // calculate destination CPU, note that we start the search
+ // at last destination cpu, because even if the owned ranges
+ // are not contiguous, they hopefully consist of large blocks
+ while (!owned_set_per_cpu[dest_cpu].is_element(row))
+ {
+ ++dest_cpu;
+ if (dest_cpu==owned_set_per_cpu.size()) // wrap around
dest_cpu=0;
- }
+ }
- //skip myself
- if (dest_cpu==myid)
- continue;
+ //skip myself
+ if (dest_cpu==myid)
+ continue;
- size_type rlen = csp.row_length(row);
+ size_type rlen = csp.row_length(row);
- //skip empty lines
- if (!rlen)
- continue;
+ //skip empty lines
+ if (!rlen)
+ continue;
- //save entries
- std::vector<size_type> &dst = send_data[dest_cpu];
+ //save entries
+ std::vector<size_type> &dst = send_data[dest_cpu];
- dst.push_back(rlen); // number of entries
- dst.push_back(row); // row index
- for (size_type c=0; c<rlen; ++c)
- {
- //columns
- size_type column = csp.column_number(row, c);
- dst.push_back(column);
- }
- }
+ dst.push_back(rlen); // number of entries
+ dst.push_back(row); // row index
+ for (size_type c=0; c<rlen; ++c)
+ {
+ //columns
+ size_type column = csp.column_number(row, c);
+ dst.push_back(column);
+ }
+ }
- }
+ }
- unsigned int num_receive=0;
- {
- std::vector<unsigned int> send_to;
- send_to.reserve(send_data.size());
- for (map_vec_t::iterator it=send_data.begin(); it!=send_data.end(); ++it)
- send_to.push_back(it->first);
-
- num_receive =
- Utilities::MPI::
- compute_point_to_point_communication_pattern(mpi_comm, send_to).size();
- }
+ unsigned int num_receive=0;
+ {
+ std::vector<unsigned int> send_to;
+ send_to.reserve(send_data.size());
+ for (map_vec_t::iterator it=send_data.begin(); it!=send_data.end(); ++it)
+ send_to.push_back(it->first);
- std::vector<MPI_Request> requests(send_data.size());
+ num_receive =
+ Utilities::MPI::
+ compute_point_to_point_communication_pattern(mpi_comm, send_to).size();
+ }
+ std::vector<MPI_Request> requests(send_data.size());
- // send data
- {
- unsigned int idx=0;
- for (map_vec_t::iterator it=send_data.begin(); it!=send_data.end(); ++it, ++idx)
- MPI_Isend(&(it->second[0]),
- it->second.size(),
- DEAL_II_DOF_INDEX_MPI_TYPE,
- it->first,
- 124,
- mpi_comm,
- &requests[idx]);
- }
+
+ // send data
+ {
+ unsigned int idx=0;
+ for (map_vec_t::iterator it=send_data.begin(); it!=send_data.end(); ++it, ++idx)
+ MPI_Isend(&(it->second[0]),
+ it->second.size(),
+ DEAL_II_DOF_INDEX_MPI_TYPE,
+ it->first,
+ 124,
+ mpi_comm,
+ &requests[idx]);
+ }
//TODO: In the following, we read individual bytes and then reinterpret them
// as size_type objects. this is error prone. use properly typed reads that
// match the write above
- {
- //receive
- std::vector<size_type> recv_buf;
- for (unsigned int index=0; index<num_receive; ++index)
- {
- MPI_Status status;
- int len;
- MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, mpi_comm, &status);
- Assert (status.MPI_TAG==124, ExcInternalError());
+ {
+ //receive
+ std::vector<size_type> recv_buf;
+ for (unsigned int index=0; index<num_receive; ++index)
+ {
+ MPI_Status status;
+ int len;
+ MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, mpi_comm, &status);
+ Assert (status.MPI_TAG==124, ExcInternalError());
+
+ MPI_Get_count(&status, MPI_BYTE, &len);
+ Assert( len%sizeof(unsigned int)==0, ExcInternalError());
- MPI_Get_count(&status, MPI_BYTE, &len);
- Assert( len%sizeof(unsigned int)==0, ExcInternalError());
+ recv_buf.resize(len/sizeof(size_type));
- recv_buf.resize(len/sizeof(size_type));
+ MPI_Recv(&recv_buf[0], len, MPI_BYTE, status.MPI_SOURCE,
+ status.MPI_TAG, mpi_comm, &status);
- MPI_Recv(&recv_buf[0], len, MPI_BYTE, status.MPI_SOURCE,
- status.MPI_TAG, mpi_comm, &status);
+ std::vector<size_type>::const_iterator ptr = recv_buf.begin();
+ std::vector<size_type>::const_iterator end = recv_buf.end();
+ while (ptr+1<end)
+ {
+ size_type num=*(ptr++);
+ size_type row=*(ptr++);
+ for (unsigned int c=0; c<num; ++c)
+ {
+ csp.add(row, *ptr);
+ ptr++;
+ }
+ }
+ Assert(ptr==end, ExcInternalError());
+ }
+ }
- std::vector<size_type>::const_iterator ptr = recv_buf.begin();
- std::vector<size_type>::const_iterator end = recv_buf.end();
- while (ptr+1<end)
- {
- size_type num=*(ptr++);
- size_type row=*(ptr++);
- for (unsigned int c=0; c<num; ++c)
- {
- csp.add(row, *ptr);
- ptr++;
- }
- }
- Assert(ptr==end, ExcInternalError());
- }
+ // complete all sends, so that we can
+ // safely destroy the buffers.
+ MPI_Waitall(requests.size(), &requests[0], MPI_STATUSES_IGNORE);
}
- // complete all sends, so that we can
- // safely destroy the buffers.
- MPI_Waitall(requests.size(), &requests[0], MPI_STATUSES_IGNORE);
-}
-
#endif
}
template void SparsityTools::distribute_sparsity_pattern
<BlockCompressedSimpleSparsityPattern>
(BlockCompressedSimpleSparsityPattern &csp,
- const std::vector<IndexSet> &owned_set_per_cpu,
- const MPI_Comm &mpi_comm,
- const IndexSet &myrange);
+ const std::vector<IndexSet> &owned_set_per_cpu,
+ const MPI_Comm &mpi_comm,
+ const IndexSet &myrange);
#endif
// we only allow assignment to vectors with the same number of blocks
// or to an empty BlockVector
Assert (n_blocks() == 0 || n_blocks() == v.n_blocks(),
- ExcDimensionMismatch(n_blocks(), v.n_blocks()));
+ ExcDimensionMismatch(n_blocks(), v.n_blocks()));
if (this->n_blocks() != v.n_blocks())
reinit(v.n_blocks());
/* -------------------------- PreconditionAMG -------------------------- */
- void
+ void
PreconditionIdentity::vmult(VectorBase &dst,
const VectorBase &src) const
{
dst = src;
}
- void
+ void
PreconditionIdentity::vmult(dealii::Vector<double> &dst,
const dealii::Vector<double> &src) const
{
Assert (false, ExcNotImplemented());
}
- // Introduce the preconditioner,
+ // Introduce the preconditioner,
// if the identity preconditioner is used,
// the precondioner is set to none, ...
if (preconditioner.preconditioner.use_count()!=0)
- {
- ierr = solver.SetPrecOperator (const_cast<Epetra_Operator *>
- (preconditioner.preconditioner.get()));
- AssertThrow (ierr == 0, ExcTrilinosError(ierr));
- }
+ {
+ ierr = solver.SetPrecOperator (const_cast<Epetra_Operator *>
+ (preconditioner.preconditioner.get()));
+ AssertThrow (ierr == 0, ExcTrilinosError(ierr));
+ }
else
solver.SetAztecOption(AZ_precond,AZ_none);
:
(dim == 2 ?
(i<2*fe.dofs_per_vertex ? i : i+2*fe.dofs_per_vertex)
+ :
+ (dim == 3 ?
+ (i<4*fe.dofs_per_vertex ?
+ i
:
- (dim == 3 ?
- (i<4*fe.dofs_per_vertex ?
- i
- :
- (i<4*fe.dofs_per_vertex+4*fe.dofs_per_line ?
- i+4*fe.dofs_per_vertex
- :
- i+4*fe.dofs_per_vertex+8*fe.dofs_per_line))
+ (i<4*fe.dofs_per_vertex+4*fe.dofs_per_line ?
+ i+4*fe.dofs_per_vertex
:
- numbers::invalid_unsigned_int)));
+ i+4*fe.dofs_per_vertex+8*fe.dofs_per_line))
+ :
+ numbers::invalid_unsigned_int)));
Assert (cell_i < fe.dofs_per_cell, ExcInternalError());
// make sure
const typename FunctionMap<dim>::type &function_map,
std::vector<IndexSet> &boundary_indices,
const ComponentMask &component_mask)
-{
+ {
Assert (boundary_indices.size() == dof.get_tria().n_global_levels(),
ExcDimensionMismatch (boundary_indices.size(),
dof.get_tria().n_global_levels()));
}
const unsigned int patch_idx =
- (*data.cell_to_patch_index_map)[cell_and_index->first->level()][cell_and_index->first->index()];
+ (*data.cell_to_patch_index_map)[cell_and_index->first->level()][cell_and_index->first->index()];
// did we mess up the indices?
Assert(patch_idx < patches.size(), ExcInternalError());
unsigned int active_index = 0;
cell_iterator cell = first_locally_owned_cell();
for (; cell != this->triangulation->end();
- cell = next_locally_owned_cell(cell))
+ cell = next_locally_owned_cell(cell))
{
// move forward until active_cell points at the cell (cell) we are looking
// at to compute the current active_index
while (active_cell!=this->triangulation->end()
- && cell->active()
- && active_cell_iterator(cell) != active_cell)
+ && cell->active()
+ && active_cell_iterator(cell) != active_cell)
{
++active_cell;
++active_index;
cell_to_patch_index_map[cell->level()].size(),
ExcInternalError());
Assert (active_index < this->triangulation->n_active_cells(),
- ExcInternalError());
+ ExcInternalError());
cell_to_patch_index_map[cell->level()][cell->index()] = all_cells.size();
all_cells.push_back (std::make_pair(cell, active_index));
std_cxx1x::bind(&DataOut<dim,DH>::build_one_patch,
this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3,
curved_cell_region,std_cxx1x::ref(this->patches)),
- // no copy-local-to-global function needed here
- std_cxx1x::function<void (const ::dealii::DataOutBase::Patch<DH::dimension, DH::space_dimension> &)>(),
+ // no copy-local-to-global function needed here
+ std_cxx1x::function<void (const ::dealii::DataOutBase::Patch<DH::dimension, DH::space_dimension> &)>(),
thread_data,
sample_patch,
- // experimenting shows that we can make things run a bit
- // faster if we increase the number of cells we work on
- // per item (i.e., WorkStream's chunk_size argument,
- // about 10% improvement) and the items in flight at any
- // given time (another 5% on the testcase discussed in
- // @ref workstream_paper, on 32 cores) and if
- 8*multithread_info.n_threads(),
- 64);
+ // experimenting shows that we can make things run a bit
+ // faster if we increase the number of cells we work on
+ // per item (i.e., WorkStream's chunk_size argument,
+ // about 10% improvement) and the items in flight at any
+ // given time (another 5% on the testcase discussed in
+ // @ref workstream_paper, on 32 cores) and if
+ 8*multithread_info.n_threads(),
+ 64);
}
// convert the iterator to an active_iterator and advance this to the next
// active cell
typename Triangulation<DH::dimension,DH::space_dimension>::
- active_cell_iterator active_cell = cell;
+ active_cell_iterator active_cell = cell;
++active_cell;
return active_cell;
}
DataOut<dim,DH>::first_locally_owned_cell ()
{
typename DataOut<dim,DH>::cell_iterator
- cell = first_cell();
+ cell = first_cell();
// skip cells if the current one has no children (is active) and is a ghost
// or artificial cell
if (use_face_values == false)
{
dealii::hp::QCollection<dim>
- quadrature(QIterated<dim>(QTrapez<1>(), n_subdivisions));
+ quadrature(QIterated<dim>(QTrapez<1>(), n_subdivisions));
n_q_points = quadrature[0].size();
x_fe_values.resize(this->finite_elements.size());
for (unsigned int i=0; i<this->finite_elements.size(); ++i)
else
{
dealii::hp::QCollection<dim-1>
- quadrature(QIterated<dim-1>(QTrapez<1>(), n_subdivisions));
+ quadrature(QIterated<dim-1>(QTrapez<1>(), n_subdivisions));
n_q_points = quadrature[0].size();
x_fe_face_values.resize(this->finite_elements.size());
for (unsigned int i=0; i<this->finite_elements.size(); ++i)
{
Assert(data.x_fe_face_values.empty() == true, ExcInternalError());
dealii::hp::QCollection<dim>
- quadrature(QIterated<dim>(QTrapez<1>(), n_subdivisions));
+ quadrature(QIterated<dim>(QTrapez<1>(), n_subdivisions));
x_fe_values.resize(this->finite_elements.size());
for (unsigned int i=0; i<this->finite_elements.size(); ++i)
{
else
{
dealii::hp::QCollection<dim-1>
- quadrature(QIterated<dim-1>(QTrapez<1>(), n_subdivisions));
+ quadrature(QIterated<dim-1>(QTrapez<1>(), n_subdivisions));
x_fe_face_values.resize(this->finite_elements.size());
for (unsigned int i=0; i<this->finite_elements.size(); ++i)
{
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
DataOut_DoFData<DH,patch_dim,patch_space_dim>::DataOut_DoFData ()
:
triangulation(0,typeid(*this).name()),
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
template <class VECTOR>
void
DataOut_DoFData<DH,patch_dim,patch_space_dim>::
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
template <class VECTOR>
void
DataOut_DoFData<DH,patch_dim,patch_space_dim>::
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
template <class VECTOR>
void
DataOut_DoFData<DH,patch_dim,patch_space_dim>::
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
template <class VECTOR>
void
DataOut_DoFData<DH,patch_dim,patch_space_dim>::
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
template <class VECTOR>
void
DataOut_DoFData<DH,patch_dim,patch_space_dim>::
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
template <class VECTOR>
void
DataOut_DoFData<DH,patch_dim,patch_space_dim>::
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
void DataOut_DoFData<DH,patch_dim,patch_space_dim>::clear_data_vectors ()
{
dof_data.erase (dof_data.begin(), dof_data.end());
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
void
DataOut_DoFData<DH,patch_dim,patch_space_dim>::
clear_input_data_references ()
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
void
DataOut_DoFData<DH,patch_dim,patch_space_dim>::clear ()
{
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
std::vector<std::string>
DataOut_DoFData<DH,patch_dim,patch_space_dim>::
get_dataset_names () const
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
std::vector<std_cxx1x::tuple<unsigned int, unsigned int, std::string> >
DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_vector_data_ranges () const
{
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
const std::vector< dealii::DataOutBase::Patch<patch_dim, patch_space_dim> > &
DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_patches () const
{
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
std::vector<std_cxx1x::shared_ptr<dealii::hp::FECollection<DH::dimension,DH::space_dimension> > >
DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_finite_elements() const
{
const unsigned int dhdim = DH::dimension;
const unsigned int dhspacedim = DH::space_dimension;
std::vector<std_cxx1x::shared_ptr<dealii::hp::FECollection<dhdim,dhspacedim> > >
- finite_elements(this->dof_data.size());
+ finite_elements(this->dof_data.size());
for (unsigned int i=0; i<this->dof_data.size(); ++i)
{
Assert (dof_data[i]->dof_handler != 0, ExcNoDoFHandlerSelected ());
template <class DH,
- int patch_dim, int patch_space_dim>
+ int patch_dim, int patch_space_dim>
std::size_t
DataOut_DoFData<DH,patch_dim,patch_space_dim>::memory_consumption () const
{
// first fill dof_data
for (unsigned int dataset=0; dataset<this->dof_data.size(); ++dataset)
{
- const FEValuesBase<DH::dimension> & fe_patch_values
+ const FEValuesBase<DH::dimension> &fe_patch_values
= data.get_present_fe_values(dataset);
const unsigned int n_components
= fe_patch_values.get_fe().n_components();
template <class DerivativeDescription, int dim,
- template <int, int> class DH, class InputVector, int spacedim>
+ template <int, int> class DH, class InputVector, int spacedim>
void
DerivativeApproximation::
approximate_derivative (const Mapping<dim,spacedim> &mapping,
// Only act on the locally owned cells
typedef FilteredIterator<typename DH<dim,spacedim>::active_cell_iterator> CellFilter;
-
+
typedef std_cxx1x::tuple<CellFilter,Vector<float>::iterator>
- Iterators;
+ Iterators;
SynchronousIterators<Iterators> begin(Iterators (CellFilter(IteratorFilters::LocallyOwnedCell(),
- dof_handler.begin_active()),derivative_norm.begin())),
- end(Iterators (CellFilter(IteratorFilters::LocallyOwnedCell(),dof_handler.end()),
- derivative_norm.end()));
-
- // There is no need for a copier because there is no conflict between threads
+ dof_handler.begin_active()),derivative_norm.begin())),
+ end(Iterators (CellFilter(IteratorFilters::LocallyOwnedCell(),dof_handler.end()),
+ derivative_norm.end()));
+
+ // There is no need for a copier because there is no conflict between threads
// to write in derivative_norm. Scratch and CopyData are also useless.
WorkStream::run(begin,end,
- static_cast<std_cxx1x::function<void (SynchronousIterators<Iterators> const&,
- internal::Assembler::Scratch const&,internal::Assembler::CopyData &)> >
- (std_cxx1x::bind(&DerivativeApproximation::template approximate<DerivativeDescription,dim,DH,
- InputVector,spacedim>,
- std_cxx1x::_1,
- std_cxx1x::cref(mapping),
- std_cxx1x::cref(dof_handler),
- std_cxx1x::cref(solution),component)),
- std_cxx1x::function<void (internal::Assembler::CopyData const &)> (),
- internal::Assembler::Scratch (),internal::Assembler::CopyData ());
+ static_cast<std_cxx1x::function<void (SynchronousIterators<Iterators> const &,
+ internal::Assembler::Scratch const &,internal::Assembler::CopyData &)> >
+ (std_cxx1x::bind(&DerivativeApproximation::template approximate<DerivativeDescription,dim,DH,
+ InputVector,spacedim>,
+ std_cxx1x::_1,
+ std_cxx1x::cref(mapping),
+ std_cxx1x::cref(dof_handler),
+ std_cxx1x::cref(solution),component)),
+ std_cxx1x::function<void (internal::Assembler::CopyData const &)> (),
+ internal::Assembler::Scratch (),internal::Assembler::CopyData ());
}
template <class DerivativeDescription, int dim,
- template <int, int> class DH, class InputVector, int spacedim>
+ template <int, int> class DH, class InputVector, int spacedim>
void
DerivativeApproximation::approximate (SynchronousIterators<std_cxx1x::tuple<FilteredIterator<typename DH<dim,spacedim>::active_cell_iterator>,Vector<float>::iterator> > const &cell,
const Mapping<dim,spacedim> &mapping,
// call the function doing the actual
// work on this cell
DerivativeApproximation::template approximate_cell<DerivativeDescription,dim,DH,InputVector>
- (mapping,dof_handler,solution,component,std_cxx1x::get<0>(cell.iterators),derivative);
+ (mapping,dof_handler,solution,component,std_cxx1x::get<0>(cell.iterators),derivative);
// evaluate the norm and fill the vector
//*derivative_norm_on_this_cell
*std_cxx1x::get<1>(cell.iterators) = DerivativeDescription::derivative_norm (derivative);
template <class DerivativeDescription, int dim,
- template <int, int> class DH, class InputVector, int spacedim>
+ template <int, int> class DH, class InputVector, int spacedim>
void
DerivativeApproximation::
approximate_cell (const Mapping<dim,spacedim> &mapping,
namespace AssemblerData
{
template <int dim,
- int spacedim>
+ int spacedim>
struct Scratch
{
Scratch (const ::dealii::hp::FECollection<dim,spacedim> &fe,
template <int dim,
- int spacedim,
- typename CellIterator>
+ int spacedim,
+ typename CellIterator>
void mass_assembler (const CellIterator &cell,
MatrixCreator::internal::AssemblerData::Scratch<dim,spacedim> &data,
MatrixCreator::internal::AssemblerData::CopyData ©_data)
template <int dim,
- int spacedim,
- typename CellIterator>
+ int spacedim,
+ typename CellIterator>
void laplace_assembler (const CellIterator &cell,
MatrixCreator::internal::AssemblerData::Scratch<dim,spacedim> &data,
MatrixCreator::internal::AssemblerData::CopyData ©_data)
template <typename MatrixType,
- typename VectorType>
+ typename VectorType>
void copy_local_to_global (const AssemblerData::CopyData &data,
MatrixType *matrix,
VectorType *right_hand_side)
template <typename DH>
CopyData<DH>::CopyData(CopyData const &data) :
- dofs_per_cell(data.dofs_per_cell),
- dofs(data.dofs),
- dof_is_on_face(data.dof_is_on_face),
- cell(data.cell),
- cell_matrix(data.cell_matrix),
- cell_vector(data.cell_vector)
+ dofs_per_cell(data.dofs_per_cell),
+ dofs(data.dofs),
+ dof_is_on_face(data.dof_is_on_face),
+ cell(data.cell),
+ cell_matrix(data.cell_matrix),
+ cell_vector(data.cell_vector)
{}
}
}
typename FunctionMap<spacedim>::type const &boundary_functions,
Function<spacedim> const *const coefficient,
std::vector<unsigned int> const &component_mapping)
-
+
{
// All assertions for this function
// are in the calling function
const bool fe_is_primitive = fe.is_primitive();
const unsigned int dofs_per_face = fe.dofs_per_face;
-
+
copy_data.cell = cell;
copy_data.dofs_per_cell = fe.dofs_per_cell;
std::vector<double> rhs_values_scalar (fe_values.n_quadrature_points);
std::vector<Vector<double> > rhs_values_system (fe_values.n_quadrature_points,
- Vector<double>(n_function_components));
+ Vector<double>(n_function_components));
copy_data.dofs.resize(copy_data.dofs_per_cell);
cell->get_dof_indices (copy_data.dofs);
boundary_functions.end())
{
copy_data.cell_matrix.push_back(FullMatrix<double> (copy_data.dofs_per_cell,
- copy_data.dofs_per_cell));
+ copy_data.dofs_per_cell));
copy_data.cell_vector.push_back(Vector<double> (copy_data.dofs_per_cell));
fe_values.reinit (cell, face);
}
}
copy_data.cell_vector.back()(i) += fe_values.shape_value(i,point)
- * rhs_values_system[point](component_mapping[fe.system_to_component_index(i).first])
- * weight;
+ * rhs_values_system[point](component_mapping[fe.system_to_component_index(i).first])
+ * weight;
}
else
{
* normal_adjustment[point][comp]
* weight * coefficient_vector_values[point](comp);
copy_data.cell_vector.back()(i) += fe_values.shape_value_component(i,point,comp) *
- rhs_values_system[point](component_mapping[comp])
- * normal_adjustment[point][comp]
- * weight;
+ rhs_values_system[point](component_mapping[comp])
+ * normal_adjustment[point][comp]
+ * weight;
}
}
}
copy_data.dofs[i])
!=
dofs_on_face_vector.end());
- }
+ }
}
template <int dim,int spacedim>
// searches.
unsigned int pos(0);
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- {
- // check if this face is on that part of
- // the boundary we are interested in
- if (boundary_functions.find(copy_data.cell->face(face)->boundary_indicator()) !=
- boundary_functions.end())
- {
- for (unsigned int i=0; i<copy_data.dofs_per_cell; ++i)
- {
- if (copy_data.dof_is_on_face[pos][i] &&
- dof_to_boundary_mapping[copy_data.dofs[i]] != numbers::invalid_dof_index)
- {
- for (unsigned int j=0; j<copy_data.dofs_per_cell; ++j)
- if (copy_data.dof_is_on_face[pos][j] &&
- dof_to_boundary_mapping[copy_data.dofs[j]] != numbers::invalid_dof_index)
- {
- Assert(numbers::is_finite(copy_data.cell_matrix[pos](i,j)),
- ExcNumberNotFinite());
- matrix.add(dof_to_boundary_mapping[copy_data.dofs[i]],
- dof_to_boundary_mapping[copy_data.dofs[j]],
- copy_data.cell_matrix[pos](i,j));
- }
- Assert(numbers::is_finite(copy_data.cell_vector[pos](i)), ExcNumberNotFinite());
- rhs_vector(dof_to_boundary_mapping[copy_data.dofs[i]]) += copy_data.cell_vector[pos](i);
- }
- }
- ++pos;
- }
- }
+ {
+ // check if this face is on that part of
+ // the boundary we are interested in
+ if (boundary_functions.find(copy_data.cell->face(face)->boundary_indicator()) !=
+ boundary_functions.end())
+ {
+ for (unsigned int i=0; i<copy_data.dofs_per_cell; ++i)
+ {
+ if (copy_data.dof_is_on_face[pos][i] &&
+ dof_to_boundary_mapping[copy_data.dofs[i]] != numbers::invalid_dof_index)
+ {
+ for (unsigned int j=0; j<copy_data.dofs_per_cell; ++j)
+ if (copy_data.dof_is_on_face[pos][j] &&
+ dof_to_boundary_mapping[copy_data.dofs[j]] != numbers::invalid_dof_index)
+ {
+ Assert(numbers::is_finite(copy_data.cell_matrix[pos](i,j)),
+ ExcNumberNotFinite());
+ matrix.add(dof_to_boundary_mapping[copy_data.dofs[i]],
+ dof_to_boundary_mapping[copy_data.dofs[j]],
+ copy_data.cell_matrix[pos](i,j));
+ }
+ Assert(numbers::is_finite(copy_data.cell_vector[pos](i)), ExcNumberNotFinite());
+ rhs_vector(dof_to_boundary_mapping[copy_data.dofs[i]]) += copy_data.cell_vector[pos](i);
+ }
+ }
+ ++pos;
+ }
+ }
}
template <>
void
create_boundary_mass_matrix_1<2,3> (DoFHandler<2,3>::active_cell_iterator const &cell,
- MatrixCreator::internal::AssemblerBoundary::Scratch const
- &scratch,
+ MatrixCreator::internal::AssemblerBoundary::Scratch const
+ &scratch,
MatrixCreator::internal::AssemblerBoundary::CopyData<DoFHandler<2,
- 3> > ©_data,
- Mapping<2,3> const &mapping,
- FiniteElement<2,3> const &fe,
- Quadrature<1> const &q,
- FunctionMap<3>::type const &boundary_functions,
- Function<3> const *const coefficient,
- std::vector<unsigned int> const &component_mapping)
+ 3> > ©_data,
+ Mapping<2,3> const &mapping,
+ FiniteElement<2,3> const &fe,
+ Quadrature<1> const &q,
+ FunctionMap<3>::type const &boundary_functions,
+ Function<3> const *const coefficient,
+ std::vector<unsigned int> const &component_mapping)
{
Assert(false,ExcNotImplemented());
}
template <>
void
create_boundary_mass_matrix_1<1,3> (DoFHandler<1,3>::active_cell_iterator const &cell,
- MatrixCreator::internal::AssemblerBoundary::Scratch const
+ MatrixCreator::internal::AssemblerBoundary::Scratch const
&scratch,
MatrixCreator::internal::AssemblerBoundary::CopyData<DoFHandler<1,
- 3> > ©_data,
+ 3> > ©_data,
Mapping<1,3> const &mapping,
FiniteElement<1,3> const &fe,
Quadrature<0> const &q,
FunctionMap<3>::type const &boundary_functions,
Function<3> const *const coefficient,
- std::vector<unsigned int> const &component_mapping)
+ std::vector<unsigned int> const &component_mapping)
{
Assert(false,ExcNotImplemented());
}
MatrixCreator::internal::AssemblerBoundary::CopyData<DoFHandler<dim,spacedim> > copy_data;
WorkStream::run(dof.begin_active(),dof.end(),
- static_cast<std_cxx1x::function<void (typename DoFHandler<dim,spacedim>::active_cell_iterator
- const &,MatrixCreator::internal::AssemblerBoundary::Scratch const &,
- MatrixCreator::internal::AssemblerBoundary::CopyData<DoFHandler<dim,spacedim> > &)> >
- (std_cxx1x::bind(&create_boundary_mass_matrix_1<dim,spacedim>,std_cxx1x::_1,std_cxx1x::_2,
- std_cxx1x::_3,
- std_cxx1x::cref(mapping),std_cxx1x::cref(fe),std_cxx1x::cref(q),
- std_cxx1x::cref(boundary_functions),coefficient,
- std_cxx1x::cref(component_mapping))),
- static_cast<std_cxx1x::function<void (MatrixCreator::internal::AssemblerBoundary
- ::CopyData<DoFHandler<dim,spacedim> > const &)> > (std_cxx1x::bind(
- ©_boundary_mass_matrix_1<dim,spacedim>,
- std_cxx1x::_1,
- std_cxx1x::cref(boundary_functions),
- std_cxx1x::cref(dof_to_boundary_mapping),
- std_cxx1x::ref(matrix),
- std_cxx1x::ref(rhs_vector))),
- scratch,
- copy_data);
+ static_cast<std_cxx1x::function<void (typename DoFHandler<dim,spacedim>::active_cell_iterator
+ const &,MatrixCreator::internal::AssemblerBoundary::Scratch const &,
+ MatrixCreator::internal::AssemblerBoundary::CopyData<DoFHandler<dim,spacedim> > &)> >
+ (std_cxx1x::bind(&create_boundary_mass_matrix_1<dim,spacedim>,std_cxx1x::_1,std_cxx1x::_2,
+ std_cxx1x::_3,
+ std_cxx1x::cref(mapping),std_cxx1x::cref(fe),std_cxx1x::cref(q),
+ std_cxx1x::cref(boundary_functions),coefficient,
+ std_cxx1x::cref(component_mapping))),
+ static_cast<std_cxx1x::function<void (MatrixCreator::internal::AssemblerBoundary
+ ::CopyData<DoFHandler<dim,spacedim> > const &)> > (std_cxx1x::bind(
+ ©_boundary_mass_matrix_1<dim,spacedim>,
+ std_cxx1x::_1,
+ std_cxx1x::cref(boundary_functions),
+ std_cxx1x::cref(dof_to_boundary_mapping),
+ std_cxx1x::ref(matrix),
+ std_cxx1x::ref(rhs_vector))),
+ scratch,
+ copy_data);
}
template <int dim, int spacedim>
void
- create_hp_boundary_mass_matrix_1 (typename hp::DoFHandler<dim,spacedim>::active_cell_iterator const
+ create_hp_boundary_mass_matrix_1 (typename hp::DoFHandler<dim,spacedim>::active_cell_iterator const
&cell,
MatrixCreator::internal::AssemblerBoundary::Scratch const &scratch,
MatrixCreator::internal::AssemblerBoundary
const FEFaceValues<dim,spacedim> &fe_values = x_fe_values.get_present_fe_values ();
copy_data.cell_matrix.push_back(FullMatrix<double> (copy_data.dofs_per_cell,
- copy_data.dofs_per_cell));
+ copy_data.dofs_per_cell));
copy_data.cell_vector.push_back(Vector<double> (copy_data.dofs_per_cell));
if (fe_is_system)
}
copy_data.cell_vector.back()(i) += v *
- rhs_values_system[point](
- component_mapping[fe.system_to_component_index(i).first]) * weight;
+ rhs_values_system[point](
+ component_mapping[fe.system_to_component_index(i).first]) * weight;
}
}
}
copy_data.cell_matrix.back()(i,j) +=
(u * v * weight * coefficient_vector_values[point](component_i));
}
- copy_data.cell_vector.back()(i) += v *
- rhs_values_system[point](component_mapping[component_i]) * weight;
+ copy_data.cell_vector.back()(i) += v *
+ rhs_values_system[point](component_mapping[component_i]) * weight;
}
}
}
copy_data.cell_matrix.back()(i,j) += (u * v * weight);
}
copy_data.cell_vector.back()(i) += v *
- rhs_values_system[point](
- fe.system_to_component_index(i).first) *
- weight;
+ rhs_values_system[point](
+ fe.system_to_component_index(i).first) *
+ weight;
}
}
}
for (unsigned int j=0; j<fe_values.dofs_per_cell; ++j)
{
const double u = fe_values.shape_value(j,point);
- copy_data.cell_matrix.back()(i,j) += (u * v * weight *
- coefficient_values[point]);
+ copy_data.cell_matrix.back()(i,j) += (u * v * weight *
+ coefficient_values[point]);
}
copy_data.cell_vector.back()(i) += v * rhs_values_scalar[point] *weight;
}
// searches.
unsigned int pos(0);
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- {
- // check if this face is on that part of
- // the boundary we are interested in
- if (boundary_functions.find(copy_data.cell->face(face)->boundary_indicator()) !=
- boundary_functions.end())
- {
+ {
+ // check if this face is on that part of
+ // the boundary we are interested in
+ if (boundary_functions.find(copy_data.cell->face(face)->boundary_indicator()) !=
+ boundary_functions.end())
+ {
#ifdef DEBUG
- // in debug mode: compute an element in the matrix which is
- // guaranteed to belong to a boundary dof. We do this to check that the
- // entries in the cell matrix are guaranteed to be zero if the
- // respective dof is not on the boundary. Since because of
- // round-off, the actual value of the matrix entry may be
- // only close to zero, we assert that it is small relative to an element
- // which is guaranteed to be nonzero. (absolute smallness does not
- // suffice since the size of the domain scales in here)
- //
- // for this purpose we seek the diagonal of the matrix, where there
- // must be an element belonging to the boundary. we take the maximum
- // diagonal entry.
- types::global_dof_index max_element = static_cast<types::global_dof_index>(0);
- for (std::vector<types::global_dof_index>::const_iterator i=dof_to_boundary_mapping.begin();
- i!=dof_to_boundary_mapping.end(); ++i)
- if ((*i != hp::DoFHandler<dim,spacedim>::invalid_dof_index) &&
- (*i > max_element))
- max_element = *i;
- Assert (max_element == matrix.n()-1, ExcInternalError());
-
- double max_diag_entry = 0;
- for (unsigned int i=0; i<copy_data.dofs_per_cell; ++i)
- if (std::fabs(copy_data.cell_matrix[pos](i,i)) > max_diag_entry)
- max_diag_entry = std::fabs(copy_data.cell_matrix[pos](i,i));
+ // in debug mode: compute an element in the matrix which is
+ // guaranteed to belong to a boundary dof. We do this to check that the
+ // entries in the cell matrix are guaranteed to be zero if the
+ // respective dof is not on the boundary. Since because of
+ // round-off, the actual value of the matrix entry may be
+ // only close to zero, we assert that it is small relative to an element
+ // which is guaranteed to be nonzero. (absolute smallness does not
+ // suffice since the size of the domain scales in here)
+ //
+ // for this purpose we seek the diagonal of the matrix, where there
+ // must be an element belonging to the boundary. we take the maximum
+ // diagonal entry.
+ types::global_dof_index max_element = static_cast<types::global_dof_index>(0);
+ for (std::vector<types::global_dof_index>::const_iterator i=dof_to_boundary_mapping.begin();
+ i!=dof_to_boundary_mapping.end(); ++i)
+ if ((*i != hp::DoFHandler<dim,spacedim>::invalid_dof_index) &&
+ (*i > max_element))
+ max_element = *i;
+ Assert (max_element == matrix.n()-1, ExcInternalError());
+
+ double max_diag_entry = 0;
+ for (unsigned int i=0; i<copy_data.dofs_per_cell; ++i)
+ if (std::fabs(copy_data.cell_matrix[pos](i,i)) > max_diag_entry)
+ max_diag_entry = std::fabs(copy_data.cell_matrix[pos](i,i));
#endif
- for (unsigned int i=0; i<copy_data.dofs_per_cell; ++i)
+ for (unsigned int i=0; i<copy_data.dofs_per_cell; ++i)
+ for (unsigned int j=0; j<copy_data.dofs_per_cell; ++j)
+ {
+ if (copy_data.dof_is_on_face[pos][i] && copy_data.dof_is_on_face[pos][j])
+ matrix.add(dof_to_boundary_mapping[copy_data.dofs[i]],
+ dof_to_boundary_mapping[copy_data.dofs[j]],
+ copy_data.cell_matrix[pos](i,j));
+ else
+ {
+ // assume that all shape functions that are nonzero on the boundary
+ // are also listed in the @p{dof_to_boundary} mapping. if that
+ // is not the case, then the boundary mass matrix does not
+ // make that much sense anyway, as it only contains entries for
+ // parts of the functions living on the boundary
+ //
+ // these, we may compare here for relative smallness of all
+ // entries in the local matrix which are not taken over to
+ // the global one
+ Assert (std::fabs(copy_data.cell_matrix[pos](i,j)) <= 1e-10 * max_diag_entry,
+ ExcInternalError ());
+ }
+ }
+
for (unsigned int j=0; j<copy_data.dofs_per_cell; ++j)
- {
- if (copy_data.dof_is_on_face[pos][i] && copy_data.dof_is_on_face[pos][j])
- matrix.add(dof_to_boundary_mapping[copy_data.dofs[i]],
- dof_to_boundary_mapping[copy_data.dofs[j]],
- copy_data.cell_matrix[pos](i,j));
+ if (copy_data.dof_is_on_face[pos][j])
+ rhs_vector(dof_to_boundary_mapping[copy_data.dofs[j]]) += copy_data.cell_vector[pos](j);
else
{
- // assume that all shape functions that are nonzero on the boundary
- // are also listed in the @p{dof_to_boundary} mapping. if that
- // is not the case, then the boundary mass matrix does not
- // make that much sense anyway, as it only contains entries for
- // parts of the functions living on the boundary
- //
- // these, we may compare here for relative smallness of all
- // entries in the local matrix which are not taken over to
- // the global one
- Assert (std::fabs(copy_data.cell_matrix[pos](i,j)) <= 1e-10 * max_diag_entry,
- ExcInternalError ());
+ // compare here for relative
+ // smallness
+ Assert (std::fabs(copy_data.cell_vector[pos](j)) <= 1e-10 * max_diag_entry,
+ ExcInternalError());
}
- }
-
- for (unsigned int j=0; j<copy_data.dofs_per_cell; ++j)
- if (copy_data.dof_is_on_face[pos][j])
- rhs_vector(dof_to_boundary_mapping[copy_data.dofs[j]]) += copy_data.cell_vector[pos](j);
- else
- {
- // compare here for relative
- // smallness
- Assert (std::fabs(copy_data.cell_vector[pos](j)) <= 1e-10 * max_diag_entry,
- ExcInternalError());
- }
- ++pos;
- }
- }
+ ++pos;
+ }
+ }
}
}
MatrixCreator::internal::AssemblerBoundary::CopyData<hp::DoFHandler<dim,spacedim> > copy_data;
WorkStream::run(dof.begin_active(),dof.end(),
- static_cast<std_cxx1x::function<void (typename hp::DoFHandler<dim,spacedim>::active_cell_iterator
- const &,MatrixCreator::internal::AssemblerBoundary::Scratch const &,
- MatrixCreator::internal::AssemblerBoundary::CopyData<hp::DoFHandler<dim,spacedim> > &)> >
- (std_cxx1x::bind( &create_hp_boundary_mass_matrix_1<dim,spacedim>,std_cxx1x::_1,std_cxx1x::_2,
- std_cxx1x::_3,
- std_cxx1x::cref(mapping),std_cxx1x::cref(fe_collection),std_cxx1x::cref(q),
- std_cxx1x::cref(boundary_functions),coefficient,
- std_cxx1x::cref(component_mapping))),
- static_cast<std_cxx1x::function<void (MatrixCreator::internal::AssemblerBoundary
- ::CopyData<hp::DoFHandler<dim,spacedim> > const &)> > (
- std_cxx1x::bind( ©_hp_boundary_mass_matrix_1<dim,spacedim>,
- std_cxx1x::_1,
- std_cxx1x::cref(boundary_functions),
- std_cxx1x::cref(dof_to_boundary_mapping),
- std_cxx1x::ref(matrix),
- std_cxx1x::ref(rhs_vector))),
- scratch,
- copy_data);
+ static_cast<std_cxx1x::function<void (typename hp::DoFHandler<dim,spacedim>::active_cell_iterator
+ const &,MatrixCreator::internal::AssemblerBoundary::Scratch const &,
+ MatrixCreator::internal::AssemblerBoundary::CopyData<hp::DoFHandler<dim,spacedim> > &)> >
+ (std_cxx1x::bind( &create_hp_boundary_mass_matrix_1<dim,spacedim>,std_cxx1x::_1,std_cxx1x::_2,
+ std_cxx1x::_3,
+ std_cxx1x::cref(mapping),std_cxx1x::cref(fe_collection),std_cxx1x::cref(q),
+ std_cxx1x::cref(boundary_functions),coefficient,
+ std_cxx1x::cref(component_mapping))),
+ static_cast<std_cxx1x::function<void (MatrixCreator::internal::AssemblerBoundary
+ ::CopyData<hp::DoFHandler<dim,spacedim> > const &)> > (
+ std_cxx1x::bind( ©_hp_boundary_mass_matrix_1<dim,spacedim>,
+ std_cxx1x::_1,
+ std_cxx1x::cref(boundary_functions),
+ std_cxx1x::cref(dof_to_boundary_mapping),
+ std_cxx1x::ref(matrix),
+ std_cxx1x::ref(rhs_vector))),
+ scratch,
+ copy_data);
}
static_cast<typename DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::laplace_assembler<dim, spacedim, typename DoFHandler<dim,spacedim>::active_cell_iterator>,
std_cxx1x::bind (&MatrixCreator::internal::
- copy_local_to_global<SparseMatrix<double>, Vector<double> >,
- std_cxx1x::_1,
- &matrix,
- (Vector<double> *)NULL),
+ copy_local_to_global<SparseMatrix<double>, Vector<double> >,
+ std_cxx1x::_1,
+ &matrix,
+ (Vector<double> *)NULL),
assembler_data,
copy_data);
}
static_cast<typename DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::laplace_assembler<dim, spacedim, typename DoFHandler<dim,spacedim>::active_cell_iterator>,
std_cxx1x::bind (&MatrixCreator::internal::
- copy_local_to_global<SparseMatrix<double>, Vector<double> >,
- std_cxx1x::_1,
- &matrix,
- &rhs_vector),
+ copy_local_to_global<SparseMatrix<double>, Vector<double> >,
+ std_cxx1x::_1,
+ &matrix,
+ &rhs_vector),
assembler_data,
copy_data);
}
static_cast<typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::laplace_assembler<dim, spacedim, typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>,
std_cxx1x::bind (&MatrixCreator::internal::
- copy_local_to_global<SparseMatrix<double>, Vector<double> >,
- std_cxx1x::_1,
- &matrix,
- (Vector<double> *)0),
+ copy_local_to_global<SparseMatrix<double>, Vector<double> >,
+ std_cxx1x::_1,
+ &matrix,
+ (Vector<double> *)0),
assembler_data,
copy_data);
}
static_cast<typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
&MatrixCreator::internal::laplace_assembler<dim, spacedim, typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>,
std_cxx1x::bind (&MatrixCreator::internal::
- copy_local_to_global<SparseMatrix<double>, Vector<double> >,
- std_cxx1x::_1,
- &matrix,
- &rhs_vector),
+ copy_local_to_global<SparseMatrix<double>, Vector<double> >,
+ std_cxx1x::_1,
+ &matrix,
+ &rhs_vector),
assembler_data,
copy_data);
}
local_values.reinit (cell->has_children() ?
cell->child(0)->get_fe().dofs_per_cell
: cell->get_fe().dofs_per_cell, true);
- // do the interpolation. we get into trouble if the
- // interpolation_hp(new,old) matrix hasn't been computed.
- // this can happen if the respective elements don't support
- // the corresponding interpolation; if that's the case, then
- // the computation of the matrix simply sets the matrix
- // back to size zero. so if we get here and that is
- // the wrong size, then this may be because the elements
- // haven't implemented the correct function yet
- //
- // there is one wrinkle. we would like to only error out if
- // the size of the matrix is 0 times 0 but at least one
- // of the elements has more than one dof per cell. the
- // problem is that if you reinit a matrix to 4x0, it automatically
- // sets its size to 0x0. so we can only execute the following
- // test if *both* elements have dofs_per_cell>0, not if *at
- // least one* have.
- Assert (! ((interpolation_hp(new_fe_index,old_index).m() == 0)
- &&
- (interpolation_hp(new_fe_index,old_index).n() == 0)
- &&
- ((dof_handler->get_fe()[new_fe_index].dofs_per_cell > 0)
- &&
- (dof_handler->get_fe()[old_index].dofs_per_cell > 0))),
- ExcMessage ("The interpolation between two different "
- "elements you are trying to use here has "
- "not been implemented for this pair of "
- "elements!"));
+ // do the interpolation. we get into trouble if the
+ // interpolation_hp(new,old) matrix hasn't been computed.
+ // this can happen if the respective elements don't support
+ // the corresponding interpolation; if that's the case, then
+ // the computation of the matrix simply sets the matrix
+ // back to size zero. so if we get here and that is
+ // the wrong size, then this may be because the elements
+ // haven't implemented the correct function yet
+ //
+ // there is one wrinkle. we would like to only error out if
+ // the size of the matrix is 0 times 0 but at least one
+ // of the elements has more than one dof per cell. the
+ // problem is that if you reinit a matrix to 4x0, it automatically
+ // sets its size to 0x0. so we can only execute the following
+ // test if *both* elements have dofs_per_cell>0, not if *at
+ // least one* have.
+ Assert (! ((interpolation_hp(new_fe_index,old_index).m() == 0)
+ &&
+ (interpolation_hp(new_fe_index,old_index).n() == 0)
+ &&
+ ((dof_handler->get_fe()[new_fe_index].dofs_per_cell > 0)
+ &&
+ (dof_handler->get_fe()[old_index].dofs_per_cell > 0))),
+ ExcMessage ("The interpolation between two different "
+ "elements you are trying to use here has "
+ "not been implemented for this pair of "
+ "elements!"));
// simple case where all children have the
// same FE index: just interpolate to their FE
// first and then use the standard routines
- if (tmp.size() > 0)
- interpolation_hp(new_fe_index,old_index).vmult (local_values, tmp);
- else
- local_values = 0;
+ if (tmp.size() > 0)
+ interpolation_hp(new_fe_index,old_index).vmult (local_values, tmp);
+ else
+ local_values = 0;
}
if (cell->has_children() == false)
interpolation_hp(c_index,old_index).n());
local_values.reinit(cell->child(child)->get_fe().dofs_per_cell, true);
- // do the interpolation. same problem as above
- Assert (! ((interpolation_hp(c_index,old_index).m() == 0)
- &&
- (interpolation_hp(c_index,old_index).n() == 0)
- &&
- ((dof_handler->get_fe()[c_index].dofs_per_cell > 0)
- &&
- (dof_handler->get_fe()[old_index].dofs_per_cell > 0))),
- ExcMessage ("The interpolation between two different "
- "elements you are trying to use here has "
- "not been implemented for this pair of "
- "elements!"));
-
- if (tmp.size() > 0)
- interpolation_hp(c_index,old_index).vmult (local_values, tmp);
+ // do the interpolation. same problem as above
+ Assert (! ((interpolation_hp(c_index,old_index).m() == 0)
+ &&
+ (interpolation_hp(c_index,old_index).n() == 0)
+ &&
+ ((dof_handler->get_fe()[c_index].dofs_per_cell > 0)
+ &&
+ (dof_handler->get_fe()[old_index].dofs_per_cell > 0))),
+ ExcMessage ("The interpolation between two different "
+ "elements you are trying to use here has "
+ "not been implemented for this pair of "
+ "elements!"));
+
+ if (tmp.size() > 0)
+ interpolation_hp(c_index,old_index).vmult (local_values, tmp);
else
local_values = 0;
}
LIST(GET DEAL_II_BUILD_TYPES 0 _mybuild)
MESSAGE(STATUS "Setup quick_tests in ${_mybuild} mode")
+SET(ALL_TESTS) # clean variable
+
# define a macro to set up a quick test:
MACRO(make_quicktest test_basename build_name mpi_run)
STRING(TOLOWER ${build_name} _build_lowercase)
SET(_target ${test_basename}.${_build_lowercase})
+ LIST(APPEND ALL_TESTS "${_target}")
ADD_EXECUTABLE(${_target} EXCLUDE_FROM_ALL ${test_basename}.cc)
DEAL_II_INSOURCE_SETUP_TARGET(${_target} ${build_name})
- IF(NOT ${mpi_run} EQUAL "")
- ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_target}-OK
- DEPENDS ${_target}
- COMMAND mpirun -n ${mpi_run} ./${_target} > ${CMAKE_CURRENT_BINARY_DIR}/${_target}-OK 2>&1 || (rm ${_target}-OK && exit 1)
- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
- )
+ IF("${mpi_run}" STREQUAL "")
+ SET(_command ./${_target})
ELSE()
- ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_target}-OK
+ SET(_command mpirun -n ${mpi_run} ./${_target})
+ ENDIF()
+ ADD_CUSTOM_TARGET(${_target}.run
DEPENDS ${_target}
- COMMAND ./${_target} > ${CMAKE_CURRENT_BINARY_DIR}/${_target}-OK 2>&1 || (rm ${_target}-OK && exit 1)
+ COMMAND
+ ${_command} > ${_target}-OK 2>&1
+ ||(echo "${_target}: RUN failed. Output:"
+ && cat ${_target}-OK
+ && rm ${_target}-OK
+ && exit 1)
+ COMMAND echo "${_target}: PASSED."
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
- ENDIF()
- ADD_CUSTOM_TARGET(${_target}.run
- DEPENDS ${_target}
- DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_target}-OK
- COMMAND echo "${_target}: PASSED.")
+ # this is a hack to make sure the -OK file is deleted
+ # even if compilation fails.
+ ADD_CUSTOM_TARGET(kill-${_target}-OK
+ COMMAND rm -f ${_target}-OK
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ )
+ ADD_DEPENDENCIES(${_target} kill-${_target}-OK)
ADD_TEST(NAME ${_target}
COMMAND ${CMAKE_COMMAND} -DTRGT=${_target}.run -DTEST=${_target}
ENDMACRO()
-# simple assembly/solver test. This makes sure we can compile and link correctly
+# Simple assembly/solver test. This makes sure we can compile and link correctly
# in debug and release.
FOREACH(_build ${DEAL_II_BUILD_TYPES})
make_quicktest("step" ${_build} "")
# A custom test target:
ADD_CUSTOM_TARGET(test
- COMMAND ${CMAKE_CTEST_COMMAND} --force-new-ctest-process
+ COMMAND ${CMAKE_COMMAND} -D ALL_TESTS="${ALL_TESTS}" -P ${CMAKE_CURRENT_SOURCE_DIR}/run.cmake
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
ADD_DEPENDENCIES(test build_library)
--- /dev/null
+## ---------------------------------------------------------------------
+## $Id$
+##
+## Copyright (C) 2013 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 at
+## the top level of the deal.II distribution.
+##
+## ---------------------------------------------------------------------
+
+# This file is run when "make test" is executed by the user and is
+# responsible for running the tests and printing some helpful
+# error messages.
+
+SEPARATE_ARGUMENTS(ALL_TESTS)
+
+EXECUTE_PROCESS(COMMAND ${CMAKE_CTEST_COMMAND} --force-new-ctest-process --output-on-failure -O quicktests.log RESULT_VARIABLE res_var)
+
+if(NOT "${res_var}" STREQUAL "0")
+ MESSAGE( "
+
+******************************* WARNING *******************************
+
+Some of the tests failed!
+
+Please scroll up or check the file tests/quick_tests/quicktests.log for the
+error messages. If you are unable to fix the problems, see the FAQ or write
+to the mailing list linked at http://www.dealii.org\n"
+ )
+
+ FOREACH(test ${ALL_TESTS})
+ IF (${test} MATCHES "^affinity" AND NOT EXISTS ${test}-OK)
+ MESSAGE("
+The affinity test can fail when you are linking in a library like BLAS
+which uses OpenMP. Even without calling any BLAS functions, OpenMP messes
+with the thread affinity which causes TBB to run single-threaded only. You
+can fix this by exporting OMP_NUM_THREADS=1.\n"
+ )
+ ENDIF()
+
+ IF (${test} MATCHES "^step-petsc" AND NOT EXISTS ${test}-OK)
+ MESSAGE("
+Additional information about PETSc issues is available
+at:\nhttp://www.dealii.org/developer/external-libs/petsc.html\n"
+ )
+ ENDIF()
+
+ IF (${test} MATCHES "^p4est" AND NOT EXISTS ${test}-OK)
+ MESSAGE("
+The p4est test can fail if you are running an OpenMPI version before 1.5.
+This is a known problem and the only work around is to update to a more
+recent version or use a different MPI library like MPICH.\n"
+ )
+ ENDIF()
+
+ ENDFOREACH()
+
+ENDIF()
std_cxx1x::_1),
scratch_data(), copy_data());
std::cout << "result: " << result << std::endl;
-
+
if (result != (3*3+5*5+1*1))
exit(2);
}
int main ()
{
std::cout << "TBB will use " << tbb::task_scheduler_init::default_num_threads() << " threads." << std::endl;
-
+
test1();
test2();
}
projects / dealii-svn.git / commitdiff