---

DEMBL.H

Go to the documentation of this file.

/* _______              __
  / ___/ /  ___  __ _  / /  ___
 / /__/ _ \/ _ \/  ' \/ _ \/ _ \
 \___/_//_/\___/_/_/_/_.__/\___/ 
*/
//
// This software is copyright (C) by the Lawrence Berkeley
// National Laboratory.  Permission is granted to reproduce
// this software for non-commercial purposes provided that
// this notice is left intact.
// 
// It is acknowledged that the U.S. Government has rights to
// this software under Contract DE-AC03-765F00098 between
// the U.S.  Department of Energy and the University of
// California.
//
// This software is provided as a professional and academic
// contribution for joint exchange. Thus it is experimental,
// is provided ``as is'', with no warranties of any kind
// whatsoever, no support, no promise of updates, or printed
// documentation. By using this software, you acknowledge
// that the Lawrence Berkeley National Laboratory and
// Regents of the University of California shall have no
// liability with respect to the infringement of other
// copyrights by any part of this software.
//
//  ANAG, LBNL, DTG

#ifndef _DEMBL_H_
#define _DEMBL_H_

#include "MayDay.H"
#include "LoHiSide.H"
#include "IntVect.H"
#include "RealVect.H"
#include "BaseLevelSet.H"
#include "REAL.H"
#include "BoxIterator.H"
using std::pair;

/*
   This is the workshop class for a DEM.
   It follows the BaseLocalGeometry base class.
   Returns C_z+sqrt (radius-(x-C_x)squared+(y-C_y)squared));
 */
class DEMBL: public BaseLevelSet
{
public:

  DEMBL(const IntVect&    a_ncell,
                const int&        a_interpType,
                const Real&       a_dx,
                const RealVect&   a_vectDx);

  virtual ~DEMBL();

   
  /*
      Return true if DEM is read
  */
  virtual bool readDEM(const bool& a_justhead);

  /*
      Return true if DEM is read
  */
  virtual bool fixDEM();


  /*
      Return true if every cell in region is regular at the
      refinement described by dx.
  */
  virtual bool isRegular(const Box&      region,
                         const Box&      domain,
                         const RealVect& origin,
                         const Real&     dx) const;

  /* 
      Return true if every cell in region is covered at the
      refinement described by dx.
  */
  virtual bool isCovered(const Box&           region,
                         const Box&           domain,
                         const RealVect&      origin,
                         const Real&          dx) const;

  /*
     This returns the signed integer which  most closely
     represents the normal direction.  The first integer
     of the pair is of the interface at an irregular cell
     (which coordinate direction has the largest normal component). 
     This will only be called if the cell is irregular.
   */
     virtual
  pair<int, Side::LoHiSide>  upDirection(const RealVect& a_midpt,const IntVect& a_iv)  const; 

  
  //     Return the value at the dependent coordinate given the independent
  //  coordinates. Returns C_z+sqrt (radius-(x-C_x)squared+(y-C_y)squared));
  //  Where the center is (C_x,C_y,C_z)
   
  
  virtual Real localFuncValue(const RealVect& a_independentCoords, 
                              const int& a_upDirection,
                              const IntVect& a_iv, 
                              const Box& a_domain, 
                              const RealVect& a_origin, 
                              const Real& a_dx) const;  

 
  
  //   Return a newly allocated derived class.  The responsibility
  //  for deleting the memory is left to the calling function.
  
  virtual
  BaseLevelSet* new_baseLevelSet() const;   
  // calculates the max coordiante of a RealVect
  virtual Real max(const RealVect& vec)const;
  // calculates the magnitude of a RealVect
  virtual Real magnitude(const RealVect& vec)const;
 
 
protected:
  
  int m_ncols, m_nrows,m_NODATA;
  Real m_xllcorner,m_yllcorner,m_cellsize ,m_cellvalue;
  Real **m_DEM;
  Real m_dx;
  RealVect m_vectDx;
  IntVect m_ncell;
  int m_interpType;
  Real m_highground;
  Real m_minDEM;
  Real m_maxDEM;


private:
  DEMBL()
  {
    MayDay::Error("DEMBL uses strong construction");
  }
  DEMBL(const DEMBL& a_radius)
  {
    MayDay::Error("sphereBaselevel disallows copy construction");
  }
  void operator=(const DEMBL& a_radius)
  {
    MayDay::Error("DEMBL disallows assignment");
  }

};
#endif

---