]> https://gitweb.dealii.org/ - dealii.git/commitdiff
MatrixFree: deprecate n_macro_cells 11183/head
authorTimo Heister <timo.heister@gmail.com>
Sat, 14 Nov 2020 03:40:05 +0000 (22:40 -0500)
committerTimo Heister <timo.heister@gmail.com>
Sat, 14 Nov 2020 03:40:05 +0000 (22:40 -0500)
For the longest time we had n_macro_cells() and n_cell_batches() return
the same thing.
While n_cell_batches() has fewer uses (27 vs 136), I find the term
"macro cell" confusing and incorrect.

31 files changed:
examples/step-37/doc/results.dox
examples/step-37/step-37.cc
examples/step-50/step-50.cc
examples/step-67/step-67.cc
include/deal.II/matrix_free/dof_info.templates.h
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/matrix_free/mapping_info.templates.h
include/deal.II/matrix_free/matrix_free.h
include/deal.II/matrix_free/operators.h
include/deal.II/multigrid/multigrid.h
include/deal.II/numerics/vector_tools_project.templates.h
source/matrix_free/task_info.cc
tests/lac/utilities_02.cc
tests/mappings/mapping_q_eulerian_08.cc
tests/matrix_free/cell_categorization.cc
tests/matrix_free/cell_categorization_02.cc
tests/matrix_free/cell_level_and_index.cc
tests/matrix_free/compress_mapping.cc
tests/matrix_free/dof_info_01.cc
tests/matrix_free/dof_info_02.cc
tests/matrix_free/jxw_values.cc
tests/matrix_free/laplace_operator_02.cc
tests/matrix_free/quadrature_points.cc
tests/matrix_free/step-37-inhomogeneous-1.cc
tests/matrix_free/step-37.cc
tests/matrix_free/step-48.cc
tests/matrix_free/step-48b.cc
tests/matrix_free/step-48c.cc
tests/matrix_free/stokes_computation.cc
tests/mpi/step-37.cc
tests/numerics/project_parallel_qpmf_common.h

index 1088e37770083a0f41bda49461d95cfaaaab7e5e..e02ffd26c1ba1dba478e3f1f2512686d16cb0259 100644 (file)
@@ -569,7 +569,7 @@ void LaplaceProblem<dim>::assemble_rhs()
   const Table<2, VectorizedArray<double>> &coefficient = system_matrix.get_coefficient();
   FEEvaluation<dim, degree_finite_element> phi(*system_matrix.get_matrix_free());
   for (unsigned int cell = 0;
-       cell < system_matrix.get_matrix_free()->n_macro_cells();
+       cell < system_matrix.get_matrix_free()->n_cell_batches();
        ++cell)
     {
       phi.reinit(cell);
@@ -656,7 +656,7 @@ void LaplaceProblem<dim>::assemble_rhs()
   FEEvaluation<dim, degree_finite_element> phi(
     *inhomogeneous_operator.get_matrix_free());
   for (unsigned int cell = 0;
-       cell < inhomogeneous_operator.get_matrix_free()->n_macro_cells();
+       cell < inhomogeneous_operator.get_matrix_free()->n_cell_batches();
        ++cell)
     {
       phi.reinit(cell);
index 663bd0f16073d00475298da85cf8759dfa484e8c..f7540785558d2b568e4cb58d8e95a2eddf8b47d0 100644 (file)
@@ -281,7 +281,7 @@ namespace Step37
   void LaplaceOperator<dim, fe_degree, number>::evaluate_coefficient(
     const Coefficient<dim> &coefficient_function)
   {
-    const unsigned int n_cells = this->data->n_macro_cells();
+    const unsigned int n_cells = this->data->n_cell_batches();
     FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(*this->data);
 
     coefficient.reinit(n_cells, phi.n_q_points);
@@ -314,7 +314,7 @@ namespace Step37
   // actually seeing a group of quadrature points of several cells as one
   // block. This is done to enable a higher degree of vectorization.  The
   // number of such "cells" or "cell batches" is stored in MatrixFree and can
-  // be queried through MatrixFree::n_macro_cells(). Compared to the deal.II
+  // be queried through MatrixFree::n_cell_batches(). Compared to the deal.II
   // cell iterators, in this class all cells are laid out in a plain array
   // with no direct knowledge of level or neighborship relations, which makes
   // it possible to index the cells by unsigned integers.
@@ -398,7 +398,7 @@ namespace Step37
 
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
       {
-        AssertDimension(coefficient.size(0), data.n_macro_cells());
+        AssertDimension(coefficient.size(0), data.n_cell_batches());
         AssertDimension(coefficient.size(1), phi.n_q_points);
 
         phi.reinit(cell);
@@ -423,7 +423,7 @@ namespace Step37
   // @code
   // src.update_ghost_values();
   // local_apply(*this->data, dst, src, std::make_pair(0U,
-  //                                                   data.n_macro_cells()));
+  //                                                   data.n_cell_batches()));
   // dst.compress(VectorOperation::add);
   // @endcode
   //
@@ -437,7 +437,7 @@ namespace Step37
   // one hand, it will split the update_ghost_values() and compress() calls in
   // a way to allow for overlapping communication and computation. The
   // local_apply function is then called with three cell ranges representing
-  // partitions of the cell range from 0 to MatrixFree::n_macro_cells(). On
+  // partitions of the cell range from 0 to MatrixFree::n_cell_batches(). On
   // the other hand, cell_loop also supports thread parallelism in which case
   // the cell ranges are split into smaller chunks and scheduled in an
   // advanced way that avoids access to the same vector entry by several
@@ -620,7 +620,7 @@ namespace Step37
 
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
       {
-        AssertDimension(coefficient.size(0), data.n_macro_cells());
+        AssertDimension(coefficient.size(0), data.n_cell_batches());
         AssertDimension(coefficient.size(1), phi.n_q_points);
 
         phi.reinit(cell);
@@ -907,7 +907,7 @@ namespace Step37
     FEEvaluation<dim, degree_finite_element> phi(
       *system_matrix.get_matrix_free());
     for (unsigned int cell = 0;
-         cell < system_matrix.get_matrix_free()->n_macro_cells();
+         cell < system_matrix.get_matrix_free()->n_cell_batches();
          ++cell)
       {
         phi.reinit(cell);
index 349b8d93a9717a62c9c47a64baef2b867635abdb..707d83e2ae1a4a9a9214f13635a9e1bf22cc96a8 100644 (file)
@@ -251,7 +251,7 @@ Coefficient<dim>::make_coefficient_table(
 
   FEEvaluation<dim, -1, 0, 1, number> fe_eval(mf_storage);
 
-  const unsigned int n_cells    = mf_storage.n_macro_cells();
+  const unsigned int n_cells    = mf_storage.n_cell_batches();
   const unsigned int n_q_points = fe_eval.n_q_points;
 
   coefficient_table->reinit(n_cells, 1);
@@ -948,7 +948,7 @@ void LaplaceProblem<dim, degree>::assemble_rhs()
     *mf_system_matrix.get_matrix_free());
 
   for (unsigned int cell = 0;
-       cell < mf_system_matrix.get_matrix_free()->n_macro_cells();
+       cell < mf_system_matrix.get_matrix_free()->n_cell_batches();
        ++cell)
     {
       phi.reinit(cell);
index d33d595ea43ae36426e670606d6cc37caf19f519..5cf30305b3272d52bb44e3fd2f4a86df71acf313 100644 (file)
@@ -1574,7 +1574,7 @@ namespace Euler_DG
     MatrixFreeOperators::CellwiseInverseMassMatrix<dim, degree, dim + 2, Number>
       inverse(phi);
     solution.zero_out_ghosts();
-    for (unsigned int cell = 0; cell < data.n_macro_cells(); ++cell)
+    for (unsigned int cell = 0; cell < data.n_cell_batches(); ++cell)
       {
         phi.reinit(cell);
         for (unsigned int q = 0; q < phi.n_q_points; ++q)
index aa71d3da0fced391650714f1d5fa6100aecff394..b34582b003433f5ba55ee3eec0cc9e8f416a4fd8 100644 (file)
@@ -1978,12 +1978,12 @@ namespace internal
 
       types::global_dof_index counter      = 0;
       const unsigned int      n_components = start_components.back();
-      const unsigned int      n_macro_cells =
+      const unsigned int      n_cell_batches =
         n_vectorization_lanes_filled[dof_access_cell].size();
-      Assert(n_macro_cells <=
+      Assert(n_cell_batches <=
                (row_starts.size() - 1) / vectorization_length / n_components,
              ExcInternalError());
-      for (unsigned int cell_no = 0; cell_no < n_macro_cells; ++cell_no)
+      for (unsigned int cell_no = 0; cell_no < n_cell_batches; ++cell_no)
         {
           // do not renumber in case we have constraints
           if (row_starts[cell_no * n_components * vectorization_length]
index f37f136841d4b23033412c5baf5398cec27a43b3..f9835136dcecd57090e92d55035dc3c2dac2a022 100644 (file)
@@ -165,8 +165,8 @@ public:
 
   /**
    * Provides a unified interface to access data in a vector of
-   * VectorizedArray fields of length MatrixFree::n_macro_cells() +
-   * MatrixFree::n_macro_ghost_cells() for both cells (plain read) and faces
+   * VectorizedArray fields of length MatrixFree::n_cell_batches() +
+   * MatrixFree::n_ghost_cell_batches() for both cells (plain read) and faces
    * (indirect addressing).
    */
   VectorizedArrayType
@@ -174,8 +174,8 @@ public:
 
   /**
    * Provides a unified interface to set data in a vector of
-   * VectorizedArray fields of length MatrixFree::n_macro_cells() +
-   * MatrixFree::n_macro_ghost_cells() for both cells (plain read) and faces
+   * VectorizedArray fields of length MatrixFree::n_cell_batches() +
+   * MatrixFree::n_ghost_cell_batches() for both cells (plain read) and faces
    * (indirect addressing).
    */
   void
index 629b1d6166e204b55b4905a2709cfc9e65f7baac..1d89993cc5ab7d29c1f725bc0f3ae2f9c90134d8 100644 (file)
@@ -1470,16 +1470,16 @@ namespace internal
       const unsigned int n_cells = cells.size();
       const unsigned int n_lanes = VectorizedArrayType::size();
       Assert(n_cells % n_lanes == 0, ExcInternalError());
-      const unsigned int n_macro_cells = n_cells / n_lanes;
-      cell_type.resize(n_macro_cells);
+      const unsigned int n_cell_batches = n_cells / n_lanes;
+      cell_type.resize(n_cell_batches);
 
-      if (n_macro_cells == 0)
+      if (n_cell_batches == 0)
         return;
 
       // Create as many chunks of cells as we have threads and spawn the work
       unsigned int work_per_chunk =
         std::max(8U,
-                 (n_macro_cells + MultithreadInfo::n_threads() - 1) /
+                 (n_cell_batches + MultithreadInfo::n_threads() - 1) /
                    MultithreadInfo::n_threads());
 
       std::vector<std::pair<
@@ -1494,7 +1494,7 @@ namespace internal
       {
         Threads::TaskGroup<>                  tasks;
         std::pair<unsigned int, unsigned int> cell_range(0U, work_per_chunk);
-        while (cell_range.first < n_macro_cells)
+        while (cell_range.first < n_cell_batches)
           {
             data_cells_local.push_back(std::make_pair(
               std::vector<
index 25ad250d0f337e8595262ef459fd5b1bf4803005..0e5461e5fd5e7e499164a3c6413e5dd547b9d469 100644 (file)
@@ -1612,13 +1612,7 @@ public:
   n_physical_cells() const;
 
   /**
-   * Return the number of cell batches that this structure works on.  The
-   * batches are formed by application of vectorization over several cells in
-   * general. The cell range in @p cell_loop runs from zero to n_cell_batches()
-   * (exclusive), so this is the appropriate size if you want to store arrays
-   * of data for all cells to be worked on. This number is approximately
-   * `n_physical_cells()/VectorizedArray::%size()` (depending on how
-   * many cell chunks that do not get filled up completely).
+   * @deprecated Use n_cell_batches() instead.
    */
   unsigned int
   n_macro_cells() const;
@@ -1630,7 +1624,7 @@ public:
    * n_cell_batches() (exclusive), so this is the appropriate size if you want
    * to store arrays of data for all cells to be worked on. This number is
    * approximately `n_physical_cells()/VectorizedArray::%size()`
-   * (depending on how many cell chunks that do not get filled up completely).
+   * (depending on how many cell batches that do not get filled up completely).
    */
   unsigned int
   n_cell_batches() const;
@@ -2344,9 +2338,9 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_faces_by_cells_boundary_id(
   const unsigned int macro_cell,
   const unsigned int face_number) const
 {
-  AssertIndexRange(macro_cell, n_macro_cells());
+  AssertIndexRange(macro_cell, n_cell_batches());
   AssertIndexRange(face_number, GeometryInfo<dim>::faces_per_cell);
-  Assert(face_info.cell_and_face_boundary_id.size(0) >= n_macro_cells(),
+  Assert(face_info.cell_and_face_boundary_id.size(0) >= n_cell_batches(),
          ExcNotInitialized());
   std::array<types::boundary_id, VectorizedArrayType::size()> result;
   result.fill(numbers::invalid_boundary_id);
index d48471dda7766515d736a38a909bdd4b5d41dec4..6b2945e16e03ba416fdd7c6b9817ce47c94e4d48 100644 (file)
@@ -853,7 +853,7 @@ namespace MatrixFreeOperators
      * coefficient = std::make_shared<Table<2, VectorizedArray<double> > >();
      * {
      *   FEEvaluation<dim,fe_degree,n_q_points_1d,1,double> fe_eval(mf_data);
-     *   const unsigned int n_cells = mf_data.n_macro_cells();
+     *   const unsigned int n_cells = mf_data.n_cell_batches();
      *   const unsigned int n_q_points = fe_eval.n_q_points;
      *   coefficient->reinit(n_cells, n_q_points);
      *   for (unsigned int cell=0; cell<n_cells; ++cell)
@@ -1274,7 +1274,7 @@ namespace MatrixFreeOperators
 
     for (unsigned int j = 0; j < selected_rows.size(); ++j)
       {
-        if (data_->n_macro_cells() > 0)
+        if (data_->n_cell_batches() > 0)
           {
             AssertDimension(level, data_->get_cell_iterator(0, 0, j)->level());
           }
index 74165f07f8402a5c455090be439c122753873757..f62db72383a8b3594a9525119adad1ec35123a56 100644 (file)
@@ -77,6 +77,10 @@ namespace mg
      * This signal is triggered before (@p before is true) and after (@p before
      * is
      * false) the call to the coarse solver on @p level.
+     *
+     * The coarse solve will be done with ``defect[leve]`` and returned in
+     * ``solution[level]``, which can be inspected by the user using this
+     * signal.
      */
     boost::signals2::signal<void(const bool before, const unsigned int level)>
       coarse_solve;
@@ -85,6 +89,9 @@ namespace mg
      * This signal is triggered before (@p before is true) and after (@p before
      * is false) the call to MGTransfer::restrict_and_add() which restricts a
      * vector from @p level to the next coarser one (@p level - 1).
+     *
+     * The vector ``defect[level-1]`` will be updated between these two
+     * triggers and can be inspected by the user using this signal.
      */
     boost::signals2::signal<void(const bool before, const unsigned int level)>
       restriction;
@@ -101,6 +108,9 @@ namespace mg
      * This signal is triggered before (@p before is true) and after (@p before
      * is false) the call to a pre-smoothing step via MGPreSmoother::apply() on
      * @p level.
+     *
+     * The smoother result will be stored in ``solution[level]`` and can be
+     * inspected by the user using this signal.
      */
     boost::signals2::signal<void(const bool before, const unsigned int level)>
       pre_smoother_step;
index 69083a0bdcab2e3319754d0fa9ac83d101355939..1a3ad6dcef8d6a4cde04dde57d82e499b615d135 100644 (file)
@@ -216,7 +216,8 @@ namespace VectorTools
         // account for inhomogeneous constraints
         inhomogeneities.update_ghost_values();
         FEEvaluation<dim, -1, 0, components, Number> phi(*matrix_free);
-        for (unsigned int cell = 0; cell < matrix_free->n_macro_cells(); ++cell)
+        for (unsigned int cell = 0; cell < matrix_free->n_cell_batches();
+             ++cell)
           {
             phi.reinit(cell);
             phi.read_dof_values_plain(inhomogeneities);
index f60266af332a55392f21ff6b03e6ea341d48f139..7f3de4fe1250c124a231a6a9fe02d21085fbb3c9 100644 (file)
@@ -1076,17 +1076,17 @@ namespace internal
       std::vector<unsigned int> &      renumbering,
       std::vector<unsigned char> &     incompletely_filled_vectorization)
     {
-      const unsigned int n_macro_cells =
+      const unsigned int n_cell_batches =
         (n_active_cells + vectorization_length - 1) / vectorization_length;
       const unsigned int n_ghost_slots =
         (n_ghost_cells + vectorization_length - 1) / vectorization_length;
-      incompletely_filled_vectorization.resize(n_macro_cells + n_ghost_slots);
-      if (n_macro_cells * vectorization_length > n_active_cells)
-        incompletely_filled_vectorization[n_macro_cells - 1] =
+      incompletely_filled_vectorization.resize(n_cell_batches + n_ghost_slots);
+      if (n_cell_batches * vectorization_length > n_active_cells)
+        incompletely_filled_vectorization[n_cell_batches - 1] =
           vectorization_length -
-          (n_macro_cells * vectorization_length - n_active_cells);
+          (n_cell_batches * vectorization_length - n_active_cells);
       if (n_ghost_slots * vectorization_length > n_ghost_cells)
-        incompletely_filled_vectorization[n_macro_cells + n_ghost_slots - 1] =
+        incompletely_filled_vectorization[n_cell_batches + n_ghost_slots - 1] =
           vectorization_length -
           (n_ghost_slots * vectorization_length - n_ghost_cells);
 
@@ -1116,13 +1116,13 @@ namespace internal
             (boundary_cells.size() + vectorization_length - 1) /
             vectorization_length;
           cell_partition_data.push_back(
-            (n_macro_cells - n_macro_boundary_cells) / 2);
+            (n_cell_batches - n_macro_boundary_cells) / 2);
           cell_partition_data.push_back(cell_partition_data[1] +
                                         n_macro_boundary_cells);
         }
       else
         AssertDimension(boundary_cells.size(), 0);
-      cell_partition_data.push_back(n_macro_cells);
+      cell_partition_data.push_back(n_cell_batches);
       cell_partition_data.push_back(cell_partition_data.back() + n_ghost_slots);
       partition_row_index.resize(n_procs > 1 ? 4 : 2);
       partition_row_index[0] = 0;
@@ -1171,8 +1171,8 @@ namespace internal
       std::vector<unsigned char> &irregular_cells,
       const bool)
     {
-      const unsigned int n_macro_cells = *(cell_partition_data.end() - 2);
-      if (n_macro_cells == 0)
+      const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
+      if (n_cell_batches == 0)
         return;
 
       Assert(vectorization_length > 0, ExcInternalError());
@@ -1238,8 +1238,8 @@ namespace internal
 
       // set the start list for each block and compute the renumbering of
       // cells
-      std::vector<unsigned int>  block_start(n_macro_cells + 1);
-      std::vector<unsigned char> irregular(n_macro_cells);
+      std::vector<unsigned int>  block_start(n_cell_batches + 1);
+      std::vector<unsigned char> irregular(n_cell_batches);
 
       unsigned int mcell_start = 0;
       block_start[0]           = 0;
@@ -1247,7 +1247,7 @@ namespace internal
         {
           block_start[block + 1] = block_start[block];
           for (unsigned int mcell = mcell_start;
-               mcell < std::min(mcell_start + block_size, n_macro_cells);
+               mcell < std::min(mcell_start + block_size, n_cell_batches);
                ++mcell)
             {
               unsigned int n_comp = (irregular_cells[mcell] > 0) ?
@@ -1261,7 +1261,7 @@ namespace internal
       counter                    = 0;
       unsigned int counter_macro = 0;
       unsigned int block_size_last =
-        n_macro_cells - block_size * (n_blocks - 1);
+        n_cell_batches - block_size * (n_blocks - 1);
       if (block_size_last == 0)
         block_size_last = block_size;
 
@@ -1290,7 +1290,7 @@ namespace internal
 
       irregular_cells.swap(irregular);
       AssertDimension(counter, n_active_cells);
-      AssertDimension(counter_macro, n_macro_cells);
+      AssertDimension(counter_macro, n_cell_batches);
 
       // check that the renumbering is one-to-one
 #ifdef DEBUG
@@ -1306,7 +1306,7 @@ namespace internal
       update_task_info(
         partition); // Actually sets too much for partition color case
 
-      AssertDimension(cell_partition_data.back(), n_macro_cells);
+      AssertDimension(cell_partition_data.back(), n_cell_batches);
     }
 
 
@@ -1319,8 +1319,8 @@ namespace internal
       std::vector<unsigned char> &     irregular_cells,
       const bool                       hp_bool)
     {
-      const unsigned int n_macro_cells = *(cell_partition_data.end() - 2);
-      if (n_macro_cells == 0)
+      const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
+      if (n_cell_batches == 0)
         return;
 
       Assert(vectorization_length > 0, ExcInternalError());
@@ -1435,8 +1435,8 @@ namespace internal
         {
           // set the start list for each block and compute the renumbering of
           // cells
-          std::vector<unsigned int>  block_start(n_macro_cells + 1);
-          std::vector<unsigned char> irregular(n_macro_cells);
+          std::vector<unsigned int>  block_start(n_cell_batches + 1);
+          std::vector<unsigned char> irregular(n_cell_batches);
 
           unsigned int counter     = 0;
           unsigned int mcell_start = 0;
@@ -1445,7 +1445,7 @@ namespace internal
             {
               block_start[block + 1] = block_start[block];
               for (unsigned int mcell = mcell_start;
-                   mcell < std::min(mcell_start + block_size, n_macro_cells);
+                   mcell < std::min(mcell_start + block_size, n_cell_batches);
                    ++mcell)
                 {
                   unsigned int n_comp = (irregular_cells[mcell] > 0) ?
@@ -1459,7 +1459,7 @@ namespace internal
           counter                    = 0;
           unsigned int counter_macro = 0;
           unsigned int block_size_last =
-            n_macro_cells - block_size * (n_blocks - 1);
+            n_cell_batches - block_size * (n_blocks - 1);
           if (block_size_last == 0)
             block_size_last = block_size;
 
@@ -1488,7 +1488,7 @@ namespace internal
 
           irregular_cells.swap(irregular);
           AssertDimension(counter, n_active_cells);
-          AssertDimension(counter_macro, n_macro_cells);
+          AssertDimension(counter_macro, n_cell_batches);
           // check that the renumbering is one-to-one
 #ifdef DEBUG
           {
@@ -1514,8 +1514,8 @@ namespace internal
       std::vector<unsigned char> &     irregular_cells,
       const bool                       hp_bool)
     {
-      const unsigned int n_macro_cells = *(cell_partition_data.end() - 2);
-      if (n_macro_cells == 0)
+      const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
+      if (n_cell_batches == 0)
         return;
 
       const unsigned int cluster_size = block_size * vectorization_length;
@@ -1523,7 +1523,7 @@ namespace internal
       // Create cell-block  partitioning.
 
       // For each block of cells, this variable saves to which partitions the
-      // block belongs. Initialize all to n_macro_cells to mark them as not
+      // block belongs. Initialize all to n_cell_batches to mark them as not
       // yet assigned a partition.
       std::vector<unsigned int> cell_partition(n_active_cells,
                                                numbers::invalid_unsigned_int);
@@ -1631,9 +1631,9 @@ namespace internal
       std::vector<unsigned int> &      partition_partition_list,
       std::vector<unsigned char> &     irregular_cells)
     {
-      const unsigned int n_macro_cells = *(cell_partition_data.end() - 2);
+      const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
       const unsigned int n_ghost_slots =
-        *(cell_partition_data.end() - 1) - n_macro_cells;
+        *(cell_partition_data.end() - 1) - n_cell_batches;
 
       // List of cells in previous partition
       std::vector<unsigned int> neighbor_list;
@@ -1658,7 +1658,7 @@ namespace internal
         // Create partitioning within partitions.
 
         // For each block of cells, this variable saves to which partitions
-        // the block belongs. Initialize all to n_macro_cells to mark them as
+        // the block belongs. Initialize all to n_cell_batches to mark them as
         // not yet assigned a partition.
         std::vector<unsigned int> cell_partition_l2(
           n_active_cells, numbers::invalid_unsigned_int);
@@ -1948,8 +1948,8 @@ namespace internal
       const std::vector<unsigned int> &partition_size,
       std::vector<unsigned int> &      partition_color_list)
     {
-      const unsigned int n_macro_cells = *(cell_partition_data.end() - 2);
-      std::vector<unsigned int> cell_color(n_blocks, n_macro_cells);
+      const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
+      std::vector<unsigned int> cell_color(n_blocks, n_cell_batches);
       std::vector<bool>         color_finder;
 
       partition_row_index.resize(partition + 1);
@@ -2025,7 +2025,7 @@ namespace internal
 
     {
       // For each block of cells, this variable saves to which partitions the
-      // block belongs. Initialize all to n_macro_cells to mark them as not
+      // block belongs. Initialize all to n_cell_batches to mark them as not
       // yet assigned a partition.
       // std::vector<unsigned int> cell_partition (n_active_cells,
       //                                          numbers::invalid_unsigned_int);
@@ -2050,11 +2050,11 @@ namespace internal
             (cell_partition_data[2] - cell_partition_data[1]) :
           0;
 
-      const unsigned int n_macro_cells = *(cell_partition_data.end() - 2);
-      if (n_macro_cells == 0)
+      const unsigned int n_cell_batches = *(cell_partition_data.end() - 2);
+      if (n_cell_batches == 0)
         return;
       if (scheme == color)
-        start_nonboundary = n_macro_cells;
+        start_nonboundary = n_cell_batches;
       if (scheme == partition_color ||
           scheme == color) // blocking_connectivity == true
         start_nonboundary = ((start_nonboundary + block_size - 1) / block_size);
index 65ec348669ff8eaaafcf7a04d1b4ad8b3c0f8593..00d475b1337c9f9d5e50dfc9d00cd6fb1c416f0e 100644 (file)
@@ -141,7 +141,7 @@ test()
     mf_data->initialize_dof_vector(inv_mass_matrix);
     FEEvaluation<dim, fe_degree> fe_eval(*mf_data);
     const unsigned int           n_q_points = fe_eval.n_q_points;
-    for (unsigned int cell = 0; cell < mf_data->n_macro_cells(); ++cell)
+    for (unsigned int cell = 0; cell < mf_data->n_cell_batches(); ++cell)
       {
         fe_eval.reinit(cell);
         for (unsigned int q = 0; q < n_q_points; ++q)
index 228db4d7eee6c51a5639b589c1d21c8aa660de56..0fc87e44fb4a15c96ed93d62e91999723e1c97a8 100644 (file)
@@ -237,8 +237,8 @@ test(const unsigned int n_ref = 0)
         matrix_free_euler);
       FEEvaluation<dim, fe_degree, n_q_points, 1, NumberType> fe_eval(
         matrix_free);
-      const unsigned int n_cells = matrix_free_euler.n_macro_cells();
-      Assert(matrix_free_euler.n_macro_cells() == matrix_free.n_macro_cells(),
+      const unsigned int n_cells = matrix_free_euler.n_cell_batches();
+      Assert(matrix_free_euler.n_cell_batches() == matrix_free.n_cell_batches(),
              ExcInternalError());
       const unsigned int nqp = fe_eval.n_q_points;
       for (unsigned int cell = 0; cell < n_cells; ++cell)
@@ -315,8 +315,8 @@ test(const unsigned int n_ref = 0)
           mg_level_euler);
         FEEvaluation<dim, fe_degree, n_q_points, 1, NumberType> fe_eval(
           mg_level);
-        const unsigned int n_cells = mg_level_euler.n_macro_cells();
-        Assert(mg_level_euler.n_macro_cells() == mg_level.n_macro_cells(),
+        const unsigned int n_cells = mg_level_euler.n_cell_batches();
+        Assert(mg_level_euler.n_cell_batches() == mg_level.n_cell_batches(),
                ExcInternalError());
         const unsigned int nqp = fe_eval.n_q_points;
         for (unsigned int cell = 0; cell < n_cells; ++cell)
index df453acc43fd9be60e0948786303af2b1eba916d..7e03e5652201304e9dda60bf4ebf71fe233ab790 100644 (file)
@@ -88,8 +88,9 @@ test()
   data.cell_vectorization_categories_strict = false;
   mf_data.reinit(dof, constraints, QGauss<1>(2), data);
 
-  deallog << "Number of cell batches: " << mf_data.n_macro_cells() << std::endl;
-  for (unsigned int i = 0; i < mf_data.n_macro_cells(); ++i)
+  deallog << "Number of cell batches: " << mf_data.n_cell_batches()
+          << std::endl;
+  for (unsigned int i = 0; i < mf_data.n_cell_batches(); ++i)
     for (unsigned int c = 0; c < mf_data.n_components_filled(i); ++c)
       deallog << mf_data.get_cell_iterator(i, c)->id() << " with "
               << mf_data.get_cell_category(i) << std::endl;
@@ -97,8 +98,9 @@ test()
 
   data.cell_vectorization_categories_strict = true;
   mf_data.reinit(dof, constraints, QGauss<1>(2), data);
-  deallog << "Number of cell batches: " << mf_data.n_macro_cells() << std::endl;
-  for (unsigned int i = 0; i < mf_data.n_macro_cells(); ++i)
+  deallog << "Number of cell batches: " << mf_data.n_cell_batches()
+          << std::endl;
+  for (unsigned int i = 0; i < mf_data.n_cell_batches(); ++i)
     for (unsigned int c = 0; c < mf_data.n_components_filled(i); ++c)
       deallog << mf_data.get_cell_iterator(i, c)->id() << " with "
               << mf_data.get_cell_category(i) << std::endl;
@@ -112,8 +114,9 @@ test()
 
   data.cell_vectorization_categories_strict = false;
   mf_data.reinit(dof, constraints, QGauss<1>(2), data);
-  deallog << "Number of cell batches: " << mf_data.n_macro_cells() << std::endl;
-  for (unsigned int i = 0; i < mf_data.n_macro_cells(); ++i)
+  deallog << "Number of cell batches: " << mf_data.n_cell_batches()
+          << std::endl;
+  for (unsigned int i = 0; i < mf_data.n_cell_batches(); ++i)
     for (unsigned int c = 0; c < mf_data.n_components_filled(i); ++c)
       deallog << mf_data.get_cell_iterator(i, c)->id() << " with "
               << mf_data.get_cell_category(i) << std::endl;
index ddbbbf66e29799d2864e47bcf5e7877ba7eb4ae0..f99a38a3ac51a6c51987ac33eefab9e09a43e1e6 100644 (file)
@@ -159,7 +159,7 @@ test()
                                 mg_additional_data[level]);
     }
 
-  for (unsigned int i = 0; i < mf_data.n_macro_cells(); ++i)
+  for (unsigned int i = 0; i < mf_data.n_cell_batches(); ++i)
     {
       const unsigned int m_id = mf_data.get_cell_iterator(i, 0)->material_id();
       for (unsigned int c = 0; c < mf_data.n_components_filled(i); ++c)
@@ -173,7 +173,7 @@ test()
   for (unsigned int level = 0; level <= max_level; ++level)
     {
       const auto &level_data = mg_mf_data[level];
-      for (unsigned int i = 0; i < level_data->n_macro_cells(); ++i)
+      for (unsigned int i = 0; i < level_data->n_cell_batches(); ++i)
         {
           const unsigned int m_id =
             level_data->get_cell_iterator(i, 0)->material_id();
index 4cd6959217903647036e8ec756259beb34641cd1..a025b9f476651862fc95c394a90f9fa1415a1744 100644 (file)
@@ -42,7 +42,7 @@ template <int dim, typename number>
 void
 compare_indices(const MatrixFree<dim, number> *mf_data)
 {
-  const unsigned int n_batches = mf_data->n_macro_cells();
+  const unsigned int n_batches = mf_data->n_cell_batches();
   for (unsigned int batch_no = 0; batch_no < n_batches; ++batch_no)
     {
       const unsigned int n_lanes_filled =
index 33627cfe17c244afe8f1e3a71242b9d67b158b79..dd120c0be392423a97ddd3fecadda19e730b6b3a 100644 (file)
@@ -82,15 +82,15 @@ test()
   data.tasks_parallel_scheme = MatrixFree<dim>::AdditionalData::none;
   mf.reinit(dof, constraints, quad, data);
 
-  const unsigned int        n_macro_cells = mf.n_macro_cells();
+  const unsigned int        n_cell_batches = mf.n_cell_batches();
   std::vector<unsigned int> n_cell_types(4, 0);
-  for (unsigned int i = 0; i < n_macro_cells; ++i)
+  for (unsigned int i = 0; i < n_cell_batches; ++i)
     n_cell_types[mf.get_mapping_info().get_cell_type(i)]++;
 
   // should do at least some compression
   Assert(n_cell_types[0] + n_cell_types[1] > 0, ExcInternalError());
   Assert(mf.get_mapping_info().cell_data[0].jacobians[0].size() <
-           (n_cell_types[3] * quad.size() + n_macro_cells - n_cell_types[3]),
+           (n_cell_types[3] * quad.size() + n_cell_batches - n_cell_types[3]),
          ExcInternalError());
   deallog << "OK" << std::endl;
 }
@@ -119,15 +119,15 @@ test_cube()
   data.tasks_parallel_scheme = MatrixFree<dim>::AdditionalData::none;
   mf.reinit(dof, constraints, quad, data);
 
-  const unsigned int        n_macro_cells = mf.n_macro_cells();
+  const unsigned int        n_cell_batches = mf.n_cell_batches();
   std::vector<unsigned int> n_cell_types(4, 0);
-  for (unsigned int i = 0; i < n_macro_cells; ++i)
+  for (unsigned int i = 0; i < n_cell_batches; ++i)
     n_cell_types[mf.get_mapping_info().get_cell_type(i)]++;
 
   // should have one Cartesian cell and no other cell type
-  AssertDimension(n_cell_types[0], n_macro_cells);
+  AssertDimension(n_cell_types[0], n_cell_batches);
   AssertDimension(mf.get_mapping_info().cell_data[0].jacobians[0].size(), 2);
-  Assert(n_macro_cells > 1, ExcInternalError());
+  Assert(n_cell_batches > 1, ExcInternalError());
   deallog << "OK" << std::endl;
 }
 
@@ -162,16 +162,16 @@ test_parallelogram()
   data.tasks_parallel_scheme = MatrixFree<dim>::AdditionalData::none;
   mf.reinit(dof, constraints, quad, data);
 
-  const unsigned int        n_macro_cells = mf.n_macro_cells();
+  const unsigned int        n_cell_batches = mf.n_cell_batches();
   std::vector<unsigned int> n_cell_types(4, 0);
-  for (unsigned int i = 0; i < n_macro_cells; ++i)
+  for (unsigned int i = 0; i < n_cell_batches; ++i)
     n_cell_types[mf.get_mapping_info().get_cell_type(i)]++;
 
   // should have one affine cell and no other
   // cell type
-  AssertDimension(n_cell_types[1], n_macro_cells);
+  AssertDimension(n_cell_types[1], n_cell_batches);
   AssertDimension(mf.get_mapping_info().cell_data[0].jacobians[0].size(), 2);
-  Assert(n_macro_cells > 1, ExcInternalError());
+  Assert(n_cell_batches > 1, ExcInternalError());
   deallog << "OK" << std::endl;
 }
 
@@ -236,16 +236,16 @@ test_deformed_cube()
     update_gradients | update_normal_vectors;
 
   mf.reinit(dof, constraints, quad, data);
-  const unsigned int n_macro_cells = mf.n_macro_cells();
-  Assert(n_macro_cells > 1, ExcInternalError());
+  const unsigned int n_cell_batches = mf.n_cell_batches();
+  Assert(n_cell_batches > 1, ExcInternalError());
 
   {
     std::vector<unsigned int> n_cell_types(4, 0);
-    for (unsigned int i = 0; i < n_macro_cells; ++i)
+    for (unsigned int i = 0; i < n_cell_batches; ++i)
       n_cell_types[mf.get_mapping_info().get_cell_type(i)]++;
 
     // should have all Cartesian type and no other cell type
-    AssertDimension(n_cell_types[0], n_macro_cells);
+    AssertDimension(n_cell_types[0], n_cell_batches);
 
     // should have as many different Jacobians as we have cell batches in x
     // direction; as the mesh is a cube, we can easily calculate it
@@ -260,11 +260,11 @@ test_deformed_cube()
     mf.reinit(mapping, dof, constraints, quad, data);
 
     std::vector<unsigned int> n_cell_types(4, 0);
-    for (unsigned int i = 0; i < n_macro_cells; ++i)
+    for (unsigned int i = 0; i < n_cell_batches; ++i)
       n_cell_types[mf.get_mapping_info().get_cell_type(i)]++;
 
     // should have all general type and no other cell type
-    AssertDimension(n_cell_types[3], n_macro_cells);
+    AssertDimension(n_cell_types[3], n_cell_batches);
 
     // should have as many different Jacobians as we have cell batches in x
     // direction times the number of quadrature points; as the mesh is a cube,
index 0aa6bfa60a271b746ce5992fe3c1ee632ebdb5dd..271b8dbc3a53df4e36bd42a3646c7dbf98a86081 100644 (file)
@@ -97,7 +97,7 @@ test(const bool adaptive_ref = true)
     mf_data->reinit(dof, constraints, quad, data);
   }
 
-  const unsigned int     n_cells         = mf_data->n_macro_cells();
+  const unsigned int     n_cells         = mf_data->n_cell_batches();
   const auto &           dof_info        = mf_data->get_dof_info();
   constexpr unsigned int n_vectorization = VectorizedArray<number>::size();
 
index f12532947a2347cf04819935cef7e847b9ede996..e7d523dfb796f393c2cbcbf74875ab3b31ae81d8 100644 (file)
@@ -99,7 +99,7 @@ test(const bool adaptive_ref = true)
     mf_data->reinit(dof, constraints, quad, data);
   }
 
-  const unsigned int     n_cells         = mf_data->n_macro_cells();
+  const unsigned int     n_cells         = mf_data->n_cell_batches();
   const auto &           dof_info        = mf_data->get_dof_info();
   constexpr unsigned int n_vectorization = VectorizedArray<number>::size();
 
index 3296ff034d5c299ec9ab2a1b5b05d85f00d84215..7788cfdc7501c89fea2e5b05b579f62b2aa75469 100644 (file)
@@ -79,7 +79,7 @@ test()
   QGauss<dim>          quad(2);
   FEValues<dim>        fe_values(fe, quad, update_JxW_values);
   FEEvaluation<dim, 1> fe_eval(mf_data);
-  for (unsigned int cell = 0; cell < mf_data.n_macro_cells(); ++cell)
+  for (unsigned int cell = 0; cell < mf_data.n_cell_batches(); ++cell)
     {
       fe_eval.reinit(cell);
       for (unsigned int v = 0; v < mf_data.n_components_filled(cell); ++v)
index 903110315bfaaa599951ad03ca67e78cb5e49425..a69c57974d051244b26a8520751b90b157c477af 100644 (file)
@@ -163,7 +163,7 @@ test()
   {
     FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> fe_eval(*mf_data);
 
-    const unsigned int n_cells    = mf_data->n_macro_cells();
+    const unsigned int n_cells    = mf_data->n_cell_batches();
     const unsigned int n_q_points = fe_eval.n_q_points;
 
     coefficient->reinit(n_cells, n_q_points);
index 7525797e4521348d4c325bd1cf411dcc459affbf..7bff563c64e49859f518ba30fc6aee978765269b 100644 (file)
@@ -83,7 +83,7 @@ test()
   }
 
   double                       error_points = 0, abs_points = 0;
-  const unsigned int           n_cells = mf_data.n_macro_cells();
+  const unsigned int           n_cells = mf_data.n_cell_batches();
   FEEvaluation<dim, fe_degree> fe_eval(mf_data);
   FEValues<dim>                fe_values(mapping,
                           fe,
index 94ce0b8505ec8de61e499f06d1d813d1cb46d444..31361fd8e1049ce92542a08f0349df9e4ad6fa49 100644 (file)
@@ -211,7 +211,7 @@ namespace Step37
   LaplaceOperator<dim, fe_degree, number>::evaluate_coefficient(
     const Coefficient<dim> &coefficient_function)
   {
-    const unsigned int n_cells = this->data->n_macro_cells();
+    const unsigned int n_cells = this->data->n_cell_batches();
     FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(*this->data);
 
     coefficient.reinit(n_cells, phi.n_q_points);
@@ -238,7 +238,7 @@ namespace Step37
 
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
       {
-        AssertDimension(coefficient.size(0), data.n_macro_cells());
+        AssertDimension(coefficient.size(0), data.n_cell_batches());
         AssertDimension(coefficient.size(1), phi.n_q_points);
 
         phi.reinit(cell);
@@ -307,7 +307,7 @@ namespace Step37
 
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
       {
-        AssertDimension(coefficient.size(0), data.n_macro_cells());
+        AssertDimension(coefficient.size(0), data.n_cell_batches());
         AssertDimension(coefficient.size(1), phi.n_q_points);
 
         phi.reinit(cell);
@@ -490,7 +490,7 @@ namespace Step37
     FEEvaluation<dim, degree_finite_element> phi(
       *system_matrix.get_matrix_free());
     for (unsigned int cell = 0;
-         cell < system_matrix.get_matrix_free()->n_macro_cells();
+         cell < system_matrix.get_matrix_free()->n_cell_batches();
          ++cell)
       {
         phi.reinit(cell);
index ffbe8b5aa406b62de23235d0b42428d085ab295b..e1c83a5b852c085e5499a4a5aac243ee04505088 100644 (file)
@@ -233,7 +233,7 @@ namespace Step37
   LaplaceOperator<dim, fe_degree, number>::evaluate_coefficient(
     const Coefficient<dim> &coefficient_function)
   {
-    const unsigned int n_cells = data.n_macro_cells();
+    const unsigned int n_cells = data.n_cell_batches();
     FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(data);
     coefficient.resize(n_cells * phi.n_q_points);
     for (unsigned int cell = 0; cell < n_cells; ++cell)
@@ -256,7 +256,7 @@ namespace Step37
     const std::pair<unsigned int, unsigned int> &cell_range) const
   {
     FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(data);
-    AssertDimension(coefficient.size(), data.n_macro_cells() * phi.n_q_points);
+    AssertDimension(coefficient.size(), data.n_cell_batches() * phi.n_q_points);
 
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
       {
index 82e70963052d06038a866fc9f6e129a3ffa2d091..c23a8a321d5403eb3c31909e68188aa6557753cd 100644 (file)
@@ -97,7 +97,7 @@ namespace Step48
     FEEvaluation<dim, -1> fe_eval(data);
     const unsigned int    n_q_points = fe_eval.n_q_points;
 
-    for (unsigned int cell = 0; cell < data.n_macro_cells(); ++cell)
+    for (unsigned int cell = 0; cell < data.n_cell_batches(); ++cell)
       {
         fe_eval.reinit(cell);
         for (unsigned int q = 0; q < n_q_points; ++q)
index a1fa6965fc35d2f972ce84d87f9864e58884a3f7..549d8b0cf8fab8c3078a66d62bcb65b4324b3fdc 100644 (file)
@@ -91,7 +91,7 @@ namespace Step48
     FEEvaluation<dim, -1> fe_eval(data);
     const unsigned int    n_q_points = fe_eval.n_q_points;
 
-    for (unsigned int cell = 0; cell < data.n_macro_cells(); ++cell)
+    for (unsigned int cell = 0; cell < data.n_cell_batches(); ++cell)
       {
         fe_eval.reinit(cell);
         for (unsigned int q = 0; q < n_q_points; ++q)
index 8be0462527a842e6c8d275717c7fc75ad4afd3db..f3b3e0318cd89333a98be94482480fe9b00f4ac0 100644 (file)
@@ -97,7 +97,7 @@ namespace Step48
     FEEvaluation<dim, -1> fe_eval(data);
     const unsigned int    n_q_points = fe_eval.n_q_points;
 
-    for (unsigned int cell = 0; cell < data.n_macro_cells(); ++cell)
+    for (unsigned int cell = 0; cell < data.n_cell_batches(); ++cell)
       {
         fe_eval.reinit(cell);
         for (unsigned int q = 0; q < n_q_points; ++q)
index 93d381fec279e86684e707ed4e72776f13b4acc0..fd119f2df3e27192a59d474334011b5084f0c3e0 100644 (file)
@@ -474,7 +474,7 @@ namespace StokesClass
   StokesOperator<dim, degree_v, number>::evaluate_2_x_viscosity(
     const Viscosity<dim> &viscosity_function)
   {
-    const unsigned int n_cells = this->data->n_macro_cells();
+    const unsigned int n_cells = this->data->n_cell_batches();
     FEEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(*this->data,
                                                                     0);
     viscosity_x_2.reinit(n_cells, velocity.n_q_points);
@@ -609,7 +609,7 @@ namespace StokesClass
   MassMatrixOperator<dim, degree_p, number>::evaluate_1_over_viscosity(
     const Viscosity<dim> &viscosity_function)
   {
-    const unsigned int n_cells = this->data->n_macro_cells();
+    const unsigned int n_cells = this->data->n_cell_batches();
     FEEvaluation<dim, degree_p, degree_p + 2, 1, number> pressure(*this->data,
                                                                   0);
     one_over_viscosity.reinit(n_cells, pressure.n_q_points);
@@ -643,7 +643,7 @@ namespace StokesClass
 
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
       {
-        AssertDimension(one_over_viscosity.size(0), data.n_macro_cells());
+        AssertDimension(one_over_viscosity.size(0), data.n_cell_batches());
         AssertDimension(one_over_viscosity.size(1), pressure.n_q_points);
 
         pressure.reinit(cell);
@@ -787,7 +787,7 @@ namespace StokesClass
   ABlockOperator<dim, degree_v, number>::evaluate_2_x_viscosity(
     const Viscosity<dim> &viscosity_function)
   {
-    const unsigned int n_cells = this->data->n_macro_cells();
+    const unsigned int n_cells = this->data->n_cell_batches();
     FEEvaluation<dim, degree_v, degree_v + 1, dim, number> velocity(*this->data,
                                                                     0);
     viscosity_x_2.reinit(n_cells, velocity.n_q_points);
@@ -823,7 +823,7 @@ namespace StokesClass
 
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
       {
-        AssertDimension(viscosity_x_2.size(0), data.n_macro_cells());
+        AssertDimension(viscosity_x_2.size(0), data.n_cell_batches());
         AssertDimension(viscosity_x_2.size(1), velocity.n_q_points);
 
         velocity.reinit(cell);
@@ -1210,7 +1210,7 @@ namespace StokesClass
       pressure(*stokes_matrix.get_matrix_free(), 1);
 
     for (unsigned int cell = 0;
-         cell < stokes_matrix.get_matrix_free()->n_macro_cells();
+         cell < stokes_matrix.get_matrix_free()->n_cell_batches();
          ++cell)
       {
         velocity.reinit(cell);
index fca726b5717f6661ca2d8f4bb7061ea58e3ac6f4..623fc01e6a0065f50b9051099fdf9ad59493b383 100644 (file)
@@ -351,7 +351,7 @@ namespace Step37
     FEEvaluation<dim, degree_finite_element> phi(
       *system_matrix.get_matrix_free());
     for (unsigned int cell = 0;
-         cell < system_matrix.get_matrix_free()->n_macro_cells();
+         cell < system_matrix.get_matrix_free()->n_cell_batches();
          ++cell)
       {
         phi.reinit(cell);
index 4c9cd20b537f1537f1116b94d4f10e8cda951e1e..966597fba33694e457687e813d5b4e3243283de4 100644 (file)
@@ -159,7 +159,7 @@ do_project(const parallel::distributed::Triangulation<dim> &triangulation,
       {
         FEEvaluation<dim, fe_degree, n_q_points_1d, 1, double> fe_eval(
           *data, fe_index);
-        const unsigned int n_cells    = data->n_macro_cells();
+        const unsigned int n_cells    = data->n_cell_batches();
         const unsigned int n_q_points = fe_eval.n_q_points;
 
         qp_data.reinit(n_cells, n_q_points);

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.