ThermochimicaData.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
// MOOSE includes
#include "NodalUserObject.h"
#include "ElementUserObject.h"
 
// Forward declaration
class ChemicalCompositionAction;
 
template <bool is_nodal>
using ThermochimicaDataBaseParent =
    typename std::conditional<is_nodal, NodalUserObject, ElementUserObject>::type;
 
template <bool is_nodal>
class ThermochimicaDataBase : public ThermochimicaDataBaseParent<is_nodal>
{
public:
  static InputParameters validParams();
  ThermochimicaDataBase(const InputParameters & parameters);
  ~ThermochimicaDataBase();
 
  virtual void initialize() override;
  virtual void execute() override;
  virtual void finalize() override {}
  virtual void threadJoin(const UserObject &) override {}
 
  void reinitDataMooseFromTc();
 
  void reinitDataMooseToTc();
 
  struct Data
  {
    int _reinit_available;
    int _elements;
    int _species;
    std::vector<int> _elements_used;
    std::vector<int> _assemblage;
    std::vector<double> _moles_phase;
    std::vector<double> _element_potential;
    std::vector<double> _chemical_potential;
    std::vector<double> _mol_fraction;
  };
 
  const Data & getNodalData(dof_id_type id) const;
  const Data & getElementData(dof_id_type id) const;
 
  // universal data access
  const Data & getData(dof_id_type id) const;
 
protected:
  // child process routine to dispatch thermochimica calculations
  void server();
 
  // helper to wait on a socket read
  template <typename T>
  void expect(T expect_msg);
 
  // send message to socket
  template <typename T>
  void notify(T send_msg);
 
  const VariableValue & _pressure;
  const VariableValue & _temperature;
 
  const std::size_t _n_phases;
  const std::size_t _n_species;
  const std::size_t _n_elements;
  const std::size_t _n_vapor_species;
  const std::size_t _n_phase_elements;
  const std::size_t _n_potentials;
 
  std::vector<const VariableValue *> _el;
 
  const ChemicalCompositionAction & _action;
  std::vector<unsigned int> _el_ids;
 
  // re-initialization data
  const enum class ReinitializationType { NONE, TIME, NODE } _reinit;
 
  const std::vector<std::string> & _ph_names;
  const std::vector<std::string> & _element_potentials;
  const std::vector<std::pair<std::string, std::string>> & _species_phase_pairs;
  const std::vector<std::pair<std::string, std::string>> & _vapor_phase_pairs;
  const std::vector<std::pair<std::string, std::string>> & _phase_element_pairs;
 
  std::unordered_map<dof_id_type, Data> _data;
 
  const bool _output_element_potentials;
  const bool _output_vapor_pressures;
  const bool _output_element_phases;
 
  std::vector<MooseWritableVariable *> _ph;
 
  std::vector<MooseWritableVariable *> _sp;
 
  std::vector<MooseWritableVariable *> _vp;
 
  std::vector<MooseWritableVariable *> _el_pot;
 
  std::vector<MooseWritableVariable *> _el_ph;
 
  const enum class OutputMassUnit { MOLES, FRACTION } _output_mass_unit;
 
  int _socket;
 
  pid_t _pid;
 
  dof_id_type * _shared_dofid_mem;
 
  Real * _shared_real_mem;
 
  // current node or element ID
  dof_id_type _current_id;
 
  using ThermochimicaDataBaseParent<is_nodal>::isCoupled;
  using ThermochimicaDataBaseParent<is_nodal>::isParamValid;
  using ThermochimicaDataBaseParent<is_nodal>::coupledValue;
  using ThermochimicaDataBaseParent<is_nodal>::coupledComponents;
  using ThermochimicaDataBaseParent<is_nodal>::writableVariable;
};
 
typedef ThermochimicaDataBase<true> ThermochimicaNodalData;
typedef ThermochimicaDataBase<false> ThermochimicaElementData;