The ChemicalCompositionAction sets up user objects, aux kernels, and aux variables for a thermochemistry calculation using Thermochimica. More...

#include <ChemicalCompositionAction.h>

Inheritance diagram for ChemicalCompositionAction:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	ChemicalCompositionAction (const InputParameters &params)

const std::vector< unsigned int > &	elementIDs () const

const std::vector< std::string > &	phases () const

const std::vector< std::string > &	elementPotentials () const

const std::vector< std::pair< std::string, std::string > > &	speciesPhasePairs () const

const std::vector< std::pair< std::string, std::string > > &	vaporPhasePairs () const

const std::vector< std::pair< std::string, std::string > > &	phaseElementPairs () const

virtual void	act ()

void	timedAct ()

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

MooseObjectName	uniqueActionName () const

const std::string &	specificTaskName () const

const std::set< std::string > &	getAllTasks () const

void	appendTask (const std::string &task)

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &nm) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	mooseError (Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
void	readCSV ()

bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)

void	associateWithParameter (const std::string &param_name, InputParameters &params) const

void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::vector< std::string >	_elements
	Element names. More...

std::map< std::string, Real >	_initial_conditions
	Initial conditions for each element: [element name] => initial condition value. More...

std::vector< std::string >	_phases
	List of phases tracked by Thermochimica. More...

std::vector< unsigned int >	_element_ids
	Atomic numbers of the selected elements. More...

std::vector< std::pair< std::string, std::string > >	_tokenized_species
	Tokenized versions of the output variables to avoid redoing tokenization. More...

std::vector< std::string >	_tokenized_element_potentials

std::vector< std::pair< std::string, std::string > >	_tokenized_vapor_species

std::vector< std::pair< std::string, std::string > >	_tokenized_phase_elements

std::string	_registered_identifier

std::string	_specific_task_name

std::set< std::string >	_all_tasks

ActionWarehouse &	_awh

const std::string &	_current_task

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem

PerfID	_act_timer

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Detailed Description

The ChemicalCompositionAction sets up user objects, aux kernels, and aux variables for a thermochemistry calculation using Thermochimica.

Definition at line 19 of file ChemicalCompositionAction.h.

Constructor & Destructor Documentation

◆ ChemicalCompositionAction()

ChemicalCompositionAction::ChemicalCompositionAction ( const InputParameters & params )

Definition at line 88 of file ChemicalCompositionAction.C.

   : Action(parameters)
 {
   const auto & params = _app.getInputParameterWarehouse().getInputParameters();
   InputParameters & pars(*(params.find(uniqueActionName())->second.get()));
 
   // check if a container block with common parameters is found
   auto action = _awh.getActions<CommonChemicalCompositionAction>();
   if (action.size() == 1)
     pars.applyParameters(action[0]->parameters());
 
   if (!isParamValid("tunit"))
     paramError(
         "tunit",
         "The temperature unit must be specified for Thermochimica objects to be constructed");
 
   if (!isParamValid("punit"))
     paramError("punit",
                "The pressure unit must be specified for Thermochimica objects to be constructed");
 
   if (!isParamValid("munit"))
     paramError("munit",
                "The mass unit must be specified for Thermochimica objects to be constructed");
 
   if (!isParamValid("temperature"))
     paramError("temperature",
                "Temperature variable must be specified for this object to be constructed");
 
   if ((isParamValid("output_species") || isParamValid("output_element_phases")) &&
       !isParamValid("output_species_unit"))
     paramError(
         "output_species_unit",
         "Output mass unit must be specified for Thermochimica user object to be constructed");
 
   ThermochimicaUtils::checkLibraryAvailability(*this);
 
 #ifdef THERMOCHIMICA_ENABLED
   // Initialize database in Thermochimica
   if (isParamValid("thermofile"))
   {
     const auto thermo_file = getParam<FileName>("thermofile");
 
     if (thermo_file.length() > 1024)
       paramError("thermofile",
                  "Path exceeds Thermochimica's maximal permissible length of 1024 with ",
                  thermo_file.length(),
                  " characters: ",
                  thermo_file);
 
     Thermochimica::setThermoFilename(thermo_file);
 
     // Read in thermodynamics model for setting up variables
     Thermochimica::parseThermoFile();
 
     const auto idbg = Thermochimica::checkInfoThermo();
     if (idbg != 0)
       paramError("thermofile", "Thermochimica data file cannot be parsed. ", idbg);
   }
 
   // Set thermochimica units
   auto tunit = Moose::stringify(getParam<MooseEnum>("tunit"));
   Thermochimica::checkTemperature(tunit);
   Thermochimica::setUnitTemperature(tunit);
   int idbg = Thermochimica::checkInfoThermo();
   if (idbg != 0)
     paramError("tunit", "Cannot set temperature unit in Thermochimica", idbg);
 
   auto punit = Moose::stringify(getParam<MooseEnum>("punit"));
   Thermochimica::checkPressure(punit);
   Thermochimica::setUnitPressure(punit);
   idbg = Thermochimica::checkInfoThermo();
   if (idbg != 0)
     paramError("punit", "Cannot set pressure unit in Thermochimica", idbg);
 
   auto munit = Moose::stringify(getParam<MooseEnum>("munit"));
   std::replace(munit.begin(), munit.end(), '_', ' ');
   Thermochimica::checkMass(munit);
   Thermochimica::setUnitMass(munit);
   idbg = Thermochimica::checkInfoThermo();
   if (idbg != 0)
     paramError("munit", "Cannot set mass unit in Thermochimica", idbg);
 
   _elements = getParam<std::vector<std::string>>("elements");
   if (_elements.size() == 1 && _elements[0] == "ALL")
   {
     _elements.resize(Thermochimica::getNumberElementsDatabase());
     _elements = Thermochimica::getElementsDatabase();
     mooseInfo("Thermochimica elements: 'ALL' specified in input file. Using: ",
               Moose::stringify(_elements));
   }
   else
   {
     std::vector<std::string> db_elements(Thermochimica::getNumberElementsDatabase());
     db_elements = Thermochimica::getElementsDatabase();
     for (const auto i : index_range(_elements))
       if (std::find(db_elements.begin(), db_elements.end(), _elements[i]) == db_elements.end())
         paramError("elements", "Element '", _elements[i], "' was not found in the database.");
   }
   _element_ids.resize(_elements.size());
   for (const auto i : index_range(_elements))
     _element_ids[i] = Thermochimica::atomicNumber(_elements[i]);
 
   // I want to check all the input parameters here and have a list of possible phases and species
   // for setting up the Aux variables with "ALL" option
 
   // Temporarily set Thermochimica state space to get the list of possible phases and species
   Thermochimica::setTemperaturePressure(1000.0, 1.0);
   Thermochimica::setElementMass(0, 0.0);
 
   for (const auto i : make_range(_elements.size()))
     Thermochimica::setElementMass(Thermochimica::atomicNumber(_elements[i]), 1.0);
 
   Thermochimica::setup();
 
   if (isParamValid("output_phases"))
   {
     _phases = getParam<std::vector<std::string>>("output_phases");
     if (_phases.size() == 1 && _phases[0] == "ALL")
     {
       auto [soln_phases, stoich_phases] = Thermochimica::getNumberPhasesSystem();
       _phases.resize(soln_phases + stoich_phases);
       _phases = Thermochimica::getPhaseNamesSystem();
       mooseInfo("ChemicalCompositionAction phases: 'ALL' specified in input file. Using: ",
                 Moose::stringify(_phases));
     }
     else
     {
       auto db_phases = Thermochimica::getPhaseNamesSystem();
       for (const auto i : index_range(_phases))
         if (std::find(db_phases.begin(), db_phases.end(), _phases[i]) == db_phases.end())
           paramError("output_phases", "Phase '", _phases[i], "' was not found in the simulation.");
     }
   }
 
   if (isParamValid("output_species"))
   {
     auto species = getParam<std::vector<std::string>>("output_species");
     auto db_phases = Thermochimica::getPhaseNamesSystem();
     auto n_db_species = Thermochimica::getNumberSpeciesSystem();
     auto db_species = Thermochimica::getSpeciesSystem();
     for (auto i : index_range(n_db_species))
       if (Thermochimica::isPhaseMQM(i))
       {
         auto [pairs, quads, idbg] =
             Thermochimica::getMqmqaNumberPairsQuads(Thermochimica::getPhaseNamesSystem()[i]);
         n_db_species[i] = pairs;
       }
 
     if (species.size() == 1 && species[0] == "ALL")
     {
       if (!n_db_species.empty())
         species.resize(n_db_species.back());
       else
         mooseInfo("ChemicalCompositionAction species: 'ALL' specified in input file. Thermochimica "
                   "returned no possible species.");
 
       species.clear();
       _tokenized_species.clear();
       for (const auto i : make_range(db_species.size()))
         for (const auto j : index_range(db_species[i]))
         {
           species.push_back(db_phases[i] + ":" + db_species[i][j]);
           _tokenized_species.push_back(std::make_pair(db_phases[i], db_species[i][j]));
         }
       mooseInfo("ChemicalCompositionAction species: 'ALL' specified in input file. Using: ",
                 Moose::stringify(species));
     }
     else
       for (const auto i : index_range(species))
       {
         _tokenized_species.resize(species.size());
         std::vector<std::string> tokens;
         MooseUtils::tokenize(species[i], tokens, 1, ":");
         if (tokens.size() == 1)
           paramError("output_species", "No ':' separator found in variable '", species[i], "'");
 
         auto phase_index = std::find(db_phases.begin(), db_phases.end(), tokens[0]);
         if (phase_index == db_phases.end())
           paramError("output_species",
                      "Phase '",
                      tokens[0],
                      "' of output species '",
                      species[i],
                      "' not found in the simulation.");
         auto sp = db_species[std::distance(db_phases.begin(), phase_index)];
         if (std::find(sp.begin(), sp.end(), tokens[1]) == sp.end())
           paramError(
               "output_species", "Species '", tokens[1], "' was not found in the simulation.");
         _tokenized_species[i] = std::make_pair(tokens[0], tokens[1]);
       }
   }
 
   if (isParamValid("output_element_potentials"))
   {
     auto element_potentials = getParam<std::vector<std::string>>("output_element_potentials");
     if (element_potentials.size() == 1 && element_potentials[0] == "ALL")
     {
       _tokenized_element_potentials.resize(_elements.size());
       _tokenized_element_potentials = _elements;
       element_potentials.resize(_elements.size());
       for (const auto i : index_range(_elements))
         element_potentials[i] = "mu:" + _elements[i];
       mooseInfo(
           "ChemicalCompositionAction element potentials: 'ALL' specified in input file. Using: ",
           Moose::stringify(element_potentials));
     }
     else
     {
       _tokenized_element_potentials.resize(element_potentials.size());
       for (const auto i : index_range(element_potentials))
       {
         std::vector<std::string> tokens;
         MooseUtils::tokenize(element_potentials[i], tokens, 1, ":");
         if (tokens.size() == 1)
           paramError("output_element_potentials",
                      "No ':' separator found in variable '",
                      element_potentials[i],
                      "'");
         if (std::find(_elements.begin(), _elements.end(), tokens[1]) == _elements.end())
           paramError("output_element_potentials",
                      "Element '",
                      tokens[1],
                      "' was not found in the simulation.");
         _tokenized_element_potentials[i] = tokens[1];
       }
     }
   }
 
   if (isParamValid("output_vapor_pressures"))
   {
     auto vapor_pressures = getParam<std::vector<std::string>>("output_vapor_pressures");
     if (!Thermochimica::isPhaseGas(0))
       paramError("output_vapor_pressures",
                  "No gas phase found in the simulation. Cannot output vapor pressures.");
     if (vapor_pressures.size() == 1 && vapor_pressures[0] == "ALL")
     {
       vapor_pressures.resize(Thermochimica::getNumberSpeciesSystem()[0]);
       _tokenized_vapor_species.resize(Thermochimica::getNumberSpeciesSystem()[0]);
       auto db_gas_species = Thermochimica::getSpeciesInPhase(0);
       auto gas_name = Thermochimica::getPhaseNamesSystem()[0];
       for (const auto i : index_range(db_gas_species))
       {
         vapor_pressures[i] = "vp:" + gas_name + ':' + db_gas_species[i];
         _tokenized_vapor_species[i] = std::make_pair(gas_name, db_gas_species[i]);
       }
       mooseInfo("ChemicalCompositionAction vapor pressures: 'ALL' specified in input file. Using: ",
                 Moose::stringify(vapor_pressures));
     }
     else
     {
       auto db_gas_species = Thermochimica::getSpeciesInPhase(0);
       _tokenized_vapor_species.resize(vapor_pressures.size());
       for (const auto i : index_range(vapor_pressures))
       {
         std::vector<std::string> tokens;
         MooseUtils::tokenize(vapor_pressures[i], tokens, 1, ":");
         if (tokens.size() == 1)
           paramError("output_vapor_pressures",
                      "No ':' separator found in variable '",
                      vapor_pressures[i],
                      "'");
         if (tokens[1] != Thermochimica::getPhaseNamesSystem()[0])
           paramError("output_vapor_pressures",
                      "Phase '",
                      tokens[1],
                      "' of vapor species '",
                      vapor_pressures[i],
                      "' is not a gas phase. Cannot calculate vapor pressure.");
         if (std::find(db_gas_species.begin(), db_gas_species.end(), tokens[2]) ==
             db_gas_species.end())
           paramError("output_vapor_pressures",
                      "Species '",
                      tokens[2],
                      "' was not found in the gas phase of simulation.");
         _tokenized_vapor_species[i] = std::make_pair(tokens[1], tokens[2]);
       }
     }
   }
 
   if (isParamValid("output_element_phases"))
   {
     auto element_phases = getParam<std::vector<std::string>>("output_element_phases");
     auto db_phases = Thermochimica::getPhaseNamesSystem();
     if (element_phases.size() == 1 && element_phases[0] == "ALL")
     {
       element_phases.resize(_elements.size() * db_phases.size());
       _tokenized_phase_elements.resize(_elements.size() * db_phases.size());
       for (const auto i : index_range(db_phases))
         for (const auto j : index_range(_elements))
         {
           element_phases[i * _elements.size() + j] = db_phases[i] + ':' + _elements[j];
           _tokenized_phase_elements[i * _elements.size() + j] =
               std::make_pair(db_phases[i], _elements[j]);
         }
       mooseInfo(
           "ChemicalCompositionAction elements in phase: 'ALL' specified in input file. Using: ",
           Moose::stringify(element_phases));
     }
     else
     {
       _tokenized_phase_elements.resize(element_phases.size());
       for (const auto i : index_range(element_phases))
       {
         std::vector<std::string> tokens;
         MooseUtils::tokenize(element_phases[i], tokens, 1, ":");
         if (tokens.size() == 1)
           paramError("output_element_phases",
                      "No ':' separator found in variable '",
                      element_phases[i],
                      "'");
         if (std::find(db_phases.begin(), db_phases.end(), tokens[1]) == db_phases.end())
           paramError("output_element_phases",
                      "Phase '",
                      tokens[1],
                      "' of '",
                      element_phases[i],
                      "' not found in the simulation.");
         if (std::find(_elements.begin(), _elements.end(), tokens[2]) == _elements.end())
           paramError("output_element_phases",
                      "Element '",
                      tokens[2],
                      "' was not found in the simulation.");
         _tokenized_phase_elements[i] = std::make_pair(tokens[1], tokens[2]);
       }
     }
   }
 
   Thermochimica::resetThermoAll();
 
 #endif
 }

Member Function Documentation

◆ act()

void ChemicalCompositionAction::act ( )

virtual

Implements Action.

Definition at line 421 of file ChemicalCompositionAction.C.

 {
 #ifdef THERMOCHIMICA_ENABLED
   //
   // Add AuxVariables
   //
   if (_current_task == "add_aux_variable")
   {
     auto aux_var_type = AddVariableAction::variableType(
         FEType(Utility::string_to_enum<Order>(_problem->mesh().hasSecondOrderElements() ? "SECOND"
                                                                                         : "FIRST"),
                Utility::string_to_enum<libMesh::FEFamily>("LAGRANGE")),
         /* is_fv = */ getParam<bool>("is_fv"),
         /* is_array = */ false);
     auto params = _factory.getValidParams(aux_var_type);
 
     for (const auto i : index_range(_elements))
       _problem->addAuxVariable(aux_var_type, _elements[i], params);
 
     for (const auto i : index_range(_phases))
       _problem->addAuxVariable(aux_var_type, _phases[i], params);
 
     for (const auto i : index_range(_tokenized_species))
       _problem->addAuxVariable(
           aux_var_type, Moose::stringify(_tokenized_species[i], /* delim = */ ":"), params);
 
     for (const auto i : index_range(_tokenized_element_potentials))
       _problem->addAuxVariable(aux_var_type, "mu:" + _tokenized_element_potentials[i], params);
 
     for (const auto i : index_range(_tokenized_vapor_species))
       _problem->addAuxVariable(aux_var_type,
                                "vp:" +
                                    Moose::stringify(_tokenized_vapor_species[i], /* delim = */ ":"),
                                params);
 
     for (const auto i : index_range(_tokenized_phase_elements))
       _problem->addAuxVariable(
           aux_var_type,
           "ep:" + Moose::stringify(_tokenized_phase_elements[i], /* delim = */ ":"),
           params);
   }
 
   //
   // Set up initial conditions from a file
   //
   if (_current_task == "add_ic" && isParamValid("initial_values"))
   {
     readCSV();
     for (auto it : _initial_conditions)
     {
       const std::string class_name = "ConstantIC";
       auto params = _factory.getValidParams(class_name);
       params.set<VariableName>("variable") = it.first;
       params.set<Real>("value") = it.second;
       _problem->addInitialCondition(class_name, it.first + "_ic", params);
     }
   }
 
   //
   // Set up user object
   //
   if (_current_task == "add_user_object")
   {
     std::string uo_name = getParam<std::string>("uo_name");
 
     if (isParamValid("block") && !isParamSetByUser("uo_name"))
       uo_name += "_" + Moose::stringify(getParam<std::vector<SubdomainName>>("block"));
 
     const auto uo_type =
         getParam<bool>("is_fv") ? "ThermochimicaElementData" : "ThermochimicaNodalData";
 
     auto uo_params = _factory.getValidParams(uo_type);
 
     std::copy(_elements.begin(),
               _elements.end(),
               std::back_inserter(uo_params.set<std::vector<VariableName>>("elements")));
 
     if (isParamValid("output_phases"))
       std::copy(_phases.begin(),
                 _phases.end(),
                 std::back_inserter(uo_params.set<std::vector<VariableName>>("output_phases")));
 
     if (isParamValid("output_species"))
     {
       std::vector<std::string> species;
       for (auto token : _tokenized_species)
         species.push_back(Moose::stringify(token, ":"));
       uo_params.set<std::vector<VariableName>>("output_species")
           .insert(uo_params.set<std::vector<VariableName>>("output_species").end(),
                   species.begin(),
                   species.end());
     }
 
     if (isParamValid("output_element_potentials"))
     {
       std::vector<std::string> element_potentials;
       for (auto token : _tokenized_element_potentials)
         element_potentials.push_back("mu:" + token);
       uo_params.set<std::vector<VariableName>>("output_element_potentials")
           .insert(uo_params.set<std::vector<VariableName>>("output_element_potentials").end(),
                   element_potentials.begin(),
                   element_potentials.end());
     }
 
     if (isParamValid("output_vapor_pressures"))
     {
       std::vector<std::string> vapor_pressures;
       for (auto token : _tokenized_vapor_species)
         vapor_pressures.push_back("vp:" + Moose::stringify(token, ":"));
       uo_params.set<std::vector<VariableName>>("output_vapor_pressures")
           .insert(uo_params.set<std::vector<VariableName>>("output_vapor_pressures").end(),
                   vapor_pressures.begin(),
                   vapor_pressures.end());
     }
 
     if (isParamValid("output_element_phases"))
     {
       std::vector<std::string> element_phases;
       for (auto token : _tokenized_phase_elements)
         element_phases.push_back("ep:" + Moose::stringify(token, ":"));
       uo_params.set<std::vector<VariableName>>("output_element_phases")
           .insert(uo_params.set<std::vector<VariableName>>("output_element_phases").end(),
                   element_phases.begin(),
                   element_phases.end());
     }
     uo_params.set<std::vector<VariableName>>("temperature") =
         getParam<std::vector<VariableName>>("temperature");
 
     uo_params.set<ChemicalCompositionAction *>("_chemical_composition_action") = this;
 
     uo_params.set<FileName>("thermofile") = getParam<FileName>("thermofile");
 
     uo_params.set<MooseEnum>("reinit_type") = getParam<MooseEnum>("reinitialization_type");
 
     uo_params.set<MooseEnum>("output_species_unit") = getParam<MooseEnum>("output_species_unit");
 
     uo_params.applyParameters(parameters());
 
     _problem->addUserObject(uo_type, uo_name, uo_params);
   }
 
 #endif
 }

◆ elementIDs()

const std::vector<unsigned int>& ChemicalCompositionAction::elementIDs ( ) const

inline

Definition at line 25 of file ChemicalCompositionAction.h.

25 { return _element_ids; }

ChemicalCompositionAction::_element_ids

std::vector< unsigned int > _element_ids

Atomic numbers of the selected elements.

Definition: ChemicalCompositionAction.h:63

◆ elementPotentials()

const std::vector<std::string>& ChemicalCompositionAction::elementPotentials ( ) const

inline

Definition at line 28 of file ChemicalCompositionAction.h.

   {
     return _tokenized_element_potentials;
   }

◆ phaseElementPairs()

const std::vector<std::pair<std::string, std::string> >& ChemicalCompositionAction::phaseElementPairs ( ) const

inline

Definition at line 43 of file ChemicalCompositionAction.h.

   {
     return _tokenized_phase_elements;
   }

◆ phases()

const std::vector<std::string>& ChemicalCompositionAction::phases ( ) const

inline

Definition at line 27 of file ChemicalCompositionAction.h.

27 { return _phases; }

ChemicalCompositionAction::_phases

std::vector< std::string > _phases

List of phases tracked by Thermochimica.

Definition: ChemicalCompositionAction.h:60

◆ readCSV()

void ChemicalCompositionAction::readCSV ( )

protected

Definition at line 566 of file ChemicalCompositionAction.C.

Referenced by act().

 {
   const auto & filename = getParam<FileName>("initial_values");
   std::ifstream file(filename.c_str());
   if (!file.good())
     paramError("initial_values", "Error opening file '", filename, "'.");
 
   std::string line;
   std::vector<std::string> items;
 
   // skip header
   std::getline(file, line);
   while (std::getline(file, line))
   {
     MooseUtils::tokenize(line, items, 1, ",");
     if (items.empty())
       continue;
     if (items.size() != 2)
       paramError("initial_value", "Unexpected line in CSV file: ", line);
 
     _initial_conditions[items[0]] = MooseUtils::convert<Real>(items[1]);
   }
 }

◆ speciesPhasePairs()

const std::vector<std::pair<std::string, std::string> >& ChemicalCompositionAction::speciesPhasePairs ( ) const

inline

Definition at line 33 of file ChemicalCompositionAction.h.

   {
     return _tokenized_species;
   }

◆ validParams()

InputParameters ChemicalCompositionAction::validParams ( )

static

Definition at line 32 of file ChemicalCompositionAction.C.

Referenced by CommonChemicalCompositionAction::validParams().

 {
   InputParameters params = Action::validParams();
   params += BlockRestrictable::validParams();
 
   ThermochimicaUtils::addClassDescription(params,
                                           "Sets up the thermodynamic model and variables for the "
                                           "thermochemistry solve using Thermochimica.");
 
   // Required variables
   params.addParam<std::vector<std::string>>(
       "elements", {"ALL"}, "List of chemical elements (or ALL)");
   params.addCoupledVar("temperature", "Name of temperature variable");
   params.addCoupledVar("pressure", "Name of pressure variable");
   MooseEnum reinit_type("none time nodal", "nodal");
   params.addParam<MooseEnum>(
       "reinitialization_type", reinit_type, "Reinitialization scheme to use with Thermochimica");
   params.addParam<FileName>("initial_values", "The CSV file name with initial conditions.");
   params.addParam<FileName>("thermofile", "Thermodynamics model file");
 
   MooseEnum tUnit("K C F R");
   params.addParam<MooseEnum>("tunit", tUnit, "Temperature Unit");
   MooseEnum pUnit("atm psi bar Pa kPa");
   params.addParam<MooseEnum>("punit", pUnit, "Pressure Unit");
   MooseEnum mUnit(
       "mole_fraction atom_fraction atoms moles gram-atoms mass_fraction kilograms grams pounds");
   params.addParam<MooseEnum>("munit", mUnit, "Mass Unit");
   ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
   exec_enum = {EXEC_INITIAL, EXEC_TIMESTEP_END};
   params.addParam<ExecFlagEnum>(
       "execute_on", exec_enum, "When to execute the ThermochimicaData UO");
   params.addParam<bool>("is_fv", false, "Should the variables set up by action be of FV type");
 
   params.addParam<std::vector<std::string>>("output_phases", {}, "List of phases to be output");
   params.addParam<std::vector<std::string>>(
       "output_species", {}, "List species for which concentration in the phases is needed");
   MooseEnum mUnit_op("moles mole_fraction");
   params.addParam<MooseEnum>(
       "output_species_unit", mUnit_op, "Mass unit for output species: mole_fractions or moles");
   params.addParam<std::vector<std::string>>(
       "output_element_potentials",
       {},
       "List of chemical elements for which chemical potentials are requested");
   params.addParam<std::vector<std::string>>(
       "output_vapor_pressures",
       {},
       "List of gas phase species for which vapor pressures are requested");
   params.addParam<std::vector<std::string>>(
       "output_element_phases",
       {},
       "List of elements whose molar amounts in specific phases are requested");
   params.addParam<std::string>(
       "uo_name", "Thermochimica", "Name of the ThermochimicaDataUserObject.");
   return params;
 }

◆ vaporPhasePairs()

const std::vector<std::pair<std::string, std::string> >& ChemicalCompositionAction::vaporPhasePairs ( ) const

inline

Definition at line 38 of file ChemicalCompositionAction.h.

   {
     return _tokenized_vapor_species;
   }

Member Data Documentation

◆ _element_ids

std::vector<unsigned int> ChemicalCompositionAction::_element_ids

protected

Atomic numbers of the selected elements.

Definition at line 63 of file ChemicalCompositionAction.h.

Referenced by ChemicalCompositionAction(), and elementIDs().

◆ _elements

std::vector<std::string> ChemicalCompositionAction::_elements

protected

Element names.

Definition at line 54 of file ChemicalCompositionAction.h.

Referenced by act(), and ChemicalCompositionAction().

◆ _initial_conditions

std::map<std::string, Real> ChemicalCompositionAction::_initial_conditions

protected

Initial conditions for each element: [element name] => initial condition value.

Definition at line 57 of file ChemicalCompositionAction.h.

Referenced by act(), and readCSV().

◆ _phases

std::vector<std::string> ChemicalCompositionAction::_phases

protected

List of phases tracked by Thermochimica.

Definition at line 60 of file ChemicalCompositionAction.h.

Referenced by act(), ChemicalCompositionAction(), and phases().

◆ _tokenized_element_potentials

std::vector<std::string> ChemicalCompositionAction::_tokenized_element_potentials

protected

Definition at line 67 of file ChemicalCompositionAction.h.

Referenced by act(), ChemicalCompositionAction(), and elementPotentials().

◆ _tokenized_phase_elements

std::vector<std::pair<std::string, std::string> > ChemicalCompositionAction::_tokenized_phase_elements

protected

Definition at line 69 of file ChemicalCompositionAction.h.

Referenced by act(), ChemicalCompositionAction(), and phaseElementPairs().

◆ _tokenized_species

std::vector<std::pair<std::string, std::string> > ChemicalCompositionAction::_tokenized_species

protected

Tokenized versions of the output variables to avoid redoing tokenization.

Definition at line 66 of file ChemicalCompositionAction.h.

Referenced by act(), ChemicalCompositionAction(), and speciesPhasePairs().

◆ _tokenized_vapor_species

std::vector<std::pair<std::string, std::string> > ChemicalCompositionAction::_tokenized_vapor_species

protected

Definition at line 68 of file ChemicalCompositionAction.h.

Referenced by act(), ChemicalCompositionAction(), and vaporPhasePairs().

The documentation for this class was generated from the following files:

chemical_reactions/include/actions/ChemicalCompositionAction.h
chemical_reactions/src/actions/ChemicalCompositionAction.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ChemicalCompositionAction()

Member Function Documentation

◆ act()

◆ elementIDs()

◆ elementPotentials()

◆ phaseElementPairs()

◆ phases()

◆ readCSV()

◆ speciesPhasePairs()

◆ validParams()

◆ vaporPhasePairs()

Member Data Documentation

◆ _element_ids

◆ _elements

◆ _initial_conditions

◆ _phases

◆ _tokenized_element_potentials

◆ _tokenized_phase_elements

◆ _tokenized_species

◆ _tokenized_vapor_species