src/coupler/PISMSurface.hh

Go to the documentation of this file.

// Copyright (C) 2008-2011 Ed Bueler, Constantine Khroulev, Ricarda Winkelmann,
// Gudfinna Adalgeirsdottir and Andy Aschwanden
//
// This file is part of PISM.
//
// PISM is free software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the Free Software
// Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// PISM is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License
// along with PISM; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef __PISMSurfaceModel_hh
#define __PISMSurfaceModel_hh

#include "PISMComponent.hh"
#include "iceModelVec.hh"
#include "PISMAtmosphere.hh"
#include "localMassBalance.hh"

class PISMSurfaceModel : public PISMComponent_TS {
public:
  PISMSurfaceModel(IceGrid &g, const NCConfigVariable &conf)
    : PISMComponent_TS(g, conf)
  { atmosphere = NULL; };

  virtual ~PISMSurfaceModel()
  { delete atmosphere; };

  virtual void get_diagnostics(map<string, PISMDiagnostic*> &dict)
  { if (atmosphere)  atmosphere->get_diagnostics(dict); }

  virtual PetscErrorCode init(PISMVars &vars);
  virtual void attach_atmosphere_model(PISMAtmosphereModel *input);
  virtual PetscErrorCode ice_surface_mass_flux(IceModelVec2S &result) = 0;
  virtual PetscErrorCode ice_surface_temperature(IceModelVec2S &result) = 0;
  virtual PetscErrorCode ice_surface_liquid_water_fraction(IceModelVec2S &result);
  virtual PetscErrorCode mass_held_in_surface_layer(IceModelVec2S &result);
  virtual PetscErrorCode surface_layer_thickness(IceModelVec2S &result);

  virtual PetscErrorCode define_variables(set<string> vars, const NCTool &nc, nc_type nctype);
  virtual PetscErrorCode write_variables(set<string> vars, string filename);
protected:
  PISMAtmosphereModel *atmosphere;
};



class PSDummy : public PISMSurfaceModel {
public:
  PSDummy(IceGrid &g, const NCConfigVariable &conf)
    : PISMSurfaceModel(g, conf)
  {};

  virtual void attach_atmosphere_model(PISMAtmosphereModel *input)
  { delete input; }

  virtual PetscErrorCode init(PISMVars &) { return 0; };
  virtual PetscErrorCode update(PetscReal t_years, PetscReal dt_years)
  { t = t_years; dt = dt_years; return 0; } // do nothing
  virtual PetscErrorCode ice_surface_mass_flux(IceModelVec2S&)
  { return 0; }

  virtual PetscErrorCode ice_surface_temperature(IceModelVec2S &)
  { return 0; }
  virtual void add_vars_to_output(string /*keyword*/, set<string> &/*result*/) {}
  virtual PetscErrorCode define_variables(set<string> /*vars*/, const NCTool &/*nc*/, nc_type /*nctype*/)
  { return 0; }
  virtual PetscErrorCode write_variables(set<string>, string)
  { return 0; }

  // Does not have an atmosphere model.
  virtual void get_diagnostics(map<string, PISMDiagnostic*> &/*dict*/) {}
};



class PSSimple : public PISMSurfaceModel {
public:
  PSSimple(IceGrid &g, const NCConfigVariable &conf)
    : PISMSurfaceModel(g, conf) {};
  virtual PetscErrorCode init(PISMVars &vars);
  virtual PetscErrorCode update(PetscReal t_years, PetscReal dt_years)
  {
    t = t_years; dt = dt_years;
    if (atmosphere) {
      PetscErrorCode ierr = atmosphere->update(t_years, dt_years); CHKERRQ(ierr);
    }
    return 0;
  }
  virtual PetscErrorCode ice_surface_mass_flux(IceModelVec2S &result);
  virtual PetscErrorCode ice_surface_temperature(IceModelVec2S &result);
  virtual void add_vars_to_output(string keyword, set<string> &result);
};



class PSConstant : public PISMSurfaceModel {
public:
  PSConstant(IceGrid &g, const NCConfigVariable &conf)
    : PISMSurfaceModel(g, conf)
  {};

  virtual PetscErrorCode init(PISMVars &vars);
  virtual PetscErrorCode update(PetscReal t_years, PetscReal dt_years)
  { t = t_years; dt = dt_years; return 0; } // do nothing
  virtual void attach_atmosphere_model(PISMAtmosphereModel *input)
  { delete input; }

  // Does not have an atmosphere model.
  virtual void get_diagnostics(map<string, PISMDiagnostic*> &/*dict*/) {}

  virtual PetscErrorCode ice_surface_mass_flux(IceModelVec2S &result);
  virtual PetscErrorCode ice_surface_temperature(IceModelVec2S &result);
  virtual PetscErrorCode define_variables(set<string> vars, const NCTool &nc, nc_type nctype);
  virtual PetscErrorCode write_variables(set<string> vars, string filename);
  virtual void add_vars_to_output(string keyword, set<string> &result);
protected:
  string input_file;
  IceModelVec2S acab, artm;
};



class PSTemperatureIndex : public PISMSurfaceModel {
public:
  PSTemperatureIndex(IceGrid &g, const NCConfigVariable &conf);
  virtual ~PSTemperatureIndex();
  virtual PetscErrorCode update(PetscReal t_years, PetscReal dt_years);
  virtual PetscErrorCode init(PISMVars &vars);
  virtual PetscErrorCode max_timestep(PetscReal t_years, PetscReal &dt_years);
  virtual PetscErrorCode ice_surface_mass_flux(IceModelVec2S &result);
  virtual PetscErrorCode ice_surface_temperature(IceModelVec2S &result);
  virtual void add_vars_to_output(string keyword, set<string> &result);
  virtual PetscErrorCode define_variables(set<string> vars, const NCTool &nc, nc_type nctype);  
  virtual PetscErrorCode write_variables(set<string> vars, string filename);
protected:
  virtual PetscErrorCode update_internal(PetscReal t_years, PetscReal dt_years);
  LocalMassBalance *mbscheme;         

  FaustoGrevePDDObject *faustogreve;  

  DegreeDayFactors base_ddf;          
  PetscScalar  base_pddStdDev,        
               base_pddThresholdTemp; 
  IceModelVec2S
    acab,               
    accumulation_rate,  
    melt_rate,          

    runoff_rate;        

  IceModelVec2S *lat, *lon, *usurf;  



  bool pdd_annualize;
  PetscReal next_pdd_update_year;
};


class PSModifier : public Modifier<PISMSurfaceModel>
{
public:
  PSModifier(IceGrid &g, const NCConfigVariable &conf, PISMSurfaceModel* in)
    : Modifier<PISMSurfaceModel>(g, conf, in) {}
  virtual ~PSModifier() {}

  virtual void attach_atmosphere_model(PISMAtmosphereModel *in) {
    input_model->attach_atmosphere_model(in);
  }

  virtual PetscErrorCode ice_surface_mass_flux(IceModelVec2S &result)
  {
    PetscErrorCode ierr = input_model->ice_surface_mass_flux(result); CHKERRQ(ierr);
    return 0;
  }

  virtual PetscErrorCode ice_surface_temperature(IceModelVec2S &result)
  {
    PetscErrorCode ierr = input_model->ice_surface_temperature(result); CHKERRQ(ierr);
    return 0;
  }

  virtual PetscErrorCode ice_surface_liquid_water_fraction(IceModelVec2S &result)
  {
    PetscErrorCode ierr = input_model->ice_surface_liquid_water_fraction(result); CHKERRQ(ierr);
    return 0;
  }

  virtual PetscErrorCode mass_held_in_surface_layer(IceModelVec2S &result)
  {
    PetscErrorCode ierr = input_model->mass_held_in_surface_layer(result); CHKERRQ(ierr);
    return 0;
  }

  virtual PetscErrorCode surface_layer_thickness(IceModelVec2S &result)
  {
    PetscErrorCode ierr = input_model->surface_layer_thickness(result); CHKERRQ(ierr);
    return 0;
  }
};

class PSForceThickness : public PSModifier {
public:
  PSForceThickness(IceGrid &g, const NCConfigVariable &conf, PISMSurfaceModel *input)
    : PSModifier(g, conf, input)
  {
    ice_thickness = NULL;
    alpha = config.get("force_to_thickness_alpha");
  }

  virtual ~PSForceThickness() {}
  PetscErrorCode init(PISMVars &vars);
  virtual void attach_atmosphere_model(PISMAtmosphereModel *input);
  virtual PetscErrorCode ice_surface_mass_flux(IceModelVec2S &result);
  virtual PetscErrorCode ice_surface_temperature(IceModelVec2S &result);
  virtual PetscErrorCode max_timestep(PetscReal t_years, PetscReal &dt_years);
  virtual void add_vars_to_output(string keyword, set<string> &result);
  virtual PetscErrorCode define_variables(set<string> vars, const NCTool &nc, nc_type nctype);
  virtual PetscErrorCode write_variables(set<string> vars, string filename);
protected:
  string input_file;
  PetscReal alpha;
  IceModelVec2S *ice_thickness; 
  IceModelVec2S target_thickness, ftt_mask, ftt_modified_acab;
};


class PSConstantPIK : public PISMSurfaceModel {
public:
  PSConstantPIK(IceGrid &g, const NCConfigVariable &conf)
    : PISMSurfaceModel(g, conf)
  {};

  virtual PetscErrorCode init(PISMVars &vars);
  virtual void attach_atmosphere_model(PISMAtmosphereModel *input)
  { delete input; }

  // Does not have an atmosphere model.
  virtual void get_diagnostics(map<string, PISMDiagnostic*> &/*dict*/) {}

  virtual PetscErrorCode update(PetscReal t_years, PetscReal dt_years)
  { t = t_years; dt = dt_years; return 0; } // do nothing
  virtual PetscErrorCode ice_surface_mass_flux(IceModelVec2S &result);
  virtual PetscErrorCode ice_surface_temperature(IceModelVec2S &result);
  virtual PetscErrorCode define_variables(set<string> vars, const NCTool &nc, nc_type nctype);
  virtual PetscErrorCode write_variables(set<string> vars, string filename);
  virtual void add_vars_to_output(string keyword, set<string> &result);
protected:
  string input_file;
  IceModelVec2S acab, artm;
  IceModelVec2S *lat, *usurf;

};


#endif  // __PISMSurfaceModel_hh