ComplexSurfaceFlux.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 _COMPLEXSURFACEFLUX_H_
#define _COMPLEXSURFACEFLUX_H_

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



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

  virtual ~fortranInterfaceFlux() {}

  virtual SurfaceFlux* new_surfaceFlux();

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

  void setFluxVal(Real* a_data_ptr,
                  const int* a_dimInfo,
                  const int* a_boxlo, const int* a_boxhi, 
                  const Real* a_dew, const Real* a_dns,
                  const IntVect& a_offset,
                  const IntVect& a_nGhost,
                  const ProblemDomain& a_domain,
                  const bool a_nodal);
    

  bool gridsSet() const {return m_gridsSet;}


protected:
  IntVect m_fluxGhost;
  bool m_verbose;

  ProblemDomain m_domain;
  DisjointBoxLayout m_grids;
  bool m_gridsSet;

  // input flux from CISM
  // alias to data array passed in from CISM
  FArrayBox m_inputFlux;
  bool m_nodalFlux;


  FArrayBox m_ccInputFlux;

  RealVect m_inputFluxDx;

  RefCountedPtr<LevelData<FArrayBox> > m_inputFluxLDF;

  bool m_isValSet;

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

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


class ProductSurfaceFlux : public SurfaceFlux
{

public:
  
  ProductSurfaceFlux(SurfaceFlux* a_Flux1, SurfaceFlux* a_flux2);

  virtual ~ProductSurfaceFlux();

  virtual SurfaceFlux* new_surfaceFlux();

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


protected:
  SurfaceFlux* m_flux1;
  SurfaceFlux* m_flux2;

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

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

  ProductSurfaceFlux()
  {
    MayDay::Error("invalid operator");
  }

};
  

class MaskedFlux : public SurfaceFlux
{

public:

  MaskedFlux(SurfaceFlux* a_groundedIceFlux, SurfaceFlux* a_floatingIceFlux,
             SurfaceFlux* a_openSeaFlux, SurfaceFlux* a_openLandFlux);

  virtual ~MaskedFlux(){};

  virtual SurfaceFlux* new_surfaceFlux();

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


protected:
  SurfaceFlux* m_groundedIceFlux;
  SurfaceFlux* m_floatingIceFlux;
  SurfaceFlux* m_openSeaFlux;
  SurfaceFlux* m_openLandFlux;
  
private:
  // Disallowed for all the usual reasons
  void operator=(const MaskedFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

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

  MaskedFlux()
  {
    MayDay::Error("invalid operator");
  }

};
  


class BoxBoundedFlux : public SurfaceFlux
{
  RealVect m_lo,m_hi;
  Real m_startTime, m_endTime;
  SurfaceFlux* m_fluxPtr;
public:
  BoxBoundedFlux
(const RealVect& a_lo,
 const RealVect& a_hi,
 const Real& a_startTime,
 const Real& a_endTime,
 SurfaceFlux* a_fluxPtr)
    : m_lo(a_lo),m_hi(a_hi),m_startTime(a_startTime),m_endTime(a_endTime)
  {
    m_fluxPtr = a_fluxPtr->new_surfaceFlux();
    if (!(m_hi > m_lo))
      {
        pout() <<  "!(m_hi > m_lo), m_lo = " << m_lo << " m_hi = " << m_hi << endl;
        CH_assert( (m_hi > m_lo) );
        MayDay::Error("BoxBoundedFlux::  !(m_hi > m_lo)");
      }
  }
  

  virtual ~BoxBoundedFlux(){};

  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 BoxBoundedFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

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

  BoxBoundedFlux()
  {
    MayDay::Error("invalid operator");
  }

};


class AxbyFlux : public SurfaceFlux
{
  SurfaceFlux* m_x;
  SurfaceFlux* m_y;
  Real m_a,m_b;
  
public:

  AxbyFlux(const Real& a_a, SurfaceFlux* a_x, 
           const Real& a_b, SurfaceFlux* a_y);

  virtual ~AxbyFlux();

  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 AxbyFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

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

  AxbyFlux()
  {
    MayDay::Error("invalid operator");
  }

};



class CompositeFlux : public SurfaceFlux
{
  
  Vector<SurfaceFlux*> m_fluxes;

public:
  CompositeFlux(const Vector<SurfaceFlux*>& a_fluxes);

  virtual ~CompositeFlux();

  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 CompositeFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

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

  CompositeFlux()
  {
    MayDay::Error("invalid operator");
  }


};


class PiecewiseLinearFlux : public SurfaceFlux
{
public:

  PiecewiseLinearFlux(const Vector<Real>& a_abscissae, 
                      const Vector<Real>& a_ordinates,
                      const Real a_minWaterDepth = -1.0);

  ~PiecewiseLinearFlux(){};

  virtual SurfaceFlux* new_surfaceFlux();

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

protected:
  Vector<Real> m_abscissae;
  Vector<Real> m_ordinates;
  Real m_minWaterDepth;

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

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

  PiecewiseLinearFlux()
  {
    MayDay::Error("invalid operator");
  }

};



class NormalizedFlux : public SurfaceFlux
{
  
  SurfaceFlux* m_direction;
  Real m_amplitude;

public:

  NormalizedFlux(SurfaceFlux* a_direction, const Real& a_amplitude);

  virtual ~NormalizedFlux();

  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 NormalizedFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

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

  NormalizedFlux()
  {
    MayDay::Error("invalid operator");
  }


};

typedef NormalizedFlux NormalizedData;



class FloatingDivUHLocalizedFlux : public SurfaceFlux
{
  
  SurfaceFlux* m_flux;
  Real m_mesh_spacing;
 
public:

  FloatingDivUHLocalizedFlux(SurfaceFlux* a_flux, const Real& a_mesh_spacing);

  virtual ~FloatingDivUHLocalizedFlux();

  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 FloatingDivUHLocalizedFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

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

  FloatingDivUHLocalizedFlux()
  {
    MayDay::Error("invalid operator");
  }


};




class TargetThicknessFlux : public SurfaceFlux
{
  
  SurfaceFlux* m_target;
  Real m_timescale;

public:

  TargetThicknessFlux(SurfaceFlux* a_target, const Real& a_timescale);

  virtual ~TargetThicknessFlux();

  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 TargetThicknessFlux& a_input)
  {
    MayDay::Error("invalid operator");
  }

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

  TargetThicknessFlux()
  {
    MayDay::Error("invalid operator");
  }


};


#include "NamespaceFooter.H"
#endif // multiple-include preventer