BasalFrictionRelation.H

Go to the documentation of this file.

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

#ifndef _BASALFRICTIONRELATION_H_
#define _BASALFRICTIONRELATION_H_

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

class LevelSigmaCS;
class DataIterator;


class BasalFrictionRelation
{
public:

  virtual ~BasalFrictionRelation() {;}

  

  virtual void updateThermodynamics( Vector<LevelData<FArrayBox>* >* a_tillWaterDepth )
  {
  }

    
  

  virtual void computeAlpha(FArrayBox& a_alpha,
                            const FArrayBox& a_basalVel,
                            const FArrayBox& a_C, const Real& a_scale,
                            const LevelSigmaCS& a_coords, 
                            const DataIterator& a_dit,
                            int a_level,
                            const Box& a_box) const = 0;
  

  virtual void computeDissipation(FArrayBox& a_dissipation,  
                                  const FArrayBox& a_basalVel,
                                  const FArrayBox& a_C, const Real& a_scale,
                                  const LevelSigmaCS& a_coords, 
                                  const DataIterator& a_dit,
                                  int a_level,
                                  const Box& a_box) const;

  
  virtual BasalFrictionRelation* getNewBasalFrictionRelation() const = 0;

  virtual Real power() const = 0;

  static BasalFrictionRelation* parse(const char* a_prefix, int a_recursion );

};



class BasalFrictionPowerLaw : public BasalFrictionRelation
{
public:

  BasalFrictionPowerLaw(Real a_m,
                        Real a_fastSlidingSpeed = -1.0,
                        Real a_highThickness = -1.0  ,
                        bool a_includeEffectivePressure = false) 
    : m_m(a_m),  m_includeEffectivePressure(a_includeEffectivePressure) ,
      m_fastSlidingSpeed(a_fastSlidingSpeed), m_highThickness(a_highThickness)
  {;}
  
  virtual ~BasalFrictionPowerLaw() {;}

  virtual void computeAlpha(FArrayBox& a_alpha,
                            const FArrayBox& a_basalVel,
                            const FArrayBox& a_C, const Real& a_scale,
                            const LevelSigmaCS& a_coords, 
                            const DataIterator& a_dit,
                            int a_level,
                            const Box& a_box) const;

  BasalFrictionRelation* getNewBasalFrictionRelation() const{
    return static_cast<BasalFrictionRelation*> (new BasalFrictionPowerLaw(m_m, m_fastSlidingSpeed, m_highThickness, m_includeEffectivePressure));
  }

  virtual Real power() const {return m_m;}
  
private:
  Real m_m;
  bool m_includeEffectivePressure;
  Real m_fastSlidingSpeed; // a scale u_r for fast flow : u >> u_r -> Tb -> a constant
  Real m_highThickness; // a scale for thickness above flotation
  BasalFrictionPowerLaw();

};


class PressureLimitedBasalFrictionRelation : public BasalFrictionRelation
{

public:
  enum Model {Tsai,Leguy,MAX_MODEL};

private:
  Real m_a, m_p, m_maxTillWaterDepth, m_tillPressureFactor;
  Model m_model;
  Vector<LevelData<FArrayBox>* >* m_tillWaterDepth;
  BasalFrictionRelation* m_bfr; 
  
public:


  virtual void computeDissipation(FArrayBox& a_dissipation,  
                                  const FArrayBox& a_basalVel,
                                  const FArrayBox& a_C, const Real& a_scale,
                                  const LevelSigmaCS& a_coords, 
                                  const DataIterator& a_dit,
                                  int a_level,
                                  const Box& a_box) const;
  
  void updateThermodynamics( Vector<LevelData<FArrayBox>* >* a_tillWaterDepth  )
  {
    m_tillWaterDepth = a_tillWaterDepth;
  }
  virtual void computeAlpha(FArrayBox& a_alpha,
                            const FArrayBox& a_basalVel,
                            const FArrayBox& a_C, const Real& a_scale,
                            const LevelSigmaCS& a_coords, 
                            const DataIterator& a_dit,
                            int a_level,
                            const Box& a_box) const;


  PressureLimitedBasalFrictionRelation(Real a_a, Real a_p,  Real a_maxTillWaterDepth,
                                       Real a_tillPressureFactor, 
                                       Model a_model,  BasalFrictionRelation* a_bfr)
    : m_a(a_a), m_p(a_p), m_maxTillWaterDepth(a_maxTillWaterDepth),
      m_tillPressureFactor(a_tillPressureFactor),  m_model(a_model),  
      m_bfr(a_bfr->getNewBasalFrictionRelation())
  {

  }


  virtual BasalFrictionRelation* getNewBasalFrictionRelation() const
  {
    PressureLimitedBasalFrictionRelation* ptr = 
      new PressureLimitedBasalFrictionRelation(m_a, m_p, m_maxTillWaterDepth,m_tillPressureFactor ,
                                               m_model, m_bfr);

    return static_cast<BasalFrictionRelation*>(ptr);
  }
    

  virtual Real power() const
  {
    return m_bfr->power();
  }

};



#include "NamespaceFooter.H"

#endif