[PATCH] Use new sub-field constructors, fix centering view of expression

[Richard Guenther]

Hi!

This patch uses the new sub-field constructors from Field::centering() and
Field::material() fixing taking centering views of expressions like
(a+b).center(c). It disambiguates possibly other viewing constructors also
by constructing the expression rather than the expression engine in the
FieldEngine<,,ExpressionTag> viewing constructors.

I'd like to remove all unused sub-field viewing constructors as a follow
up patch now.  Also the Field::subField() viewing method should be now
either removed or made honouring centerings and materials, which needs
adjusting of f.i. FieldEngine::numSubFields() to return
materials*centerings and similar changes elsewhere.  These changes will
kill backward compatibility for some apps - is this feasible? I think yes,
as the current code doesnt seem to have gotten wide testing/appliance.

Tested on ppc, for Field and Evaluator, including previous changes.

Ok?

Richard.


2003Nov09  Richard Guenther <address@hidden>

        * src/Field/FieldEngine/FieldEngine.ExprEngine.h: add sub-field
        viewing constructors for centerings and materials. Construct
        expression rather than engine.
        src/Field/Field.h: use new sub-field viewing constructors for
        centerings and materials. Adjust Field constructors accordingly.

===== Field.h 1.13 vs edited =====
--- 1.13/r2/src/Field/Field.h   Mon Oct 27 11:43:23 2003
+++ edited/Field.h      Sun Nov  9 21:35:00 2003
@@ -184,21 +184,29 @@
   inline static Type_t make(const Type_t &s, int m, int c)
   {
 #if POOMA_BOUNDS_CHECK
-    PInsist(m >= 0 && m < s.numMaterials(),
-            "Field::subField(m, c) indexing error.");
-    PInsist(c >= 0 && c < s.centeringSize(),
+    PInsist(m >= 0 && m < s.numMaterials()
+           && c >= 0 && c < s.centeringSize(),
             "Field::subField(m, c) indexing error.");
 #endif
     return Type_t(s, m, c);
   }

-  inline static Type_t make(int c, const Type_t &s)
+  inline static Type_t make(const Type_t &s, int c, const 
Pooma::CenteringViewTag &tag)
   {
 #if POOMA_BOUNDS_CHECK
     PInsist(c >= 0 && c < s.centeringSize(),
-            "Field::subField(m, c) indexing error.");
+            "Field::center(c) indexing error.");
 #endif
-    return Type_t(c, s);
+    return Type_t(s, c, tag);
+  }
+
+  inline static Type_t make(const Type_t &s, int m, const 
Pooma::MaterialViewTag &tag)
+  {
+#if POOMA_BOUNDS_CHECK
+    PInsist(m >= 0 && m < s.numMaterials(),
+            "Field::material(m) indexing error.");
+#endif
+    return Type_t(s, m, tag);
   }
 };

@@ -229,21 +237,29 @@
   inline static Type_t make(const Subject_t &s, int m, int c)
   {
 #if POOMA_BOUNDS_CHECK
-    PInsist(m >= 0 && m < s.numMaterials(),
-            "Field::subField(m, c) indexing error.");
-    PInsist(c >= 0 && c < s.centeringSize(),
+    PInsist(m >= 0 && m < s.numMaterials()
+           && c >= 0 && c < s.centeringSize(),
             "Field::subField(m, c) indexing error.");
 #endif
     return Type_t(s, m, c);
   }

-  inline static Type_t make(int c, const Subject_t &s)
+  inline static Type_t make(const Subject_t &s, int c, const 
Pooma::CenteringViewTag &tag)
   {
 #if POOMA_BOUNDS_CHECK
     PInsist(c >= 0 && c < s.centeringSize(),
-            "Field::subField(m, c) indexing error.");
+            "Field::center(c) indexing error.");
+#endif
+    return Type_t(s, c, tag);
+  }
+
+  inline static Type_t make(const Subject_t &s, int m, const 
Pooma::MaterialViewTag &tag)
+  {
+#if POOMA_BOUNDS_CHECK
+    PInsist(m >= 0 && m < s.numMaterials(),
+            "Field::material(m) indexing error.");
 #endif
-    return Type_t(c, s);
+    return Type_t(s, m, tag);
   }
 };

@@ -1248,6 +1264,16 @@
     : fieldEngine_m(c, model.fieldEngine())
   { }

+  template<class ET2>
+  Field(const Field<Mesh, T, ET2> &model, int c, const Pooma::CenteringViewTag 
&tag)
+    : fieldEngine_m(model.fieldEngine(), c, tag)
+  { }
+
+  template<class ET2>
+  Field(const Field<Mesh, T, ET2> &model, int m, const Pooma::MaterialViewTag 
&tag)
+    : fieldEngine_m(model.fieldEngine(), m, tag)
+  { }
+
   //---------------------------------------------------------------------------
   /// Empty destructor is fine for us.

@@ -1408,7 +1434,7 @@
   center(int c) const
   {
     typedef SubFieldView<This_t> Ret_t;
-    return Ret_t::make(c, *this);
+    return Ret_t::make(*this, c, Pooma::CenteringViewTag());
   }

   inline typename SubFieldView<This_t>::Type_t
@@ -1416,7 +1442,7 @@
   {
     PAssert(numMaterials() > 1);
     typedef SubFieldView<This_t> Ret_t;
-    return Ret_t::make(*this, m);
+    return Ret_t::make(*this, m, Pooma::MaterialViewTag());
   }
   //@}

===== FieldEngine/FieldEngine.ExprEngine.h 1.2 vs edited =====
--- 1.2/r2/src/Field/FieldEngine/FieldEngine.ExprEngine.h       Sun Oct 26 
14:35:21 2003
+++ edited/FieldEngine/FieldEngine.ExprEngine.h Sun Nov  9 21:23:12 2003
@@ -53,6 +53,7 @@
 #include "Engine/ExpressionEngine.h"
 #include "Layout/GuardLayers.h"
 #include "Utilities/PAssert.h"
+#include "Field/FieldEngine/FieldEngine.h"


 //-----------------------------------------------------------------------------
@@ -215,38 +216,59 @@
     referenceField_m(
       forEachRef(engine_m.expression(), FarLeftTag(), FarLeftTag()))
     { }
-
-  // Sub-field view constructor. This is when we want to construct a view of
-  // one of the subFields in our top-level list.
-  // All these constructors take ints.  We distinguish the sub-material view
-  // from the sub-center view by the order of the arguments.

-  // Version that takes a material and centering.
+  ///@name Sub-field view constructors
+  //@{
+
+  /// This is when we want to construct a view of
+  /// one of the subFields in our top-level list from material and centering.

   template<class Expr2>
   FieldEngine(const FieldEngine<Mesh, T, ExpressionTag<Expr2> > &model, int m, 
int c)
-    : engine_m(model.engine(), m, c),
+    : engine_m(Expr(model.engine().expression(), m, c)),
       referenceField_m(forEachRef(engine_m.expression(),
                                   FarLeftTag(), FarLeftTag()))
   { }

-  // sub-material view.
+  /// Sub-field view for a material.
+
+  template<class Expr2>
+  FieldEngine(const FieldEngine<Mesh, T, ExpressionTag<Expr2> > &model, int m,
+             const Pooma::MaterialViewTag& tag)
+    : engine_m(Expr(model.engine().expression(), m, tag)),
+      referenceField_m(forEachRef(engine_m.expression(),
+                                  FarLeftTag(), FarLeftTag()))
+  { }
+
+  /// Sub-field view for a centering.

   template<class Expr2>
-  FieldEngine(const FieldEngine<Mesh, T, ExpressionTag<Expr2> > &model, const 
int &m)
-    : engine_m(model.engine(), m),
+  FieldEngine(const FieldEngine<Mesh, T, ExpressionTag<Expr2> > &model, int c,
+             const Pooma::CenteringViewTag& tag)
+    : engine_m(Expr(model.engine().expression(), c, tag)),
       referenceField_m(forEachRef(engine_m.expression(),
                                   FarLeftTag(), FarLeftTag()))
   { }

-  // sub-center view.
+  /// sub-material view. Deprecated.
+
+  template<class Expr2>
+  FieldEngine(const FieldEngine<Mesh, T, ExpressionTag<Expr2> > &model, int m)
+    : engine_m(Expr(model.engine().expression, m)),
+      referenceField_m(forEachRef(engine_m.expression(),
+                                  FarLeftTag(), FarLeftTag()))
+  { }
+
+  /// sub-center view. Deprecated.

   template<class Expr2>
   FieldEngine(int c, const FieldEngine<Mesh, T, ExpressionTag<Expr2> > &model)
-    : engine_m(c, model.engine()),
+    : engine_m(Expr(c, model.engine().expression())),
       referenceField_m(forEachRef(engine_m.expression(),
                                   FarLeftTag(), FarLeftTag()))
   { }
+
+  //@}

   // Very important! Copy constructor is needed so that referenceField_m
   // doesn't refer to someone else's expression.