SeaLevel.cc

Go to the documentation of this file.

/* Copyright (C) 2018, 2019, 2021, 2023, 2025, 2026 PISM Authors
 *
 * 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 3 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
 */
 
#include "pism/coupler/SeaLevel.hh"
 
#include "pism/util/MaxTimestep.hh"
 
#include "pism/util/pism_utilities.hh" // combine
#include "pism/util/Logger.hh"
 
namespace pism {
namespace ocean {
namespace sea_level {
 
// "Modifier" constructor.
SeaLevel::SeaLevel(std::shared_ptr<const Grid> grid, std::shared_ptr<SeaLevel> input)
  : Component(grid),
    m_input_model(input),
    m_sea_level(grid, "sea_level") {
 
  m_sea_level.metadata(0)
      .long_name("sea level elevation, relative to the geoid")
      .units("meter");
}
 
// "Model" constructor (returns sea level is zero).
SeaLevel::SeaLevel(std::shared_ptr<const Grid> g)
  : SeaLevel(g, std::shared_ptr<SeaLevel>()) {
  // empty
}
 
void SeaLevel::init(const Geometry &geometry) {
  init_impl(geometry);
}
 
void SeaLevel::init_impl(const Geometry &geometry) {
  if (m_input_model) {
    m_input_model->init(geometry);
  } else {
    double z_s = m_config->get_number("sea_level.constant.value");
    m_sea_level.set(z_s);
    m_log->message(2, "* Using constant sea level at %f meters...\n", z_s);
  }
}
 
void SeaLevel::update(const Geometry &geometry, double t, double dt) {
  update_impl(geometry, t, dt);
}
 
void SeaLevel::update_impl(const Geometry &geometry, double t, double dt) {
  if (m_input_model) {
    m_input_model->update(geometry, t, dt);
  } else {
    double z_s = m_config->get_number("sea_level.constant.value");
    m_sea_level.set(z_s);
  }
}
 
const array::Scalar& SeaLevel::elevation() const {
  return m_sea_level;
}
 
MaxTimestep SeaLevel::max_timestep_impl(double t) const {
  if (m_input_model) {
    return m_input_model->max_timestep(t);
  }
  return MaxTimestep("sea level forcing");
}
 
std::set<VariableMetadata> SeaLevel::state_impl() const {
  if (m_input_model) {
    return m_input_model->state();
  }
  return {};
}
 
void SeaLevel::write_state_impl(const OutputFile &output) const {
  if (m_input_model) {
    m_input_model->write_state(output);
  }
}
 
namespace diagnostics {
 
/*! @brief Sea level elevation. */
class SL : public Diag<SeaLevel> {
public:
  SL(const SeaLevel *m) : Diag<SeaLevel>(m) {
    m_vars = { { m_sys, "sea_level", *m_grid } };
    m_vars[0].long_name("sea level elevation, relative to the geoid").units("meters");
  }
 
protected:
  std::shared_ptr<array::Array> compute_impl() const {
    auto result = allocate<array::Scalar>("sea_level");
 
    result->copy_from(model->elevation());
 
    return result;
  }
};
 
} // end of namespace diagnostics
 
DiagnosticList SeaLevel::spatial_diagnostics_impl() const {
  DiagnosticList result = {
    {"sea_level", Diagnostic::Ptr(new diagnostics::SL(this))},
  };
 
  if (m_input_model) {
    return combine(result, m_input_model->spatial_diagnostics());
  } else {
    return result;
  }
}
 
TSDiagnosticList SeaLevel::scalar_diagnostics_impl() const {
  if (m_input_model) {
    return m_input_model->scalar_diagnostics();
  } else {
    return {};
  }
}
 
} // end of namespace sea_level
} // end of namespace ocean
} // end of namespace pism