radiation_band.hpp

Go to the documentation of this file.

#ifndef SRC_HARP_RADIATION_BAND_HPP_
#define SRC_HARP_RADIATION_BAND_HPP_
 
// C/C++ headers
#include <map>
#include <memory>
#include <string>
#include <vector>
 
// external
#include <yaml-cpp/yaml.h>
 
// athena
#include <athena/athena.hpp>  // Real
 
// canoe
#include <air_parcel.hpp>
#include <common.hpp>
#include <virtual_groups.hpp>
 
// harp
#include "spectral_grid.hpp"
 
// exchanger
#include <exchanger/linear_exchanger.hpp>
 
class OutputParameters;
class Absorber;
class SpectralGridBase;
struct Direction;
 
class RadiationBand : public NamedGroup,
                      public FlagGroup,
                      public ParameterGroup,
                      public ASCIIOutputGroup,
                      public LinearExchanger<RadiationBand> {
 public:  // public access data
  // implementation of RT Solver
  class RTSolver;
  class RTSolverLambert;
  class RTSolverDisort;
 
  AthenaArray<Real> btau;
 
  AthenaArray<Real> bssa;
 
  AthenaArray<Real> bpmom;
 
  AthenaArray<Real> bflxup;
 
  AthenaArray<Real> bflxdn;
 
  AthenaArray<Real> btoa;
 
 public:  // constructor and destructor
  RadiationBand(std::string name, YAML::Node const &rad);
  virtual ~RadiationBand();
 
 public:  // member functions
  void Resize(int nc1, int nc2 = 1, int nc3 = 1, int nstr = 8);
 
  void ResizeSolver(int nlyr, int nstr = 8, int nuphi = 1, int numu = 1);
 
  std::shared_ptr<RTSolver> CreateRTSolverFrom(std::string const &name,
                                               YAML::Node const &rad);
 
  size_t GetNumSpecGrids() const { return pgrid_->spec.size(); }
 
  size_t GetNumAbsorbers() const { return absorbers_.size(); }
 
  size_t GetNumPhaseMoments() const { return pmom_.GetDim1() - 1; }
 
  size_t GetNumLayers() const { return tem_.size() - 2 * NGHOST; }
 
  std::pair<Real, Real> GetRange() const { return wrange_; }
 
  std::shared_ptr<Absorber> GetAbsorber(int i) { return absorbers_[i]; }
 
  std::shared_ptr<Absorber> GetAbsorberByName(std::string const &name);
 
  size_t GetNumOutgoingRays() { return rayOutput_.size(); }
 
  Real GetCosinePolarAngle(int n) const { return rayOutput_[n].mu; }
 
  Real GetAzimuthalAngle(int n) const { return rayOutput_[n].phi; }
 
 public:  // inbound functions
  void SetSpectralProperties(AirColumn &air, Coordinates const *pcoord,
                             Real grav, int k, int j);
 
  void CalBandFlux(MeshBlock const *pmb, int k, int j, int il, int iu);
 
  void CalBandRadiance(MeshBlock const *pmb, int k, int j);
 
  void SetOutgoingRays(std::vector<Direction> const &ray) { rayOutput_ = ray; }
 
 public:  // ASCIIOutputGroup functions
  void WriteAsciiHeader(OutputParameters const *) const override;
  void WriteAsciiData(OutputParameters const *) const override;
 
 public:  // Exchanger functions
  void PackTemperature();
 
  bool UnpackTemperature(void *arg);
 
  void PackSpectralGrid(int b);
 
  bool UnpackSpectralGrid(void *arg);
 
  void Transfer(MeshBlock const *pmb, int n) override;
 
 protected:
  std::shared_ptr<RTSolver> psolver_;
 
  std::shared_ptr<SpectralGridBase> pgrid_;
 
  std::pair<Real, Real> wrange_;
 
  std::vector<std::shared_ptr<Absorber>> absorbers_;
 
  std::vector<Direction> rayOutput_;
 
  AthenaArray<Real> tau_;
 
  AthenaArray<Real> ssa_;
 
  AthenaArray<Real> toa_;
 
  AthenaArray<Real> flxup_;
 
  AthenaArray<Real> flxdn_;
 
  AthenaArray<Real> pmom_;
 
  std::vector<Real> tem_;
 
  std::vector<Real> temf_;
};
 
using RadiationBandPtr = std::shared_ptr<RadiationBand>;
using RadiationBandContainer = std::vector<RadiationBandPtr>;
 
class RadiationBandsFactory {
 public:
  static RadiationBandContainer CreateFrom(ParameterInput *pin,
                                           std::string key);
  static RadiationBandContainer CreateFrom(std::string filename);
};
 
#endif  // SRC_HARP_RADIATION_BAND_HPP_