AbaqusUtils Class Reference

Utility class to interface between the object oriented MOOSE app structure and global Abaqus utility functions. More...

#include <AbaqusUtils.h>

Static Public Member Functions
static void	setInputFile (const std::string &input_file)
	Global storage for the simulation output directory, this will be set by any Abaqus class.
static std::string	getOutputDir ()
static std::string	getJobName ()
static void	setCommunicator (const libMesh::Parallel::Communicator *communicator)
	Global storage for the MPI communicator, this will be set by any Abaqus class.
static const libMesh::Parallel::Communicator *	getCommunicator ()
template<typename T >
static std::map< int, std::vector< T > >::iterator	getSMAIterator (std::map< int, std::vector< T > > &array, int id, const std::string &function)
	get data vector iterator with error checking
template<typename T >
static std::map< int, std::vector< T > > &	getSMAThreadArray (std::vector< std::map< int, std::vector< T > > > &local_array, const std::string &function)
	get thread local array
static void	smaInitialize ()
	thread storage initialization
static void	mutexInit (std::size_t n)
	Mutex API.
static void	mutexLock (std::size_t n)
static void	mutexUnlock (std::size_t n)

Static Public Attributes
static std::map< int, std::vector< int > >	_sma_int_array
	Shared Memory Arrays.
static std::map< int, std::vector< Real > >	_sma_float_array
static std::vector< std::map< int, std::vector< int > > >	_sma_local_int_array
static std::vector< std::map< int, std::vector< Real > > >	_sma_local_float_array

Static Private Attributes
static std::array< std::unique_ptr< Threads::spin_mutex >, 101 >	_mutex = {{nullptr}}
static std::string	_output_dir = ""
static std::string	_job_name = ""
static const libMesh::Parallel::Communicator *	_communicator = nullptr

Detailed Description

Utility class to interface between the object oriented MOOSE app structure and global Abaqus utility functions.

The class encapsulates static members for intermediate data storage.

Definition at line 19 of file AbaqusUtils.h.

Member Function Documentation

getCommunicator()

static const libMesh::Parallel::Communicator * AbaqusUtils::getCommunicator ( )

inlinestatic

Definition at line 35 of file AbaqusUtils.h.

{ return _communicator; }

Referenced by get_communicator(), getnumcpus_(), and getrank_().

getJobName()

static std::string AbaqusUtils::getJobName ( )

inlinestatic

Definition at line 28 of file AbaqusUtils.h.

{ return _job_name; }

Referenced by getjobname_().

getOutputDir()

static std::string AbaqusUtils::getOutputDir ( )

inlinestatic

Definition at line 27 of file AbaqusUtils.h.

{ return _output_dir; }

Referenced by getoutdir_().

getSMAIterator()

template<typename T >

std::map< int, std::vector< T > >::iterator AbaqusUtils::getSMAIterator ( std::map< int, std::vector< T > > &  array, int  id, const std::string &  function  )

static

get data vector iterator with error checking

Definition at line 72 of file AbaqusUtils.h.

{
  auto it = array.find(id);
  if (it == array.end())
    mooseError("Invalid id ", id, " in ", function, ".");
  return it;
}

Referenced by SMAFloatArrayAccess(), SMAFloatArrayDelete(), SMAFloatArraySize(), SMAIntArrayAccess(), SMAIntArrayDelete(), SMAIntArraySize(), SMALocalFloatArrayAccess(), SMALocalFloatArrayDelete(), SMALocalFloatArraySize(), SMALocalIntArrayAccess(), SMALocalIntArrayDelete(), and SMALocalIntArraySize().

getSMAThreadArray()

template<typename T >

std::map< int, std::vector< T > > & AbaqusUtils::getSMAThreadArray ( std::vector< std::map< int, std::vector< T > > > &  local_array, const std::string &  function  )

static

get thread local array

Definition at line 84 of file AbaqusUtils.h.

{
  ParallelUniqueId puid;
  if (puid.id >= local_array.size())
    mooseError("SMA storage not properly initialized in ", function, ".");
  return local_array[puid.id];
}

Referenced by SMALocalFloatArrayAccess(), SMALocalFloatArrayCreate(), SMALocalFloatArrayDelete(), SMALocalFloatArraySize(), SMALocalIntArrayAccess(), SMALocalIntArrayCreate(), SMALocalIntArrayDelete(), and SMALocalIntArraySize().

mutexInit()

void AbaqusUtils::mutexInit ( std::size_t  n )

static

Mutex API.

Definition at line 358 of file AbaqusUtils.C.

{
  // Guard the initialization with a double checked lock
  if (!_mutex[n])
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    if (!_mutex[n])
      _mutex[n] = std::make_unique<Threads::spin_mutex>();
  }
}

Referenced by MutexInit().

mutexLock()

void AbaqusUtils::mutexLock ( std::size_t  n )

static

Definition at line 370 of file AbaqusUtils.C.

{
  if (n >= _mutex.size() || !_mutex[n])
    mooseError("Invalid or uninitialized mutex ", n);
  _mutex[n]->lock();
}

Referenced by MutexLock().

mutexUnlock()

void AbaqusUtils::mutexUnlock ( std::size_t  n )

static

Definition at line 378 of file AbaqusUtils.C.

{
  if (n >= _mutex.size() || !_mutex[n])
    mooseError("Invalid or uninitialized mutex ", n);
  _mutex[n]->unlock();
}

Referenced by MutexUnlock().

setCommunicator()

void AbaqusUtils::setCommunicator ( const libMesh::Parallel::Communicator *  communicator )

static

Global storage for the MPI communicator, this will be set by any Abaqus class.

MOOSE will throw a warning if multiple objects try to set this to different values.

Definition at line 19 of file AbaqusUtils.C.

{
  if (_communicator != nullptr && communicator != _communicator)
    mooseWarning("Conflicting MPI communicators specified in Abaqus compatibility objects. Are you "
                 "running a multiapps simulation?");
 
  _communicator = communicator;
}

Referenced by AbaqusUExternalDB::AbaqusUExternalDB().

setInputFile()

void AbaqusUtils::setInputFile ( const std::string &  input_file )

static

Global storage for the simulation output directory, this will be set by any Abaqus class.

MOOSE will throw a warning if multiple objects try to set this to different values.

Definition at line 70 of file AbaqusUtils.C.

{
  auto split = MooseUtils::splitFileName(input_file);
  auto output_dir = split.first;
  auto job_name = MooseUtils::stripExtension(split.second);
 
  if (!_output_dir.empty() && output_dir != _output_dir)
    mooseWarning("Conflicting output directories specified in Abaqus compatibility objects: ",
                 output_dir,
                 " != ",
                 _output_dir,
                 ". Are you running a multiapps simulation?");
 
  if (!_job_name.empty() && job_name != _job_name)
    mooseWarning("Conflicting job names specified in Abaqus compatibility objects: ",
                 job_name,
                 " != ",
                 _job_name,
                 ". Are you running a multiapps simulation?");
 
  _output_dir = output_dir;
  _job_name = job_name;
}

Referenced by AbaqusUExternalDB::AbaqusUExternalDB().

smaInitialize()

void AbaqusUtils::smaInitialize ( )

static

thread storage initialization

Definition at line 188 of file AbaqusUtils.C.

{
  static bool initialized = false;
 
  // Guard the initialization with a double checked lock
  if (!initialized)
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    if (!initialized)
    {
      const auto n = getnumthreads_();
      _sma_local_int_array.resize(n);
      _sma_local_float_array.resize(n);
      initialized = true;
    }
  }
}

Referenced by SMALocalFloatArrayCreate(), and SMALocalIntArrayCreate().

Member Data Documentation

_communicator

const libMesh::Parallel::Communicator * AbaqusUtils::_communicator = nullptr

staticprivate

Definition at line 67 of file AbaqusUtils.h.

Referenced by getCommunicator(), and setCommunicator().

_job_name

std::string AbaqusUtils::_job_name = ""

staticprivate

Definition at line 66 of file AbaqusUtils.h.

Referenced by getJobName(), and setInputFile().

_mutex

std::array< std::unique_ptr< Threads::spin_mutex >, 101 > AbaqusUtils::_mutex = {{nullptr}}

staticprivate

Definition at line 355 of file AbaqusUtils.h.

{
public:
  static void setInputFile(const std::string & input_file);
  static std::string getOutputDir() { return _output_dir; }
  static std::string getJobName() { return _job_name; }
 
  static void setCommunicator(const libMesh::Parallel::Communicator * communicator);
  static const libMesh::Parallel::Communicator * getCommunicator() { return _communicator; }
 
  template <typename T>
  static typename std::map<int, std::vector<T>>::iterator
  getSMAIterator(std::map<int, std::vector<T>> & array, int id, const std::string & function);
 
  template <typename T>
  static typename std::map<int, std::vector<T>> &
  getSMAThreadArray(std::vector<std::map<int, std::vector<T>>> & local_array,
                    const std::string & function);
 
  static void smaInitialize();
 
  static std::map<int, std::vector<int>> _sma_int_array;
  static std::map<int, std::vector<Real>> _sma_float_array;
  static std::vector<std::map<int, std::vector<int>>> _sma_local_int_array;
  static std::vector<std::map<int, std::vector<Real>>> _sma_local_float_array;
 
  static void mutexInit(std::size_t n);
  static void mutexLock(std::size_t n);
  static void mutexUnlock(std::size_t n);
private:
  static std::array<std::unique_ptr<Threads::spin_mutex>, 101> _mutex;
  static std::string _output_dir;
  static std::string _job_name;
  static const libMesh::Parallel::Communicator * _communicator;
};
 
template <typename T>
typename std::map<int, std::vector<T>>::iterator
AbaqusUtils::getSMAIterator(std::map<int, std::vector<T>> & array,
                            int id,
                            const std::string & function)
{
  auto it = array.find(id);
  if (it == array.end())
    mooseError("Invalid id ", id, " in ", function, ".");
  return it;
}
 
template <typename T>
typename std::map<int, std::vector<T>> &
AbaqusUtils::getSMAThreadArray(std::vector<std::map<int, std::vector<T>>> & local_array,
                               const std::string & function)
{
  ParallelUniqueId puid;
  if (puid.id >= local_array.size())
    mooseError("SMA storage not properly initialized in ", function, ".");
  return local_array[puid.id];
}

Referenced by mutexInit(), mutexLock(), and mutexUnlock().

_output_dir

std::string AbaqusUtils::_output_dir = ""

staticprivate

Definition at line 65 of file AbaqusUtils.h.

Referenced by getOutputDir(), and setInputFile().

_sma_float_array

std::map< int, std::vector< Real > > AbaqusUtils::_sma_float_array

static

Definition at line 53 of file AbaqusUtils.h.

Referenced by SMAFloatArrayAccess(), SMAFloatArrayCreate(), SMAFloatArrayDelete(), and SMAFloatArraySize().

_sma_int_array

std::map< int, std::vector< int > > AbaqusUtils::_sma_int_array

static

Shared Memory Arrays.

Definition at line 52 of file AbaqusUtils.h.

Referenced by SMAIntArrayAccess(), SMAIntArrayCreate(), SMAIntArrayDelete(), and SMAIntArraySize().

_sma_local_float_array

std::vector< std::map< int, std::vector< Real > > > AbaqusUtils::_sma_local_float_array

static

Definition at line 55 of file AbaqusUtils.h.

Referenced by smaInitialize(), SMALocalFloatArrayAccess(), SMALocalFloatArrayCreate(), SMALocalFloatArrayDelete(), and SMALocalFloatArraySize().

_sma_local_int_array

std::vector< std::map< int, std::vector< int > > > AbaqusUtils::_sma_local_int_array

static

Definition at line 54 of file AbaqusUtils.h.

Referenced by smaInitialize(), SMALocalIntArrayAccess(), SMALocalIntArrayCreate(), SMALocalIntArrayDelete(), and SMALocalIntArraySize().

---

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

• solid_mechanics/include/utils/AbaqusUtils.h
• solid_mechanics/src/utils/AbaqusUtils.C