SurfaceFlux.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

// Virtual base class encapsulating surface fluxes for ice-sheet model

#ifndef _SURFACEFLUX_H_
#define _SURFACEFLUX_H_

#include "LevelData.H"
#include "FArrayBox.H"
#include "LevelSigmaCS.H"
#include "NamespaceHeader.H"

class AmrIceBase;

class SurfaceFlux;

typedef SurfaceFlux SurfaceData;


class SurfaceFlux
{
  
public:
  
  virtual ~SurfaceFlux() {};

  virtual SurfaceFlux* new_surfaceFlux() = 0;


  virtual void surfaceThicknessFlux(LevelData<FArrayBox>& a_flux,
                                    const AmrIceBase& a_amrIce, 
                                    int a_level, Real a_dt) = 0;
  

  virtual void evaluate(LevelData<FArrayBox>& a_data,
                        const AmrIceBase& a_amrIce, 
                        int a_level, Real a_dt)
  {
    surfaceThicknessFlux(a_data, a_amrIce, a_level,a_dt);
  }



  static SurfaceFlux* parse(const char* a_prefix);

  // /// re-implement to set something up once 
  // virtual void init(const AmrIceBase& a_amrIce){};
  // /// re-implement to set something up once per time step, rather
  // /// than per-level per-timestep
  // virtual void initTimeStep(const AmrIceBase& a_amrIce){};

private:
  // Disallowed for all the usual reasons
  void operator=(const SurfaceFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

  // // Disallowed for all the usual reasons
  // SurfaceFlux(const SurfaceFlux& a_input)
  // {
  //   MayDay::Error("invalid operator");
  // }
};



class zeroFlux : public SurfaceFlux
{
public:
  zeroFlux() {};

  virtual ~zeroFlux() {};

  virtual SurfaceFlux* new_surfaceFlux();

  virtual void surfaceThicknessFlux(LevelData<FArrayBox>& a_flux,
                                    const AmrIceBase& a_amrIce, 
                                    int a_level, Real a_dt);

private:
  // Disallowed for all the usual reasons
  void operator=(const zeroFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

  // Disallowed for all the usual reasons
  zeroFlux(const zeroFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }
};


typedef zeroFlux ZeroData;


class constantFlux : public SurfaceFlux
{
public:
  constantFlux();

  constantFlux(const Real& a_fluxVal):
    m_fluxVal(a_fluxVal), m_isValSet(true){;};

  virtual ~constantFlux() {}

  virtual SurfaceFlux* new_surfaceFlux();

  virtual void surfaceThicknessFlux(LevelData<FArrayBox>& a_flux,
                                    const AmrIceBase& a_amrIce, 
                                    int a_level, Real a_dt);

  void setFluxVal(const Real& a_fluxVal);

protected:
  Real m_fluxVal;

  bool m_isValSet;

private:
  // Disallowed for all the usual reasons
  void operator=(const constantFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

  // Disallowed for all the usual reasons
  constantFlux(const constantFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }
};

typedef constantFlux ConstantData;


#include "NamespaceFooter.H"


#endif // multiple-include preventer