From: bangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Date: Tue, 9 Mar 2010 15:43:54 +0000 (+0000)
Subject: Minor whitespace changes.
X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=5a5f5151dae68f2eec5ad9c9acdfac53e72367c5;p=dealii-svn.git

Minor whitespace changes.


git-svn-id: https://svn.dealii.org/trunk@20761 0785d39b-7218-0410-832d-ea1e28bc413d
---

diff --git a/deal.II/deal.II/source/numerics/matrices.cc b/deal.II/deal.II/source/numerics/matrices.cc
index 5b724676d0..2331b64c39 100644
--- a/deal.II/deal.II/source/numerics/matrices.cc
+++ b/deal.II/deal.II/source/numerics/matrices.cc
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by the deal.II authors
+//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -102,7 +102,7 @@ namespace internal
 			  rhs_function (rhs_function),
 			  update_flags (update_flags)
 	    {}
-	
+
 	  Scratch (const Scratch &data)
 			  :
 			  fe_collection (data.fe_collection),
@@ -120,13 +120,13 @@ namespace internal
 			  rhs_function (data.rhs_function),
 			  update_flags (data.update_flags)
 	    {}
-	
+
 	  const ::dealii::hp::FECollection<dim,spacedim>      fe_collection;
 	  const ::dealii::hp::QCollection<dim>                quadrature_collection;
 	  const ::dealii::hp::MappingCollection<dim,spacedim> mapping_collection;
-	
+
 	  ::dealii::hp::FEValues<dim,spacedim> x_fe_values;
-	
+
 	  std::vector<double>                  coefficient_values;
 	  std::vector<dealii::Vector<double> > coefficient_vector_values;
 	  std::vector<double>                  rhs_values;
@@ -147,11 +147,8 @@ namespace internal
 	  FullMatrix<double>        cell_matrix;
 	  dealii::Vector<double>    cell_rhs;
       };
-      
-
-      
     }
-    
+
 
     template <int dim,
 	      int spacedim,
@@ -162,7 +159,7 @@ namespace internal
     {
       data.x_fe_values.reinit (cell);
       const FEValues<dim,spacedim> &fe_values = data.x_fe_values.get_present_fe_values ();
-      
+
       const unsigned int dofs_per_cell = fe_values.dofs_per_cell,
 			 n_q_points    = fe_values.n_quadrature_points;
       const FiniteElement<dim,spacedim> &fe  = fe_values.get_fe();
@@ -179,7 +176,7 @@ namespace internal
 
       copy_data.cell_matrix.reinit (dofs_per_cell, dofs_per_cell);
       copy_data.cell_rhs.reinit (dofs_per_cell);
-      
+
       copy_data.dof_indices.resize (dofs_per_cell);
       cell->get_dof_indices (copy_data.dof_indices);
 
@@ -194,7 +191,7 @@ namespace internal
 	    }
 	  else
 	    {
-	      data.rhs_vector_values.resize (n_q_points, 
+	      data.rhs_vector_values.resize (n_q_points,
 					     dealii::Vector<double>(n_components));
 	      data.rhs_function->vector_value_list (fe_values.get_quadrature_points(),
 						    data.rhs_vector_values);
@@ -212,7 +209,7 @@ namespace internal
 	    }
 	  else
 	    {
-	      data.coefficient_vector_values.resize (n_q_points, 
+	      data.coefficient_vector_values.resize (n_q_points,
 						     dealii::Vector<double>(n_components));
 	      data.coefficient->vector_value_list (fe_values.get_quadrature_points(),
 						   data.coefficient_vector_values);
@@ -245,16 +242,16 @@ namespace internal
 		    {
 		      if (data.coefficient->n_components==1)
 			for (unsigned int point=0; point<n_q_points; ++point)
-			  add_data += (phi_i[point] * phi_j[point] * JxW[point] * 
+			  add_data += (phi_i[point] * phi_j[point] * JxW[point] *
 				       data.coefficient_values[point]);
 		      else
 			for (unsigned int point=0; point<n_q_points; ++point)
-			  add_data += (phi_i[point] * phi_j[point] * JxW[point] * 
+			  add_data += (phi_i[point] * phi_j[point] * JxW[point] *
 				       data.coefficient_vector_values[point](component_i));
 		    }
 		  else
 		    for (unsigned int point=0; point<n_q_points; ++point)
-		      add_data += phi_i[point] * phi_j[point] * JxW[point]; 
+		      add_data += phi_i[point] * phi_j[point] * JxW[point];
 
 				   // this is even ok for i==j, since then
 				   // we just write the same value twice.
@@ -293,13 +290,13 @@ namespace internal
 			    for (unsigned int point=0; point<n_q_points; ++point)
 			      add_data += (fe_values.shape_value_component(i,point,comp_i) *
 					   fe_values.shape_value_component(j,point,comp_i) *
-					   JxW[point] * 
+					   JxW[point] *
 					   data.coefficient_values[point]);
 			  else
 			    for (unsigned int point=0; point<n_q_points; ++point)
 			      add_data += (fe_values.shape_value_component(i,point,comp_i) *
 					   fe_values.shape_value_component(j,point,comp_i) *
-					   JxW[point] * 
+					   JxW[point] *
 					   data.coefficient_vector_values[point](comp_i));
 			}
 		      else
@@ -311,20 +308,20 @@ namespace internal
 		copy_data.cell_matrix(i,j) = add_data;
 		copy_data.cell_matrix(j,i) = add_data;
 	      }
-	      
+
 	    if (use_rhs_function)
 	      {
 		add_data = 0;
-		for (unsigned int comp_i = 0; comp_i < n_components; ++comp_i) 
+		for (unsigned int comp_i = 0; comp_i < n_components; ++comp_i)
 		  if (fe.get_nonzero_components(i)[comp_i])
 		    {
 		      if (data.rhs_function->n_components==1)
 			for (unsigned int point=0; point<n_q_points; ++point)
-			  add_data += fe_values.shape_value_component(i,point,comp_i) * 
+			  add_data += fe_values.shape_value_component(i,point,comp_i) *
 			              JxW[point] * data.rhs_values[point];
 		      else
 			for (unsigned int point=0; point<n_q_points; ++point)
-			  add_data += fe_values.shape_value_component(i,point,comp_i) * 
+			  add_data += fe_values.shape_value_component(i,point,comp_i) *
 			              JxW[point] * data.rhs_vector_values[point](comp_i);
 		    }
 		copy_data.cell_rhs(i) = add_data;
@@ -342,7 +339,7 @@ namespace internal
 			    internal::MatrixCreator::AssemblerData::CopyData              &copy_data)
     {
       data.x_fe_values.reinit (cell);
-      const FEValues<dim,spacedim> &fe_values = data.x_fe_values.get_present_fe_values ();      
+      const FEValues<dim,spacedim> &fe_values = data.x_fe_values.get_present_fe_values ();
 
       const unsigned int dofs_per_cell = fe_values.dofs_per_cell,
 			 n_q_points    = fe_values.n_quadrature_points;
@@ -375,7 +372,7 @@ namespace internal
 	    }
 	  else
 	    {
-	      data.rhs_vector_values.resize (n_q_points, 
+	      data.rhs_vector_values.resize (n_q_points,
 					     dealii::Vector<double>(n_components));
 	      data.rhs_function->vector_value_list (fe_values.get_quadrature_points(),
 						    data.rhs_vector_values);
@@ -393,14 +390,14 @@ namespace internal
 	    }
 	  else
 	    {
-	      data.coefficient_vector_values.resize (n_q_points, 
+	      data.coefficient_vector_values.resize (n_q_points,
 						     dealii::Vector<double>(n_components));
 	      data.coefficient->vector_value_list (fe_values.get_quadrature_points(),
 						   data.coefficient_vector_values);
 	    }
 	}
 
-      
+
       const std::vector<double> & JxW = fe_values.get_JxW_values();
       double add_data;
       for (unsigned int i=0; i<dofs_per_cell; ++i)
@@ -408,7 +405,7 @@ namespace internal
 	  {
 	    const unsigned int component_i =
 	      fe.system_to_component_index(i).first;
-	    const Tensor<1,spacedim> * grad_phi_i = 
+	    const Tensor<1,spacedim> * grad_phi_i =
 	      &fe_values.shape_grad(i,0);
 
 				   // can use symmetry
@@ -417,26 +414,26 @@ namespace internal
 		  (fe.system_to_component_index(j).first ==
 		   component_i))
 		{
-		  const Tensor<1,spacedim> * grad_phi_j = 
+		  const Tensor<1,spacedim> * grad_phi_j =
 		    & fe_values.shape_grad(j,0);
 		  add_data = 0;
 		  if (use_coefficient)
 		    {
 		      if (data.coefficient->n_components==1)
 			for (unsigned int point=0; point<n_q_points; ++point)
-			  add_data += ((grad_phi_i[point]*grad_phi_j[point]) * 
-				       JxW[point] * 
+			  add_data += ((grad_phi_i[point]*grad_phi_j[point]) *
+				       JxW[point] *
 				       data.coefficient_values[point]);
 		      else
 			for (unsigned int point=0; point<n_q_points; ++point)
-			  add_data += ((grad_phi_i[point]*grad_phi_j[point]) * 
-				       JxW[point] * 
+			  add_data += ((grad_phi_i[point]*grad_phi_j[point]) *
+				       JxW[point] *
 				       data.coefficient_vector_values[point](component_i));
 		    }
 		  else
 		    for (unsigned int point=0; point<n_q_points; ++point)
-		      add_data += (grad_phi_i[point]*grad_phi_j[point]) * 
-			          JxW[point]; 
+		      add_data += (grad_phi_i[point]*grad_phi_j[point]) *
+			          JxW[point];
 
 		  copy_data.cell_matrix(i,j) = add_data;
 		  copy_data.cell_matrix(j,i) = add_data;
@@ -471,41 +468,41 @@ namespace internal
 			{
 			  if (data.coefficient->n_components==1)
 			    for (unsigned int point=0; point<n_q_points; ++point)
-			      add_data += ((fe_values.shape_grad_component(i,point,comp_i) * 
-					    fe_values.shape_grad_component(j,point,comp_i)) * 
-					   JxW[point] * 
+			      add_data += ((fe_values.shape_grad_component(i,point,comp_i) *
+					    fe_values.shape_grad_component(j,point,comp_i)) *
+					   JxW[point] *
 					   data.coefficient_values[point]);
 			  else
 			    for (unsigned int point=0; point<n_q_points; ++point)
-			      add_data += ((fe_values.shape_grad_component(i,point,comp_i) * 
-					    fe_values.shape_grad_component(j,point,comp_i)) * 
-					   JxW[point] * 
+			      add_data += ((fe_values.shape_grad_component(i,point,comp_i) *
+					    fe_values.shape_grad_component(j,point,comp_i)) *
+					   JxW[point] *
 					   data.coefficient_vector_values[point](comp_i));
 			}
 		      else
 			for (unsigned int point=0; point<n_q_points; ++point)
-			  add_data += (fe_values.shape_grad_component(i,point,comp_i) * 
-				       fe_values.shape_grad_component(j,point,comp_i)) * 
+			  add_data += (fe_values.shape_grad_component(i,point,comp_i) *
+				       fe_values.shape_grad_component(j,point,comp_i)) *
 			              JxW[point];
 		    }
 
 		copy_data.cell_matrix(i,j) = add_data;
 		copy_data.cell_matrix(j,i) = add_data;
 	      }
-	      
+
 	    if (use_rhs_function)
 	      {
 		add_data = 0;
-		for (unsigned int comp_i = 0; comp_i < n_components; ++comp_i) 
+		for (unsigned int comp_i = 0; comp_i < n_components; ++comp_i)
 		  if (fe.get_nonzero_components(i)[comp_i])
 		    {
 		      if (data.rhs_function->n_components==1)
 			for (unsigned int point=0; point<n_q_points; ++point)
-			  add_data += fe_values.shape_value_component(i,point,comp_i) * 
+			  add_data += fe_values.shape_value_component(i,point,comp_i) *
 			              JxW[point] * data.rhs_values[point];
 		      else
 			for (unsigned int point=0; point<n_q_points; ++point)
-			  add_data += fe_values.shape_value_component(i,point,comp_i) * 
+			  add_data += fe_values.shape_value_component(i,point,comp_i) *
 			              JxW[point] * data.rhs_vector_values[point](comp_i);
 		    }
 		copy_data.cell_rhs(i) = add_data;
@@ -583,7 +580,7 @@ void MatrixCreator::create_mass_matrix (const Mapping<dim,spacedim>       &mappi
 		    (coefficient != 0 ? update_quadrature_points : UpdateFlags(0)),
 		    coefficient, /*rhs_function=*/0,
 		    q, mapping);
-  
+
   internal::MatrixCreator::AssemblerData::CopyData copy_data;
   copy_data.cell_matrix.reinit (assembler_data.fe_collection.max_dofs_per_cell(),
 			 assembler_data.fe_collection.max_dofs_per_cell());
@@ -639,7 +636,7 @@ void MatrixCreator::create_mass_matrix (const Mapping<dim,spacedim>       &mappi
   copy_data.cell_matrix.reinit (assembler_data.fe_collection.max_dofs_per_cell(),
 			 assembler_data.fe_collection.max_dofs_per_cell());
   copy_data.cell_rhs.reinit (assembler_data.fe_collection.max_dofs_per_cell());
-  copy_data.dof_indices.resize (assembler_data.fe_collection.max_dofs_per_cell());  
+  copy_data.dof_indices.resize (assembler_data.fe_collection.max_dofs_per_cell());
 
   WorkStream::run (dof.begin_active(),
 		   static_cast<typename DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
@@ -691,7 +688,7 @@ void MatrixCreator::create_mass_matrix (const hp::MappingCollection<dim,spacedim
 			 assembler_data.fe_collection.max_dofs_per_cell());
   copy_data.cell_rhs.reinit (assembler_data.fe_collection.max_dofs_per_cell());
   copy_data.dof_indices.resize (assembler_data.fe_collection.max_dofs_per_cell());
-  
+
   WorkStream::run (dof.begin_active(),
 		   static_cast<typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
 		   &internal::MatrixCreator::mass_assembler<dim, spacedim, typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>,
@@ -825,14 +822,14 @@ MatrixCreator::create_boundary_mass_matrix (const Mapping<dim, spacedim>  &mappi
 {
   const FiniteElement<dim,spacedim> &fe = dof.get_fe();
   const unsigned int n_components  = fe.n_components();
-  
+
   Assert (matrix.n() == dof.n_boundary_dofs(boundary_functions),
           ExcInternalError());
   Assert (matrix.n() == matrix.m(), ExcInternalError());
   Assert (matrix.n() == rhs_vector.size(), ExcInternalError());
   Assert (boundary_functions.size() != 0, ExcInternalError());
   Assert (dof_to_boundary_mapping.size() == dof.n_dofs(),
-	  ExcInternalError());  
+	  ExcInternalError());
   Assert (coefficient ==0 ||
 	  coefficient->n_components==1 ||
 	  coefficient->n_components==n_components, ExcComponentMismatch());
@@ -845,13 +842,13 @@ MatrixCreator::create_boundary_mass_matrix (const Mapping<dim, spacedim>  &mappi
     }
   else
     AssertDimension (n_components, component_mapping.size());
-  
+
   const unsigned int n_threads = multithread_info.n_default_threads;
   Threads::ThreadGroup<> threads;
 
 				   // define starting and end point
 				   // for each thread
-  typedef typename DoFHandler<dim,spacedim>::active_cell_iterator active_cell_iterator;  
+  typedef typename DoFHandler<dim,spacedim>::active_cell_iterator active_cell_iterator;
   std::vector<std::pair<active_cell_iterator,active_cell_iterator> > thread_ranges
     = Threads::split_range<active_cell_iterator> (dof.begin_active(),
 						  dof.end(), n_threads);
@@ -863,7 +860,7 @@ MatrixCreator::create_boundary_mass_matrix (const Mapping<dim, spacedim>  &mappi
   typedef std_cxx1x::tuple<const Mapping<dim,spacedim>&,
     const DoFHandler<dim,spacedim>&,
     const Quadrature<dim-1>&> Commons;
-  
+
 				   // then assemble in parallel
   typedef void (*create_boundary_mass_matrix_1_t)
       (Commons,
@@ -877,7 +874,7 @@ MatrixCreator::create_boundary_mass_matrix (const Mapping<dim, spacedim>  &mappi
        Threads::ThreadMutex      &mutex);
   create_boundary_mass_matrix_1_t p = &MatrixCreator::template create_boundary_mass_matrix_1<dim,spacedim>;
 
-//TODO: Use WorkStream here  
+//TODO: Use WorkStream here
   for (unsigned int thread=0; thread<n_threads; ++thread)
     threads += Threads::new_thread (p,
 				    Commons(mapping, dof, q), matrix,
@@ -885,7 +882,7 @@ MatrixCreator::create_boundary_mass_matrix (const Mapping<dim, spacedim>  &mappi
 				    dof_to_boundary_mapping, coefficient,
 				    component_mapping,
 				    thread_ranges[thread], mutex);
-  threads.join_all ();  
+  threads.join_all ();
 }
 
 
@@ -933,16 +930,16 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const Mapping<dim, spacedim> &,
   const Mapping<dim,spacedim>& mapping = std_cxx1x::get<0>(commons);
   const DoFHandler<dim,spacedim>& dof = std_cxx1x::get<1>(commons);
   const Quadrature<dim-1>& q = std_cxx1x::get<2>(commons);
-  
+
   const FiniteElement<dim,spacedim> &fe = dof.get_fe();
   const unsigned int n_components  = fe.n_components();
   const unsigned int n_function_components = boundary_functions.begin()->second->n_components;
   const bool         fe_is_system  = (n_components != 1);
-  const bool         fe_is_primitive = fe.is_primitive();  
-  
+  const bool         fe_is_primitive = fe.is_primitive();
+
   const unsigned int dofs_per_cell = fe.dofs_per_cell,
 		     dofs_per_face = fe.dofs_per_face;
-  
+
   FullMatrix<double> cell_matrix(dofs_per_cell, dofs_per_cell);
   Vector<double>     cell_vector(dofs_per_cell);
 
@@ -961,18 +958,18 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const Mapping<dim, spacedim> &,
 							  Vector<double>(n_components));
   const bool coefficient_is_vector = (coefficient != 0 && coefficient->n_components != 1)
 				     ? true : false;
-  
+
   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));
 
   std::vector<unsigned int> dofs (dofs_per_cell);
   std::vector<unsigned int> dofs_on_face_vector (dofs_per_face);
-  
+
 				   // for each dof on the cell, have a
 				   // flag whether it is on the face
   std::vector<bool>         dof_is_on_face(dofs_per_cell);
-  
+
   typename DoFHandler<dim,spacedim>::active_cell_iterator cell = range.first;
   for (; cell!=range.second; ++cell)
     for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
@@ -983,9 +980,9 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const Mapping<dim, spacedim> &,
 	{
 	  cell_matrix = 0;
 	  cell_vector = 0;
-	  
+
 	  fe_values.reinit (cell, face);
-	  
+
 	  if (fe_is_system)
 					     // FE has several components
 	    {
@@ -1026,19 +1023,19 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const Mapping<dim, spacedim> &,
 					       // should be projected.
 	      std::vector<std::vector<double> > normal_adjustment(fe_values.n_quadrature_points,
 								  std::vector<double>(n_components, 1.));
-	      
+
 	      for (unsigned int comp = 0;comp<n_components;++comp)
 		{
 		  const FiniteElement<dim,spacedim>& base = fe.base_element(fe.component_to_base_index(comp).first);
 		  const unsigned int bcomp = fe.component_to_base_index(comp).second;
-		  
+
 		  if (!base.conforms(FiniteElementData<dim>::H1) &&
 		      base.conforms(FiniteElementData<dim>::Hdiv))
 		    for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
 		      normal_adjustment[point][comp] = fe_values.normal_vector(point)(bcomp)
 						       * fe_values.normal_vector(point)(bcomp);
 		}
-	      
+
 	      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
 		{
 		  const double weight = fe_values.JxW(point);
@@ -1084,14 +1081,14 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const Mapping<dim, spacedim> &,
 	    {
 	      boundary_functions.find(cell->face(face)->boundary_indicator())
 		->second->value_list (fe_values.get_quadrature_points(), rhs_values_scalar);
-	      
+
 	      if (coefficient != 0)
 		coefficient->value_list (fe_values.get_quadrature_points(),
 					 coefficient_values);
 	      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
 		{
 		  const double weight = fe_values.JxW(point);
-		  for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i) 
+		  for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
 		    {
 		      const double v = fe_values.shape_value(i,point);
 		      for (unsigned int j=0; j<fe_values.dofs_per_cell; ++j)
@@ -1158,7 +1155,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const Mapping<dim, spacedim> &,
 					   dofs[i])
 				 !=
 				 dofs_on_face_vector.end());
-	  
+
                                            // lock the matrix
           Threads::ThreadMutex::ScopedLock lock (mutex);
 	  for (unsigned int i=0; i<dofs_per_cell; ++i)
@@ -1170,7 +1167,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const Mapping<dim, spacedim> &,
 		      matrix.add(dof_to_boundary_mapping[dofs[i]],
 				 dof_to_boundary_mapping[dofs[j]],
 				 cell_matrix(i,j));
-		  
+
 		  rhs_vector(dof_to_boundary_mapping[dofs[i]]) += cell_vector(i);
 		}
 	    }
@@ -1234,7 +1231,7 @@ MatrixCreator::create_boundary_mass_matrix (const hp::MappingCollection<dim,spac
 {
   const hp::FECollection<dim,spacedim> &fe_collection = dof.get_fe();
   const unsigned int n_components  = fe_collection.n_components();
-  
+
   Assert (matrix.n() == dof.n_boundary_dofs(boundary_functions),
           ExcInternalError());
   Assert (matrix.n() == matrix.m(), ExcInternalError());
@@ -1260,7 +1257,7 @@ MatrixCreator::create_boundary_mass_matrix (const hp::MappingCollection<dim,spac
 
 				   // define starting and end point
 				   // for each thread
-  typedef typename hp::DoFHandler<dim,spacedim>::active_cell_iterator active_cell_iterator;  
+  typedef typename hp::DoFHandler<dim,spacedim>::active_cell_iterator active_cell_iterator;
   std::vector<std::pair<active_cell_iterator,active_cell_iterator> > thread_ranges
     = Threads::split_range<active_cell_iterator> (dof.begin_active(),
 						  dof.end(), n_threads);
@@ -1268,11 +1265,11 @@ MatrixCreator::create_boundary_mass_matrix (const hp::MappingCollection<dim,spac
   typedef std_cxx1x::tuple<const hp::MappingCollection<dim,spacedim>&,
     const hp::DoFHandler<dim,spacedim>&,
     const hp::QCollection<dim-1>&> Commons;
-  
+
 				   // mutex to synchronise access to
 				   // the matrix
   Threads::ThreadMutex mutex;
-  
+
 				   // then assemble in parallel
   typedef void (*create_boundary_mass_matrix_1_t)
       (Commons,
@@ -1286,7 +1283,7 @@ MatrixCreator::create_boundary_mass_matrix (const hp::MappingCollection<dim,spac
        Threads::ThreadMutex      &mutex);
   create_boundary_mass_matrix_1_t p = &MatrixCreator::template create_boundary_mass_matrix_1<dim,spacedim>;
 
-//TODO: Use WorkStream here  
+//TODO: Use WorkStream here
   for (unsigned int thread=0; thread<n_threads; ++thread)
     threads += Threads::new_thread (p,
 				    Commons(mapping, dof, q), matrix,
@@ -1294,7 +1291,7 @@ MatrixCreator::create_boundary_mass_matrix (const hp::MappingCollection<dim,spac
 				    dof_to_boundary_mapping, coefficient,
 				    component_mapping,
 				    thread_ranges[thread], mutex);
-  threads.join_all ();  
+  threads.join_all ();
 }
 
 
@@ -1333,10 +1330,10 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
       Assert (max_element  == matrix.n()-1, ExcInternalError());
     };
 #endif
-  
+
   const unsigned int max_dofs_per_cell = fe_collection.max_dofs_per_cell(),
 		     max_dofs_per_face = fe_collection.max_dofs_per_face();
-  
+
   FullMatrix<double> cell_matrix(max_dofs_per_cell, max_dofs_per_cell);
   Vector<double>     cell_vector(max_dofs_per_cell);
 
@@ -1378,12 +1375,12 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 	  const FiniteElement<dim,spacedim> &fe = cell->get_fe();
 	  const unsigned int dofs_per_cell = fe.dofs_per_cell;
 	  const unsigned int dofs_per_face = fe.dofs_per_face;
-	  
+
 	  cell_matrix.reinit (dofs_per_cell, dofs_per_cell);
 	  cell_vector.reinit (dofs_per_cell);
 	  cell_matrix = 0;
-	  cell_vector = 0;	  
-	  
+	  cell_vector = 0;
+
 	  if (fe_is_system)
 					     // FE has several components
 	    {
@@ -1392,7 +1389,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 	      boundary_functions.find(cell->face(face)->boundary_indicator())
 		->second->vector_value_list (fe_values.get_quadrature_points(),
 					     rhs_values_system);
-	      
+
 	      if (coefficient != 0)
 		{
 		  if (coefficient->n_components==1)
@@ -1403,7 +1400,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 		      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
 			{
 			  const double weight = fe_values.JxW(point);
-			  for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i) 
+			  for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
 			    {
 			      const double v = fe_values.shape_value(i,point);
 			      for (unsigned int j=0; j<fe_values.dofs_per_cell; ++j)
@@ -1414,7 +1411,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 				    cell_matrix(i,j)
 				      += (u * v * weight * coefficient_values[point]);
 				  }
-			      
+
 			      cell_vector(i) += v *
 						rhs_values_system[point](
 						  component_mapping[fe.system_to_component_index(i).first]) * weight;
@@ -1430,7 +1427,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 		      for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
 			{
 			  const double weight = fe_values.JxW(point);
-			  for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i) 
+			  for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
 			    {
 			      const double v = fe_values.shape_value(i,point);
 			      const unsigned int component_i=
@@ -1452,7 +1449,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 		for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
 		  {
 		    const double weight = fe_values.JxW(point);
-		    for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i) 
+		    for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
 		      {
 			const double v = fe_values.shape_value(i,point);
 			for (unsigned int j=0; j<fe_values.dofs_per_cell; ++j)
@@ -1475,7 +1472,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 	      rhs_values_scalar.resize (fe_values.n_quadrature_points);
 	      boundary_functions.find(cell->face(face)->boundary_indicator())
 		->second->value_list (fe_values.get_quadrature_points(), rhs_values_scalar);
-	      
+
 	      if (coefficient != 0)
 		{
 		  coefficient_values.resize (fe_values.n_quadrature_points);
@@ -1484,7 +1481,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 		  for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
 		    {
 		      const double weight = fe_values.JxW(point);
-		      for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i) 
+		      for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
 			{
 			  const double v = fe_values.shape_value(i,point);
 			  for (unsigned int j=0; j<fe_values.dofs_per_cell; ++j)
@@ -1500,7 +1497,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 		for (unsigned int point=0; point<fe_values.n_quadrature_points; ++point)
 		  {
 		    const double weight = fe_values.JxW(point);
-		    for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i) 
+		    for (unsigned int i=0; i<fe_values.dofs_per_cell; ++i)
 		      {
 			const double v = fe_values.shape_value(i,point);
 			for (unsigned int j=0; j<fe_values.dofs_per_cell; ++j)
@@ -1578,7 +1575,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 					   dofs[i])
 				 !=
 				 dofs_on_face_vector.end());
-	  
+
 					   // in debug mode: compute an element
 					   // in the matrix which is
 					   // guaranteed to belong to a boundary
@@ -1606,7 +1603,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 	  for (unsigned int i=0; i<dofs_per_cell; ++i)
 	    if (std::fabs(cell_matrix(i,i)) > max_diag_entry)
 	      max_diag_entry = std::fabs(cell_matrix(i,i));
-#endif  
+#endif
 
                                            // lock the matrix
           Threads::ThreadMutex::ScopedLock lock (mutex);
@@ -1650,7 +1647,7 @@ create_boundary_mass_matrix_1 (std_cxx1x::tuple<const hp::MappingCollection<dim,
 		  Assert (std::fabs(cell_matrix(i,j)) <= 1e-10 * max_diag_entry,
 			  ExcInternalError ());
 		};
-	  
+
 	  for (unsigned int j=0; j<dofs_per_cell; ++j)
 	    if (dof_is_on_face[j])
 	      rhs_vector(dof_to_boundary_mapping[dofs[j]]) += cell_vector(j);
@@ -1705,7 +1702,7 @@ void MatrixCreator::create_laplace_matrix (const Mapping<dim, spacedim>       &m
   copy_data.cell_matrix.reinit (assembler_data.fe_collection.max_dofs_per_cell(),
 			 assembler_data.fe_collection.max_dofs_per_cell());
   copy_data.cell_rhs.reinit (assembler_data.fe_collection.max_dofs_per_cell());
-  copy_data.dof_indices.resize (assembler_data.fe_collection.max_dofs_per_cell());  
+  copy_data.dof_indices.resize (assembler_data.fe_collection.max_dofs_per_cell());
 
   WorkStream::run (dof.begin_active(),
 		   static_cast<typename DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
@@ -1805,7 +1802,7 @@ void MatrixCreator::create_laplace_matrix (const hp::MappingCollection<dim,space
   copy_data.cell_matrix.reinit (assembler_data.fe_collection.max_dofs_per_cell(),
 			 assembler_data.fe_collection.max_dofs_per_cell());
   copy_data.cell_rhs.reinit (assembler_data.fe_collection.max_dofs_per_cell());
-  copy_data.dof_indices.resize (assembler_data.fe_collection.max_dofs_per_cell());  
+  copy_data.dof_indices.resize (assembler_data.fe_collection.max_dofs_per_cell());
 
   WorkStream::run (dof.begin_active(),
 		   static_cast<typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
@@ -1856,7 +1853,7 @@ void MatrixCreator::create_laplace_matrix (const hp::MappingCollection<dim,space
 			 assembler_data.fe_collection.max_dofs_per_cell());
   copy_data.cell_rhs.reinit (assembler_data.fe_collection.max_dofs_per_cell());
   copy_data.dof_indices.resize (assembler_data.fe_collection.max_dofs_per_cell());
-  
+
   WorkStream::run (dof.begin_active(),
 		   static_cast<typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>(dof.end()),
 		   &internal::MatrixCreator::laplace_assembler<dim, spacedim, typename hp::DoFHandler<dim,spacedim>::active_cell_iterator>,
@@ -2227,7 +2224,7 @@ void MatrixCreator::create_boundary_mass_matrix<deal_II_dimension,deal_II_dimens
  const Function<deal_II_dimension+1> * const a,
  std::vector<unsigned int>);
 
-#endif 
+#endif
 
 // #if deal_II_dimension != 1
 // template