ABLForcingAlgorithm.h

Go to the documentation of this file.

#ifndef ABLFORCINGALGORITHM_H
#define ABLFORCINGALGORITHM_H

#include "NaluParsing.h"
#include "FieldTypeDef.h"

#include "stk_mesh/base/Selector.hpp"

#include <string>
#include <vector>
#include <stdexcept>
#include <sstream>
#include <unordered_set>

namespace sierra {
namespace nalu {

class Realm;
class Transfer;
class Transfers;

class ABLForcingAlgorithm
{
public:
  template <typename T>
  using Array2D = std::vector<std::vector<T>>;

  enum ABLForcingTypes {
    OFF = 0,              
    USER_DEFINED = 1,     
    COMPUTED = 2,         
    NUM_ABL_FORCING_TYPES 
  };

  ABLForcingAlgorithm(Realm&, const YAML::Node&);

  ~ABLForcingAlgorithm();

  void load(const YAML::Node&);

  void setup();

  void initialize();

  void execute();

  void eval_momentum_source(
    const double,        
    std::vector<double>& 
    );

  void eval_temperature_source(
    const double, 
    double&       
    );

  inline stk::mesh::Selector& inactive_selector() { return inactiveSelector_; }

  inline bool momentumForcingOn() { return (momSrcType_ != OFF); }

  inline bool temperatureForcingOn() { return (tempSrcType_ != OFF); }

  inline bool ablForcingOn()
  {
    return (momentumForcingOn() || temperatureForcingOn());
  }

private:
  ABLForcingAlgorithm();
  ABLForcingAlgorithm(const ABLForcingAlgorithm&);

  void load_momentum_info(const YAML::Node&);

  void load_temperature_info(const YAML::Node&);

  void create_interp_arrays(
    const std::vector<double>::size_type,
    const Array2D<double>&,
    std::vector<double>&,
    Array2D<double>&);

  void determine_part_names(
    std::vector<double>&, std::vector<std::string>&, bool, std::string&);

  void register_fields();

  void create_transfers();

  void populate_transfer_data(std::string, const std::vector<std::string>&);

  void compute_momentum_sources();

  void compute_temperature_sources();

  void calc_mean_velocity();

  void calc_mean_temperature();

  Realm& realm_;

  ABLForcingTypes momSrcType_;

  ABLForcingTypes tempSrcType_;

  double alphaMomentum_;

  double alphaTemperature_;

  std::vector<double> velHeights_; // Array of shape [num_Uheights]

  std::vector<double> tempHeights_; // Array of shape [num_Theights]

  std::vector<double> velXTimes_; // Arrays of shape [num_Utimes]
  std::vector<double> velYTimes_;
  std::vector<double> velZTimes_;

  std::vector<double> tempTimes_; // Array of shape [num_Ttimes]

  // The following arrays are shaped [num_UHeights, num_Utimes]
  Array2D<double> velX_;
  Array2D<double> velY_;
  Array2D<double> velZ_;
  // The temperature array is shaped [num_Theights, num_Ttimes]
  Array2D<double> temp_;

  Array2D<double> UmeanCalc_;

  Array2D<double> USource_;

  std::vector<double> TmeanCalc_;

  std::vector<double> TSource_;

  std::string searchMethod_;
  double searchTolerance_;
  double searchExpansionFactor_;

  std::vector<std::string> fromTargetNames_;

  std::vector<std::string> velPartNames_;
  std::vector<std::string> tempPartNames_;
  std::unordered_set<std::string> allPartNames_;

  stk::mesh::PartVector allParts_;
  stk::mesh::Selector inactiveSelector_;

  Transfers* transfers_;

  bool velGenPartList_;

  bool tempGenPartList_;

  std::string velPartFmt_;

  std::string tempPartFmt_;

  int outputFreq_;

  std::string outFileFmt_;
};
}
}

#endif /* ABLFORCINGALGORITHM_H */