BasalFriction.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 coefficient of basal friction 
// for ice-sheet model

#ifndef _BASALFRICTION_H_
#define _BASALFRICTION_H_

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

#include "NamespaceHeader.H"


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


  virtual BasalFriction* new_basalFriction() const = 0;


  virtual void setBasalFriction(LevelData<FArrayBox>& a_betaSqr,
                                LevelSigmaCS& a_coordSys,
                                Real a_time,
                                Real a_dt) = 0;

  static BasalFriction *parse(const char* a_prefix, const RealVect& a_domainSize);

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

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


class zeroFriction : public BasalFriction
{
public:
  zeroFriction() {};

  ~zeroFriction() {};

  BasalFriction* new_basalFriction() const;

  void setBasalFriction(LevelData<FArrayBox>& a_betaSqr,
                                LevelSigmaCS& a_coordSys,
                                Real a_time,
                                Real a_dt);


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

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



class constantFriction : public BasalFriction
{
public:
  constantFriction();


  constantFriction(Real a_betaSqr);

  ~constantFriction() {}

  BasalFriction* new_basalFriction() const;

  void setBasalFriction(LevelData<FArrayBox>& a_betaSqr,
                                LevelSigmaCS& a_coordSys,
                                Real a_time,
                                Real a_dt);


  void setFrictionVal(const Real& a_betaSqr);

protected:

  Real m_frictionVal;
  bool m_isValSet;

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

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



class sinusoidalFriction : public BasalFriction
{
public:
  sinusoidalFriction();

  sinusoidalFriction(const Real& a_betaVal,
                     const RealVect& a_omega,
                     const Real& a_eps,
                     const RealVect& a_domainSize);
    
  virtual ~sinusoidalFriction();


  virtual BasalFriction* new_basalFriction() const;


  virtual void setBasalFriction(LevelData<FArrayBox>& a_betaSqr,
                                LevelSigmaCS& a_coordSys,
                                Real a_time,
                                Real a_dt);

  void setSinParameters(const Real& a_betaVal, 
                        const RealVect& a_omega,
                        const Real& a_eps,
                        const RealVect& a_domainSize);
   
  Real m_betaVal;
  RealVect m_omega;
  Real m_eps;
  RealVect m_domainSize;

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

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


#include "NamespaceFooter.H"


#endif // multiple-include preventer