1 files changed, 194 insertions, 0 deletions
diff --git a/src/AMRHierLib/AMRGrid.icc b/src/AMRHierLib/AMRGrid.icc
new file mode 100644
index 0000000..c634f1e
--- /dev/null
+++ b/src/AMRHierLib/AMRGrid.icc
@@ -0,0 +1,194 @@
+//------------------------------------------------------------------------------
+//
+// Project:	AMR Visualization
+// Module:	$RCSfile$
+// Language:	C++
+// Date:	$Date$
+// Author:	$Author$
+// Version:	$Revision$
+//
+//------------------------------------------------------------------------------
+
+/* WARNING: This software is EXPERIMENTAL. The authors give no guaranty
+ *   about stability or correctness of the provided source!
+ *
+ * Copyright (C) 2001,  The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the Visualization
+ *      Group at Lawrence Berkeley National Laboratory.
+ * 4. Neither the name of the University of California, Berkeley nor of the 
+ *    Lawrence Berkeley National Laboratory may be used to endorse or 
+ *    promote products derived from this software without specific prior 
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *
+ * This work is supported by the U. S. Department of Energy under contract 
+ * number DE-AC03-76SF00098 between the U. S. Department of Energy and the 
+ * University of California.
+ *
+ *	Author: Gunther H Weber
+ *		Lawrence Berkeley National Laboratory
+ *              Berkeley, California 
+ *
+ *  "this software is 100% hand-crafted by a human being in the USA [and Germany :-)]"
+ *
+ */
+ 
+inline float AMRGrid::getValue(int i) const
+{
+  // <NOTE> Maybe it is possible to integrate some type of conversion here, if the
+  // grid is not Float32.</NOTE>
+  // <NOTE> Maybe it is possible to switch here between logaritmic and normal grid rep.
+  // </NOTE>
+#ifdef LOG_GETVALUE
+  return logf(static_cast<float*>(data)[i]);
+#else
+  return static_cast<float*>(data)[i];
+#endif
+}
+
+inline float AMRGrid::getValue(int i, int j, int k) const
+{
+  //if (0<=i && i<dims[0] && 0 <=j && j<dims[1] && 0<=k && k<dims[2]) 
+  return getValue(i+dims[0]*(j+k*dims[1]));
+  //else
+  //  return 0.0;
+}
+
+inline float AMRGrid::getInterpolatedValue(double x, double y, double z) const
+{
+  // Compute (i, j, k) = index of cell containing position to interpolate value for
+  x -= origin[0];
+  y -= origin[1];
+  z -= origin[2];
+
+  int i = int(x/delta[0]+0.5)-1;
+  int j = int(y/delta[1]+0.5)-1;
+  int k = int(z/delta[2]+0.5)-1;
+
+  float deltaX = (getValue(i+1, j, k) - getValue(i-1, j, k)) / delta[0];
+  float deltaY = (getValue(i, j+1, k) - getValue(i, j-1, k)) / delta[1];
+  float deltaZ = (getValue(i, j, k+1) - getValue(i, j, k-1)) / delta[2];
+
+  float xi = (float(i)+0.5)*delta[0];
+  float yi = (float(j)+0.5)*delta[1];
+  float zi = (float(k)+0.5)*delta[2];
+
+  float res = getValue(i, j, k) + deltaX*(x-xi) + deltaY*(y-yi) + deltaZ*(z-zi);
+  return res;
+#if 0
+  double tx = (x-xi)/delta[0];
+  double ty = (y-yi)/delta[1];
+  double tz = (z-zi)/delta[2];
+
+  return tz*(ty   *(tx*getValue(i+1,j+1,k+1)*(1-tx)*getValue(i,j+1,k+1))+
+      (1-ty)*(tx*getValue(i+1,j  ,k+1)*(1-tx)*getValue(i,j,  k+1)))
+    +(1-tz)*(ty   *(tx*getValue(i+1,j+1,k  )*(1-tx)*getValue(i,j+1,k  ))+
+	(1-ty)*(tx*getValue(i+1,j,  k  )*(1-tx)*getValue(i,j,k)));
+#endif
+}
+
+inline void AMRGrid::unloadCells()
+{
+  if (data) free(data);
+  data = NULL;
+}
+
+inline AMRGrid* AMRGrid::getNextGridInLevel() const
+{
+  return mNextGridInLevel;
+}
+
+inline AMRGrid::AMRRefiningGridIterator AMRGrid::refiningGridsBegin()
+{
+  return mRefiningGrids.begin();
+}
+
+inline AMRGrid::AMRRefiningGridIterator AMRGrid::refiningGridsEnd()
+{
+  return mRefiningGrids.end();
+}
+
+inline AMRGrid::AMRRefinedGridIterator AMRGrid::refinedGridsBegin()
+{
+  return mRefinedGrids.begin();
+}
+
+inline AMRGrid::AMRRefinedGridIterator AMRGrid::refinedGridsEnd()
+{
+  return mRefinedGrids.end();
+}
+
+inline AMRGrid::AMRRefiningGridConstIterator AMRGrid::refiningGridsBegin() const
+{
+  return mRefiningGrids.begin();
+}
+
+inline AMRGrid::AMRRefiningGridConstIterator AMRGrid::refiningGridsEnd() const
+{
+  return mRefiningGrids.end();
+}
+
+inline AMRGrid::AMRRefinedGridConstIterator AMRGrid::refinedGridsBegin() const
+{
+  return mRefinedGrids.begin();
+}
+
+inline AMRGrid::AMRRefinedGridConstIterator AMRGrid::refinedGridsEnd() const
+{
+  return mRefinedGrids.end();
+}
+
+
+inline AMRHierarchy::GridId AMRGrid::index() const
+{
+  return mGridIndex;
+}
+
+inline const Range<float>& AMRGrid::getValueRange() const
+{
+  return mValueRange;
+}
+
+inline AMRGrid::IntersectionMap* AMRGrid::computeIntersectionMap(IntersectionMap::MapType mapType) const
+{
+  return computeIntersectionMap(mapType, PrimitiveBitSet(1), true);
+}
+
+inline bool AMRGrid::refinementAvailable() const
+{
+  return !mRefiningGrids.empty();
+}
+
+inline bool AMRGrid::isRefinement() const
+{
+  return !mRefinedGrids.empty();
+}
+
+inline AMRHierarchy::GridId AMRGrid::getCellRefiningGridId(const int idx[3]) const
+{
+  return getCellRefiningGridId(idx[0], idx[1], idx[2]);
+}