]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Make base library 3d-aware also to the public (just forgot to check this in last...
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 22 Feb 1999 14:53:27 +0000 (14:53 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Mon, 22 Feb 1999 14:53:27 +0000 (14:53 +0000)
git-svn-id: https://svn.dealii.org/trunk@876 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/base/source/quadrature.cc
deal.II/base/source/quadrature_lib.cc

index e0445aec47b6acfa7d5168a690fc3a9dae45e07d..45a74f223ba7a21a551dfda95b45180ae1992630 100644 (file)
@@ -123,6 +123,54 @@ void QProjector<2>::project_to_face (const Quadrature<1> &quadrature,
 
 
 
+template <>
+void QProjector<3>::project_to_face (const Quadrature<2> &quadrature,
+                                    const unsigned int   face_no,
+                                    vector<Point<3> >   &q_points) {
+  const unsigned int dim=3;
+  Assert (face_no<2*dim, ExcInvalidIndex (face_no, 2*dim));
+  
+  for (unsigned int p=0; p<quadrature.n_quadrature_points; ++p)
+    switch (face_no)
+      {
+       case 0:
+             q_points[p] = Point<dim>(quadrature.quad_point(p)(0),
+                                      0,
+                                      quadrature.quad_point(p)(1));
+             break;       
+       case 1:
+             q_points[p] = Point<dim>(quadrature.quad_point(p)(0),
+                                      1,
+                                      quadrature.quad_point(p)(1));
+             break;       
+       case 2:
+             q_points[p] = Point<dim>(quadrature.quad_point(p)(0),
+                                      quadrature.quad_point(p)(1),
+                                      0);
+             break;
+       case 3:
+             q_points[p] = Point<dim>(1,
+                                      quadrature.quad_point(p)(0),
+                                      quadrature.quad_point(p)(1));
+             break;
+       case 4:
+             q_points[p] = Point<dim>(quadrature.quad_point(p)(0),
+                                      quadrature.quad_point(p)(1),
+                                      1);
+             break;
+       case 5:
+             q_points[p] = Point<dim>(0,
+                                      quadrature.quad_point(p)(0),
+                                      quadrature.quad_point(p)(1));
+             break;      
+             
+       default:
+             Assert (false, ExcInternalError());
+      };
+};
+
+
+
 template <>
 void QProjector<2>::project_to_subface (const Quadrature<1> &quadrature,
                                        const unsigned int   face_no,
@@ -196,7 +244,164 @@ void QProjector<2>::project_to_subface (const Quadrature<1> &quadrature,
 
 
 
+template <>
+void QProjector<3>::project_to_subface (const Quadrature<2> &quadrature,
+                                       const unsigned int   face_no,
+                                       const unsigned int   subface_no,
+                                       vector<Point<3> >   &q_points) {
+  const unsigned int dim=3;
+  Assert (face_no<2*dim, ExcInvalidIndex (face_no, 2*dim));
+  Assert (subface_no<(1<<(dim-1)), ExcInvalidIndex (face_no, 1<<(dim-1)));
+
+
+                                  // for all faces and subfaces: first project
+                                  // onto the first subface of each face, then
+                                  // move it to the right place
+  for (unsigned int p=0; p<quadrature.n_quadrature_points; ++p)
+    switch (face_no)
+      {
+       case 0:
+             q_points[p] = Point<dim>(quadrature.quad_point(p)(0)/2,
+                                      0,
+                                      quadrature.quad_point(p)(1)/2);
+             switch (subface_no) 
+               {
+                 case 0:
+                       break;
+                 case 1:
+                       q_points[p][0] += 1./2.;
+                       break;
+                 case 2:
+                       q_points[p][0] += 1./2.;
+                       q_points[p][2] += 1./2.;
+                       break;
+                 case 3:
+                       q_points[p][2] += 1./2.;
+                       break;
+                 default:
+                       Assert (false, ExcInternalError());
+               };
+             
+             break;       
+       case 1:
+             q_points[p] = Point<dim>(quadrature.quad_point(p)(0)/2,
+                                      1,
+                                      quadrature.quad_point(p)(1)/2);
+             switch (subface_no) 
+               {
+                 case 0:
+                       break;
+                 case 1:
+                       q_points[p][0] += 1./2.;
+                       break;
+                 case 2:
+                       q_points[p][0] += 1./2.;
+                       q_points[p][2] += 1./2.;
+                       break;
+                 case 3:
+                       q_points[p][2] += 1./2.;
+                       break;
+                 default:
+                       Assert (false, ExcInternalError());
+               };
+             break;       
+       case 2:
+             q_points[p] = Point<dim>(quadrature.quad_point(p)(0)/2,
+                                      quadrature.quad_point(p)(1)/2,
+                                      0);
+             switch (subface_no) 
+               {
+                 case 0:
+                       break;
+                 case 1:
+                       q_points[p][0] += 1./2.;
+                       break;
+                 case 2:
+                       q_points[p][0] += 1./2.;
+                       q_points[p][1] += 1./2.;
+                       break;
+                 case 3:
+                       q_points[p][1] += 1./2.;
+                       break;
+                 default:
+                       Assert (false, ExcInternalError());
+               };
+             break;
+       case 3:
+             q_points[p] = Point<dim>(1,
+                                      quadrature.quad_point(p)(0)/2,
+                                      quadrature.quad_point(p)(1)/2);
+             switch (subface_no) 
+               {
+                 case 0:
+                       break;
+                 case 1:
+                       q_points[p][1] += 1./2.;
+                       break;
+                 case 2:
+                       q_points[p][1] += 1./2.;
+                       q_points[p][2] += 1./2.;
+                       break;
+                 case 3:
+                       q_points[p][2] += 1./2.;
+                       break;
+                 default:
+                       Assert (false, ExcInternalError());
+               };
+             break;
+       case 4:
+             q_points[p] = Point<dim>(quadrature.quad_point(p)(0)/2,
+                                      quadrature.quad_point(p)(1)/2,
+                                      1);
+             switch (subface_no) 
+               {
+                 case 0:
+                       break;
+                 case 1:
+                       q_points[p][0] += 1./2.;
+                       break;
+                 case 2:
+                       q_points[p][0] += 1./2.;
+                       q_points[p][1] += 1./2.;
+                       break;
+                 case 3:
+                       q_points[p][1] += 1./2.;
+                       break;
+                 default:
+                       Assert (false, ExcInternalError());
+               };
+             break;
+       case 5:
+             q_points[p] = Point<dim>(0,
+                                      quadrature.quad_point(p)(0)/2,
+                                      quadrature.quad_point(p)(1)/2);
+             switch (subface_no) 
+               {
+                 case 0:
+                       break;
+                 case 1:
+                       q_points[p][1] += 1./2.;
+                       break;
+                 case 2:
+                       q_points[p][1] += 1./2.;
+                       q_points[p][2] += 1./2.;
+                       break;
+                 case 3:
+                       q_points[p][2] += 1./2.;
+                       break;
+                 default:
+                       Assert (false, ExcInternalError());
+               };
+             break;      
+       default:
+             Assert (false, ExcInternalError());
+      };
+};
+
+
+
 
 // explicit instantiations; note: we need them all for all dimensions
 template class Quadrature<1>;
 template class Quadrature<2>;
+template class Quadrature<3>;
index e71ed2b2c918736260fc114ed782de174fff8a10..4fd3c792ef393fa15bf7b4f5370ee02948f647de 100644 (file)
@@ -336,10 +336,7 @@ QIteratedTrapez<1>::QIteratedTrapez (const unsigned n) :
 // two space dimensions, so we leave in these Assert'ions until
 // that is done
 template <int dim>
-QGauss2<dim>::QGauss2 () :
-               Quadrature<dim> (QGauss2<dim-1>(), QGauss2<1>()){
-  Assert (dim<3, ExcInternalError());
-};
+QGauss2<dim>::QGauss2 () :  Quadrature<dim> (QGauss2<dim-1>(), QGauss2<1>())  {};
 
 template <int dim>
 QGauss3<dim>::QGauss3 () :
@@ -398,10 +395,7 @@ QTrapez<dim>::QTrapez () :
 
 template <int dim>
 QIteratedTrapez<dim>::QIteratedTrapez (const unsigned n) :
-               Quadrature<dim> (QIteratedTrapez<dim-1>(n), QIteratedTrapez<1>(n))
-{
-  Assert (dim<3, ExcInternalError());
-};
+               Quadrature<dim> (QIteratedTrapez<dim-1>(n), QIteratedTrapez<1>(n)) {};
 
 
 
@@ -418,3 +412,15 @@ template class QSimpson<2>;
 template class QTrapez<2>;
 template class QIteratedTrapez<2>;
 
+template class QGauss2<3>;
+template class QGauss3<3>;
+template class QGauss4<3>;
+template class QGauss5<3>;
+template class QGauss6<3>;
+template class QGauss7<3>;
+template class QGauss8<3>;
+template class QMidpoint<3>;
+template class QSimpson<3>;
+template class QTrapez<3>;
+template class QIteratedTrapez<3>;
+

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.