add 1st draft of support for setting an excision mask

-- alas this doesn't work properly (yet) for multiple processors


git-svn-id: http://svn.einsteintoolkit.org/cactus/EinsteinAnalysis/AHFinderDirect/trunk@975 f88db872-0e4f-0410-b76b-b9085cfa78c5

3 files changed, 71 insertions, 20 deletions

diff --git a/src/jtutil/norm.cc b/src/jtutil/norm.cc
index 6fd3a92..283beb3 100644
--- a/src/jtutil/norm.cc
+++ b/src/jtutil/norm.cc
@@ -2,7 +2,12 @@
 // $Header$
 
 //
-// *** class jtutil::norm::
+// jtutil::norm::data
+// jtutil::norm::mean
+// jtutil::norm::two_norm
+// jtutil::norm::rms_norm
+//
+// ***** template instantiations *****
 //
 
 #include <math.h>
@@ -12,8 +17,48 @@
 #include "util.hh"
 
 //*****************************************************************************
+//*****************************************************************************
+//*****************************************************************************
 
-// specify data point
+//
+// This function constructs a  norm  object.
+//
+namespace jtutil
+	  {
+template <typename fp_t>
+  norm<fp_t>::norm()
+	: N_(0L),
+	  sum_(0.0), sum2_(0.0),
+	  max_abs_value_(0.0), min_abs_value_(0.0),
+	  max_value_(0.0), min_value_(0.0)
+{ }
+	  }
+
+//*****************************************************************************
+
+//
+// This function resets a  norm  object to its initial state
+//
+namespace jtutil
+	  {
+template <typename fp_t>
+  void norm<fp_t>::reset()
+{
+N_ = 0L;
+sum_ = 0.0;
+sum2_ = 0.0;
+max_abs_value_ = 0.0;
+min_abs_value_ = 0.0;
+max_value_ = 0.0;
+min_value_ = 0.0;
+}
+	  }
+
+//*****************************************************************************
+
+//
+// This function updates the norms with a new data point  x .
+//
 namespace jtutil
 	  {
 template <typename fp_t>
@@ -24,8 +69,10 @@ sum2_ += x*x;
 
 const fp_t abs_x = jtutil::abs<fp_t>(x);
 max_abs_value_ = jtutil::max(max_abs_value_, abs_x);
-min_abs_value_ = (N_ == 0) ? abs_x
-			   : jtutil::min(min_abs_value_, abs_x);
+min_abs_value_ = (N_ == 0) ? abs_x : jtutil::min(min_abs_value_, abs_x);
+
+min_value_ = (N_ == 0) ? x : jtutil::min(min_value_, x);
+max_value_ = (N_ == 0) ? x : jtutil::max(max_value_, x);
 
 ++N_;
 }
@@ -33,7 +80,9 @@ min_abs_value_ = (N_ == 0) ? abs_x
 
 //******************************************************************************
 
-// get norms etc
+//
+// these functions compute the corresponding norms
+//
 namespace jtutil
 	  {
 template<typename fp_t>
@@ -46,6 +95,8 @@ template<typename fp_t>
 	  }	// namespace jtutil::
 
 //******************************************************************************
+//******************************************************************************
+//******************************************************************************
 
 //
 // ***** template instantiations *****
diff --git a/src/jtutil/test_norm.cc b/src/jtutil/test_norm.cc
index 25a9c59..f9c8d47 100644
--- a/src/jtutil/test_norm.cc
+++ b/src/jtutil/test_norm.cc
@@ -27,6 +27,8 @@ assert( fuzzy<double>::EQ(foo.rms_norm(), 3.0) );
 assert( fuzzy<double>::EQ(foo.infinity_norm(), 3.0) );
 assert( fuzzy<double>::EQ(foo.max_abs_value(), 3.0) );
 assert( fuzzy<double>::EQ(foo.min_abs_value(), 3.0) );
+assert( fuzzy<double>::EQ(foo.min_value(), -3.0) );
+assert( fuzzy<double>::EQ(foo.max_value(), +3.0) );
 
 foo.reset();
 assert(  foo.is_empty() );
@@ -44,6 +46,8 @@ assert( fuzzy<double>::EQ(foo.rms_norm(), sqrt(10.4)) );
 assert( fuzzy<double>::EQ(foo.infinity_norm(), 5.0) );
 assert( fuzzy<double>::EQ(foo.max_abs_value(), 5.0) );
 assert( fuzzy<double>::EQ(foo.min_abs_value(), 1.0) );
+assert( fuzzy<double>::EQ(foo.min_value(), -5.0) );
+assert( fuzzy<double>::EQ(foo.max_value(), +1.0) );
 
 printf("everything ok!\n");
 return 0;
diff --git a/src/jtutil/util.hh b/src/jtutil/util.hh
index 80fb8f0..275e927 100644
--- a/src/jtutil/util.hh
+++ b/src/jtutil/util.hh
@@ -92,8 +92,8 @@ template <typename fp_t>
 //******************************************************************************
 
 //
-// This template class computes means, 2-norms, rms-norms, and
-// infinity-norms.  It also computes minimum values.
+// This template class computes means, 2-norms, rms-norms, infinity-norms,
+// and various related values.
 //
 template <typename fp_t>
 class	norm
@@ -104,9 +104,13 @@ public:
 	fp_t two_norm() const;		// sqrt(sum x_i^2)
 	fp_t rms_norm() const;		// sqrt(average of x_i^2)
 	fp_t infinity_norm() const { return max_abs_value_; }
+
 	fp_t max_abs_value() const { return max_abs_value_; }
 	fp_t min_abs_value() const { return min_abs_value_; }
 
+	fp_t max_value() const { return max_value_; }
+	fp_t min_value() const { return min_value_; }
+
 	// specify data point
 	void data(fp_t x);
 
@@ -115,21 +119,11 @@ public:
 	bool is_nonempty() const { return N_ > 0; }
 
 	// reset ==> just like newly-constructed object
-	void reset()
-		{
-		N_ = 0;
-		sum2_ = 0.0;
-		max_abs_value_ = 0.0;
-		min_abs_value_ = 0.0;
-		}
+	void reset();
 
 	// constructor, destructor
 	// ... compiler-generated no-op destructor is ok
-	norm()
-		: N_(0),
-		  sum_(0.0), sum2_(0.0),
-		  max_abs_value_(0.0), min_abs_value_(0.0)
-		{ }
+	norm();
 
 private:
         // we forbid copying and passing by value
@@ -139,11 +133,13 @@ private:
 	norm& operator=(const norm &rhs);
 
 private:
-	int N_;			// # of data points
+	long N_;		// # of data points
 	fp_t sum_;		// sum(data)
 	fp_t sum2_;		// sum(data^2)
 	fp_t max_abs_value_;	// max |data|
 	fp_t min_abs_value_;	// min |data|
+	fp_t max_value_;	// max data
+	fp_t min_value_;	// min data
 	};
 
 //******************************************************************************