//------------------------------------------------------------------------------
//
// 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]);
}