This UserObject manages the insertion and expiration of nuclei in the simulation domain it manages a list of nuclei with their insertion times and their center positions. More...

#include <DiscreteNucleationInserter.h>

Inheritance diagram for DiscreteNucleationInserter:

[legend]

Public Types
using	NucleusLocation = std::pair< Real, Point >
	A nucleus has an expiration time and a location. More...

using	NucleusList = std::vector< NucleusLocation >
	Every MPI task should keep a full list of nuclei (in case they cross domains with their finite radii) More...

using	NucleusChanges = std::pair< unsigned int, unsigned int >

Public Member Functions
	DiscreteNucleationInserter (const InputParameters &parameters)

virtual void	initialize ()

virtual void	execute ()

virtual void	threadJoin (const UserObject &y)

virtual void	finalize ()

const Real &	getRate () const

virtual bool	isMapUpdateRequired () const

virtual const NucleusList &	getNucleusList () const

virtual const NucleusChanges &	getInsertionsAndDeletions () const

Protected Attributes
const MaterialProperty< Real > &	_probability
	Nucleation rate density (should be a material property implementing nucleation theory) More...

Real	_hold_time
	Duration of time each nucleus is kept active after insertion. More...

NucleusList &	_local_nucleus_list
	the local nucleus list of nuclei centered in the domain of the current processor More...

Real	_nucleation_rate
	total nucleation rate More...

NucleusList &	_global_nucleus_list
	the global list of all nuclei over all processors More...

NucleusChanges	_changes_made
	count the number of nucleus insertions and deletions More...

bool	_update_required
	is a map update required More...

Detailed Description

This UserObject manages the insertion and expiration of nuclei in the simulation domain it manages a list of nuclei with their insertion times and their center positions.

A DiscreteNucleationMap is needed to enable the DiscreteNucleation material to look up if a nucleus is present at a given element/qp.

Definition at line 25 of file DiscreteNucleationInserter.h.

Member Typedef Documentation

◆ NucleusChanges

using DiscreteNucleationInserterBase::NucleusChanges = std::pair<unsigned int, unsigned int>

inherited

Definition at line 37 of file DiscreteNucleationInserterBase.h.

◆ NucleusList

using DiscreteNucleationInserterBase::NucleusList = std::vector<NucleusLocation>

inherited

Every MPI task should keep a full list of nuclei (in case they cross domains with their finite radii)

Definition at line 34 of file DiscreteNucleationInserterBase.h.

◆ NucleusLocation

using DiscreteNucleationInserterBase::NucleusLocation = std::pair<Real, Point>

inherited

A nucleus has an expiration time and a location.

Definition at line 31 of file DiscreteNucleationInserterBase.h.

Constructor & Destructor Documentation

◆ DiscreteNucleationInserter()

DiscreteNucleationInserter::DiscreteNucleationInserter ( const InputParameters & parameters )

Definition at line 30 of file DiscreteNucleationInserter.C.

   : DiscreteNucleationInserterBase(parameters),
     _probability(getMaterialProperty<Real>("probability")),
     _hold_time(getParam<Real>("hold_time")),
     _local_nucleus_list(declareRestartableData("local_nucleus_list", NucleusList(0)))
 {
 }

Member Function Documentation

◆ execute()

void DiscreteNucleationInserter::execute ( )

virtual

Definition at line 70 of file DiscreteNucleationInserter.C.

 {
   // check each qp for potential nucleation
   // TODO: we might as well place the nuclei at random positions within the element...
   for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
   {
     const Real rate = _probability[qp] * _JxW[qp] * _coord[qp];
     _nucleation_rate += rate;
  
     const Real random = getRandomReal();
  
     // We check the random number against the inverse of the zero probability.
     // for performance reasons we do a quick check against the linearized form of
     // that probability, which is always strictly larger than the actual probability.
     // The expression below should short circuit and the expensive exponential
     // should rarely get evaluated
     if (random < rate * _fe_problem.dt() && random < (1.0 - std::exp(-rate * _fe_problem.dt())))
     {
       _local_nucleus_list.push_back(NucleusLocation(_fe_problem.time() + _hold_time, _q_point[qp]));
       _changes_made.first++;
     }
   }
 }

◆ finalize()

void DiscreteNucleationInserter::finalize ( )

virtual

Pack the _global_nucleus_list into a simple vector of Real. libMesh's allgather does not portably work on the original _global_nucleus_list data structure!

Definition at line 111 of file DiscreteNucleationInserter.C.

 {
   // add the _local_nucleus_list of thread zero
   _global_nucleus_list.insert(
       _global_nucleus_list.end(), _local_nucleus_list.begin(), _local_nucleus_list.end());
  
   std::vector<Real> comm_buffer(_global_nucleus_list.size() * 4);
   for (unsigned i = 0; i < _global_nucleus_list.size(); ++i)
   {
     comm_buffer[i * 4 + 0] = _global_nucleus_list[i].first;
     comm_buffer[i * 4 + 1] = _global_nucleus_list[i].second(0);
     comm_buffer[i * 4 + 2] = _global_nucleus_list[i].second(1);
     comm_buffer[i * 4 + 3] = _global_nucleus_list[i].second(2);
   }
  
   // combine _global_nucleus_lists from all MPI ranks
   _communicator.allgather(comm_buffer);
  
   // unpack the gathered _global_nucleus_list
   unsigned int n = comm_buffer.size() / 4;
   mooseAssert(comm_buffer.size() % 4 == 0,
               "Communication buffer has an unexpected size (not divisible by 4)");
   _global_nucleus_list.resize(n);
   for (unsigned i = 0; i < n; ++i)
   {
     _global_nucleus_list[i].first = comm_buffer[i * 4 + 0];
     _global_nucleus_list[i].second(0) = comm_buffer[i * 4 + 1];
     _global_nucleus_list[i].second(1) = comm_buffer[i * 4 + 2];
     _global_nucleus_list[i].second(2) = comm_buffer[i * 4 + 3];
   }
  
   // get the global number of changes (i.e. changes to _global_nucleus_list)
   gatherSum(_changes_made.first);
   gatherSum(_changes_made.second);
  
   // gather the total nucleation rate
   gatherSum(_nucleation_rate);
  
   _update_required = _changes_made.first > 0 || _changes_made.second > 0;
 }

◆ getInsertionsAndDeletions()

virtual const NucleusChanges& DiscreteNucleationInserterBase::getInsertionsAndDeletions ( ) const

inlinevirtualinherited

Definition at line 41 of file DiscreteNucleationInserterBase.h.

41 { return _changes_made; }

Referenced by DiscreteNucleationData::getValue().

◆ getNucleusList()

virtual const NucleusList& DiscreteNucleationInserterBase::getNucleusList ( ) const

inlinevirtualinherited

Definition at line 40 of file DiscreteNucleationInserterBase.h.

40 { return _global_nucleus_list; }

◆ getRate()

const Real& DiscreteNucleationInserter::getRate ( ) const

inlinevirtual

Implements DiscreteNucleationInserterBase.

Definition at line 35 of file DiscreteNucleationInserter.h.

35 { return _nucleation_rate; }

◆ initialize()

void DiscreteNucleationInserter::initialize ( )

virtual

Definition at line 39 of file DiscreteNucleationInserter.C.

 {
   // clear insertion and deletion counter
   _changes_made = {0, 0};
  
   // expire entries from the local nucleus list (if the current time step converged)
   if (_fe_problem.converged())
   {
     unsigned int i = 0;
     while (i < _local_nucleus_list.size())
     {
       if (_local_nucleus_list[i].first <= _fe_problem.time())
       {
         // remove entry (by replacing with last element and shrinking size by one)
         _local_nucleus_list[i] = _local_nucleus_list.back();
         _local_nucleus_list.pop_back();
         _changes_made.second++;
       }
       else
         ++i;
     }
   }
  
   // we reassemble this list at every time step
   _global_nucleus_list.clear();
  
   // clear total nucleation rate
   _nucleation_rate = 0.0;
 }

◆ isMapUpdateRequired()

virtual bool DiscreteNucleationInserterBase::isMapUpdateRequired ( ) const

inlinevirtualinherited

Definition at line 39 of file DiscreteNucleationInserterBase.h.

39 { return _update_required; }

Referenced by DiscreteNucleationData::getValue(), and DiscreteNucleationMap::initialize().

◆ threadJoin()

void DiscreteNucleationInserter::threadJoin ( const UserObject & y )

virtual

Definition at line 95 of file DiscreteNucleationInserter.C.

 {
   // combine _local_nucleus_list entries from all threads on the current process
   const DiscreteNucleationInserter & uo = static_cast<const DiscreteNucleationInserter &>(y);
   _global_nucleus_list.insert(
       _global_nucleus_list.end(), uo._local_nucleus_list.begin(), uo._local_nucleus_list.end());
  
   // sum up insertion and deletion counts
   _changes_made.first += uo._changes_made.first;
   _changes_made.second += uo._changes_made.second;
  
   // integrate total nucleation rate
   _nucleation_rate += uo._nucleation_rate;
 }