AbaqusUserElement.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
 
#include "GeneralUserObject.h"
#include "BlockRestrictable.h"
#include "TaggingInterface.h"
#include "DynamicLibraryLoader.h"
 
class MooseMesh;
namespace libMesh
{
class Elem;
class MeshBase;
}
 
class AbaqusUserElement : public GeneralUserObject,
                          public BlockRestrictable,
                          public TaggingInterface
{
public:
  typedef void (*uel_t)(
      Real RHS[],    // (MLVARX,*)      Residual vector contribution for the current element
      Real AMATRX[], // (NDOFEL,NDOFEL) Jacobian contribution for the current element
      Real SVARS[],  // (NSVARS)        Persistent state variable values for the current element
      Real ENERGY[], // (8)             Energy quantities at the start of the current
                     //                 increment (to be updated by the UEL routine)
      int * NDOFEL,  // Number of degrees of freedom (DOFs) for the current element
      int * NRHS,    // NRHS=1: RHS should contain the residual vector,
                     // NRHS=2: not implemented (modified Riks static procedure)
      int * NSVARS,  // Number of persistent state variables for the element
      Real PROPS[],  // (NPROPS) Static property values (parameters) defined for use with this
                     // element.
      int * NPROPS,  //
      Real COORDS[], // (MCRD,NNODE) Undisplaced coordinates of the element nodes
                     //              COORDS(K1,K2) is the K1th coordinate of the
                     //              K2th node of the element
      int * MCRD,  // Maximum number of coordinates needed at any node point (COORDINATES keyword -
                   // unsupported)
      int * NNODE, // Number of nodes in the current element
      Real U[],    // (NDOFEL)   Total values of the variables
      Real DU[],   // (MLVARX,*) Incremental values of the variables for the current increment
                   //            for right-hand-side
      Real V[],    // (NDOFEL) Time rate of change of the variables (velocities,
                   //          rates of rotation). Defined for implicit dynamics only (LFLAGS(1)
                   //          11 or 12)
      Real A[],    // (NDOFEL) Accelerations of the variables. Defined for implicit dynamics
                   //          only (LFLAGS(1) 11 or 12).
      int * JTYPE, // Integer defining the element type. This is the user-defined integer value n in
                   // element type Un
      Real TIME[], // (2) step time and total time
      Real * DTIME,  // Time increment
      int * KSTEP,   // Step number (as per Abaqus definition) can be set by the user
      int * KINC,    // Increment number (MOOSE time step)
      int * JELEM,   // User-defined element number
      Real PRAMS[],  // (*) parameters associated with the solution procedure
      int * NDLOAD,  // Number of applied loads to the element (unused)
      int JDLTYP[],  // (MDLOAD, *) array containing the integers used to define distributed load
                     //             types for the element
      Real ADLMAG[], // (MDLOAD,*)
      Real PREDEF[], // (2,NPREDF,NNODE) predefined field variables, such as temperature in an
                     //                  uncoupled stress/displacement analysis
      int * NPREDF,  // Number of predefined field (auxiliary) variables, including temperature
      int LFLAGS[],  // (*) flags that define the current solution procedure
      int * MLVARX,  // used when several displacement or right-hand-side vectors are used
      Real DDLMAG[], // (MDLOAD,*)
      int * MDLOAD,  // Total number of distributed loads and/or fluxes defined on this element
      Real * PNEWDT, // Recommended new timestep (unused)
      int JPROPS[],  // (NJPROP) NJPROP integer property values defined for the current element
      int * NJPROP,  // Number of user defined integer properties
      Real * PERIOD  // Current step time period (unused)
  );
 
  static InputParameters validParams();
  AbaqusUserElement(const InputParameters & params);
 
  virtual void initialSetup() override;
  virtual void meshChanged() override;
  virtual void timestepSetup() override;
 
  virtual void initialize() override final;
  virtual void execute() override;
  virtual void finalize() override final {}
 
  const std::vector<const MooseVariableFieldBase *> & getVariables() const { return _variables; }
  const std::vector<const MooseVariableFieldBase *> & getAuxVariables() const
  {
    return _aux_variables;
  }
 
  const uel_t & getPlugin() const { return _uel; }
 
protected:
  void setupElemRange();
 
  FileName _plugin;
 
  DynamicLibraryLoader _library;
 
  const uel_t _uel;
 
  MooseMesh & _moose_mesh;
 
  const libMesh::MeshBase & _mesh;
 
  const unsigned int _dim;
 
  std::vector<NonlinearVariableName> _variable_names;
 
  std::vector<AuxVariableName> _aux_variable_names;
 
  std::vector<const MooseVariableFieldBase *> _variables;
 
  std::vector<const MooseVariableFieldBase *> _aux_variables;
 
  const std::set<SubdomainID> _sub_ids;
 
  std::unique_ptr<ConstElemRange> _elem_range;
 
  std::vector<Real> _props;
  int _nprops;
 
  int _nstatev;
  std::array<std::map<dof_id_type, std::vector<Real>>, 2> _statev;
  std::size_t _statev_index_current;
  std::size_t _statev_index_old;
  int & _t_step_old;
 
  const int _jtype;
 
  friend class UELThread;
};