Solver class#

struct boudary_blast_type#

#include <openfdem_boundary.h>

Public Functions

boudary_blast_type() = default#

void clear()#

Public Members

std::string tag#

bool activated = true#

Real value = 0.0#

Int table = -1#

UInt size = 0#

std::vector<UInt> node#

struct boudary_edge_type#

#include <openfdem_boundary.h>

Public Functions

boudary_edge_type() = default#

void clear()#

Public Members

std::string tag#

boundary_mechanical_enum type = boundary_mechanical_enum::VEL #

Vector2 value#

bool on_x = false#

bool on_y = false#

bool activated = true#

Int table[2] = {-1, -1}#

UInt size = 0#

std::vector<UInt> edges#

struct boudary_ele_type#

#include <openfdem_boundary.h>

Public Functions

boudary_ele_type() = default#

void clear()#

Public Members

std::string tag#

boundary_mechanical_enum type = boundary_mechanical_enum::STRESS #

bool activated = true#

Real xx = 0.0#

Real xy = 0.0#

Real yy = 0.0#

UInt size = 0#

std::vector<UInt> ele#

struct boudary_flow_type#

#include <openfdem_boundary.h>

Public Functions

boudary_flow_type() = default#

void clear()#

Public Members

std::string tag#

boundary_fluid_enum type = boundary_fluid_enum::PRESSURE #

bool activated = true#

Real value = 0.0#

Real p0 = 0.0#

Real p = 0.0#

bool on_x = false#

bool on_y = false#

Real gradx = 0.0#

Real grady = 0.0#

Int table = -1#

UInt size = 0#

std::vector<UInt> node#

struct boudary_inletflow_type#

#include <openfdem_boundary.h>

Public Functions

boudary_inletflow_type() = default#

Public Members

std::string tag#

Vector2 value#

bool on_x = false#

bool on_y = false#

Int type = 0#

Int matid = -1#

Vector2 position#

Real radius = 0.0#

Int currentParticle = 0#

Real particleradius[2] = {0.0, 0.0}#

UInt maxparticles = 0#

struct boudary_node_type#

#include <openfdem_boundary.h>

Public Functions

boudary_node_type() = default#

void clear()#

Public Members

std::string tag#

boundary_mechanical_enum type = boundary_mechanical_enum::VEL #

Vector3 value#

bool on_x = false#

bool on_y = false#

bool on_r = false#

bool activated = true#

bool hascenter = false#

Vector2 center#

Int table[BOUNDARY_TABLE_SIZE] = {-1, -1, -1}#

UInt size = 0#

std::vector<UInt> node#

struct boudary_outletflow_type#

#include <openfdem_boundary.h>

Public Functions

boudary_outletflow_type() = default#

Public Members

Real value = 0.0#

bool on_x = false#

bool on_y = false#

bool upper = false#

bool lower = false#

Int type = 0#

struct boudary_particle_type#

#include <openfdem_boundary.h>

Public Functions

boudary_particle_type() = default#

void clear()#

Public Members

std::string tag#

boundary_mechanical_enum type = boundary_mechanical_enum::VEL #

Vector3 value#

bool on_x = false#

bool on_y = false#

bool on_r = false#

bool activated = true#

bool hascenter = false#

Vector2 center#

Int table[BOUNDARY_TABLE_SIZE] = {-1, -1, -1}#

UInt size = 0#

std::vector<UInt> particle#

struct boudary_point_type#

#include <openfdem_boundary.h>

Public Functions

boudary_point_type() = default#

void clear()#

Public Members

std::string tag#

boundary_mechanical_enum type = boundary_mechanical_enum::VEL #

bool on_x = false#

bool on_y = false#

Vector2 value#

Int table[2] = {-1, -1}#

UInt size = 0#

std::vector<UInt> point#

struct boudary_thermal_type#

#include <openfdem_boundary.h>

Public Functions

boudary_thermal_type() = default#

void clear()#

Public Members

std::string tag#

boundary_thermal_enum type = boundary_thermal_enum::TEMPERATURE #

bool activated = true#

Real value = 0.0#

Real T = 0.0#

Int table = -1#

UInt size = 0#

std::vector<UInt> node#

struct Boundary_structure#

#include <openfdem_boundary.h>

Public Functions

void resize(std::string type, Int size, Int initialsize = 0)#

void clear()#

Public Members

UInt n_node = 0#

UInt n_edge = 0#

UInt n_ele = 0#

UInt n_table = 0#

UInt n_flow = 0#

UInt n_blast = 0#

UInt n_thermal = 0#

UInt n_particle = 0#

UInt n_point = 0#

UInt n_inlet = 0#

UInt n_outlet = 0#

std::vector<boudary_node_type> node#

std::vector<boudary_ele_type> ele#

std::vector<table_type> table#

std::vector<boudary_edge_type> edge#

std::vector<boudary_flow_type> flow#

std::vector<boudary_blast_type> blast#

std::vector<boudary_thermal_type> thermal#

std::vector<boudary_particle_type> particle#

std::vector<boudary_point_type> point#

std::vector<boudary_inletflow_type> inlet#

std::vector<boudary_outletflow_type> outlet#

Real ini_time = 0.0#

short finishedExcavationSteps = 0#

short timedependentExcavationSteps = 0#

bool boundaryUpdate = false#

bool ExcavationboundaryUpdate = false#

std::string excavationTag#

class BoundaryModule : public OpenFdemAbstract, public ns_solve::BoundaryUtils #

#include <solver_boundary_module.h>

Subclassed by ns_solve::SolveSolid

Public Functions

inline BoundaryModule()#

inline ~BoundaryModule()#

Public Static Functions

static void applyBoundaryInsituStressonElement(Boudary boudary, Element element, Nodal nodal, Edge edge)#

static void applyBoundaryForceonNode(General general, Boudary boudary, Nodal nodal)#

static void applyBoundaryVelocityonNode(General general, Boudary boudary, Nodal nodal)#

static void applyBoundaryBodyForce(Nodal nodal, General general)#

static void applyBoundaryVelocityonEdge(General general, Boudary boudary, Nodal nodal, Edge edge)#

static void applyBoundaryForceonEdge(General general, Boudary boudary, Solidmat solidmat, Element element, Nodal nodal, Edge edge)#

static bool applyBoundaryRotationonNode(General general, Boudary boudary, Nodal nodal, Entity entity)#

class BoundaryUtils : public OpenFdemAbstract#

#include <boundary_utils.h>

Subclassed by ns_solve::BoundaryModule, ns_solve::PushBoundary, ns_solve::SolveParticle, ns_solve::SolveRigid

Public Functions

inline BoundaryUtils()#

inline ~BoundaryUtils()#

Public Static Functions

static void clear_nodal_boudary(Boudary boudary, Keywords &Tags)#

static void clear_edge_boudary(Boudary boudary, Keywords &Tags)#

static void clear_element_boudary(Boudary boudary, Keywords &Tags)#

static void clear_thermal_boudary(Boudary boudary, Keywords &Tags)#

static void clear_hydro_boudary(Boudary boudary, Keywords &Tags)#

static void clear_particle_boudary(Boudary boudary, Keywords &Tags)#

static bool checkPreviousNodalBoundary(Boudary boudary, char *tag, boundary_mechanical_enum type, UInt &boundaryid)#

static bool checkPreviousEdgeBoundary(Boudary boudary, char *tag, boundary_mechanical_enum type, UInt &boundaryid)#

static bool checkPreviousBlastBoundary(Boudary boudary, char *tag, UInt &boundaryid)#

static bool checkPreviousHydroBoundary(Boudary boudary, char *tag, boundary_fluid_enum type, UInt &boundaryid)#

static bool checkPreviousThermalBoundary(Boudary boudary, char *tag, boundary_thermal_enum type, UInt &boundaryid)#

static bool checkPreviousParticleBoundary(Boudary boudary, char *tag, boundary_mechanical_enum type, UInt &boundaryid)#

static bool checkPreviousPointBoundary(Boudary boudary, char *tag, boundary_mechanical_enum type, UInt &boundaryid)#

static bool checkPreviousElementBoundary(Boudary boudary, char *tag, boundary_mechanical_enum type, UInt &boundaryid)#

static Real getTableValue(Real CurrentTime, Boudary boudary, Int tableID)#

static Real getTableValue(Real CurrentTime, Boudary boudary, Int tableID, bool &isended)#

class ExplicitTimestep#

#include <explicit_timestep.h>

Subclassed by ns_solve::SolverModule

Public Functions

inline ExplicitTimestep()#

inline ~ExplicitTimestep()#

Real getdtfromMatrix(Nodal nodal, Element element, Solidmat solidmat)#

get crtical timestep from mechanical matrix.

Parameters:

nodal –
element –
solidmat –

Returns:

Real getdtfromHydromatrix(Solidmat solidmat, Element element)#

get critical timetsep from hydro matrix.

Parameters:

solidmat –
element –

Returns:

Real getdtfromThermal(Solidmat solidmat, Element element)#

get critical timestep from thermal.

Parameters:

solidmat –
element –

Returns:

Real getdtfromHydrofracture(Solidmat solidmat, Element element, Hydro hydro)#

get critical timestep from hydro fracture.

Parameters:

solidmat –
element –

Returns:

Real getdtfromHydrogas(Solidmat solidmat, Element element, Hydro hydro)#

Real getdtfromCohesive(General general, Element element, Solidmat solidmat)#

get critical timetsep from mechnical CZM.

Parameters:

general –
element –
solidmat –

Returns:

Real getdtfromContact(Solidmat solidmat)#

get critical timestep from mechnical contact.

Parameters:: solidmat –
Returns:

Real getdtfromParticle(Particle particle, Solidmat solidmat)#

get critical timetsep from mechnical DEM.

Parameters:

particle –
solidmat –

Returns:

Real getdtfromHydro(General general, Hydro hydro, Solidmat solidmat, Element element)#

get the minmuum critical timetsep from hydro module.

Parameters:

general –
hydro –
solidmat –
element –

Returns:

void getTimestep(General general, Nodal nodal, Element element, Particle particle, Cohelement cohelement, Contact contact, Solidmat solidmat, Hydro hydro)#

get the critical timetsep at the beginning momment.

Parameters:

general –
nodal –
element –
particle –
cohelement –
contact –
solidmat –
hydro –

void getUpdateTimestep(General general, Nodal nodal, Element element, Particle particle, Cohelement cohelement, Contact contact, Solidmat solidmat, Hydro hydro)#

update the critical timestep during running.

Parameters:

general –
nodal –
element –
particle –
cohelement –
contact –
solidmat –
hydro –

Private Members

Real minmass = Openfdem_max_value#

Real time_step = Openfdem_max_value#

Real dt_matrix = Openfdem_max_value#

Real dt_CZM = Openfdem_max_value#

Real dt_contact = Openfdem_max_value#

Real dt_pcontact = Openfdem_max_value#

Real dt_hydro = Openfdem_max_value#

Real dt_thermal = Openfdem_max_value#

Real fixedTimestep = 0.0#

class InitializeBlastModule : public OpenFdemAbstract#

#include <initialize_Blast_Data.h>

Public Functions

inline InitializeBlastModule()#

inline ~InitializeBlastModule()#

Public Static Functions

static void initializeBlastData(General general, Nodal nodal, Blast blast, Boudary boudary)#

class InitializeCohesiveMatModule : public OpenFdemAbstract#

#include <initialize_CohesiveMat_Data.h>

Public Functions

inline InitializeCohesiveMatModule()#

inline ~InitializeCohesiveMatModule()#

Public Static Functions

static void initializeCohesiveMatData(Cohelement cohelement, Solidmat solidmat, Element element)#

class InitializeCohesiveModule : public OpenFdemAbstract#

#include <initialize_Cohesive_Data.h>

Public Functions

inline InitializeCohesiveModule()#

inline ~InitializeCohesiveModule()#

Public Static Functions

static void initializeCohesiveData(Nodal nodal, Cohelement cohelement, Element element, Solidmat solidmat, General general, Seismic sesmic, Boudary boudary)#

static void buildCohesiveMemory(Cohelement cohelement, General general, Seismic sesmic)#

static void initializeCohesiveDataforExtrinsic(Nodal nodal, Cohelement cohelement, General general)#

static void initializeCohesiveStrength(Cohelement cohelement, Solidmat solidmat, General general)#

static void initializeCohesivefromDFN(Nodal nodal, Cohelement cohelement, General general)#

static void initializeCohesivefromExcavation(Nodal nodal, Element element, Cohelement cohelement, General general)#

class InitializeContactMatModule : public OpenFdemAbstract#

#include <initialize_ContactMat_Data.h>

Public Functions

inline InitializeContactMatModule()#

inline ~InitializeContactMatModule()#

Public Static Functions

static void initializeContactMatData(Solidmat solidmat, Element element)#

class InitializeContactModule : public OpenFdemAbstract#

#include <initialize_Contact_Data.h>

Public Functions

inline InitializeContactModule()#

inline ~InitializeContactModule()#

Public Static Functions

static void initializeContactData(General general, Element element, Contact contact)#

class InitializeElementModule : public OpenFdemAbstract#

#include <initialize_Element_Data.h>

Public Functions

inline InitializeElementModule()#

inline ~InitializeElementModule()#

Public Static Functions

static void initializeElementData(Element element, Intergration intergration, General general, Solidmat solidmat)#

initialize the element structure if the element count is changed.

Parameters:

element –
intergration –
general –
solidmat –

static void InitializeIntergration(Element element, Intergration intergration, Solidmat solidmat)#

Intergration point is mounted on the element, should be updated after the element is rebuild.

Parameters:

element –
intergration –
solidmat –

static void updateElementParameters(Element element, Intergration intergration, General general)#

link the element index to intergration point.

Parameters:

element –
intergration –
general –

static void buildIntergrationMemory(Element element, Intergration intergration, General general, Solidmat solidmat)#

build memory of the new intergrations, which is outside of the gauss point structure.

Parameters:

element –
intergration –
general –
solidmat –

class InitializeGeneralModule : public OpenFdemAbstract#

#include <inline_initialize_General_Data.h>

Public Functions

inline InitializeGeneralModule()#

inline ~InitializeGeneralModule()#

Public Static Functions

static inline void initializeGeneralData(General general)#

class InitializeHistoryModule : public OpenFdemAbstract#

#include <initialize_History_Data.h>

Public Functions

inline InitializeHistoryModule()#

inline ~InitializeHistoryModule()#

Public Static Functions

static void initializeHistoryData(General general, History history)#

class InitializeHydroModule : public OpenFdemAbstract#

#include <initialize_Hydro_Data.h>

Public Functions

inline InitializeHydroModule()#

inline ~InitializeHydroModule()#

Public Static Functions

static void buildHydroData(General general, Hydro hydro, Nodal nodal, Cohelement cohelement, Element element)#

static void buildHydroCavity(General general, Hydro hydro, Nodal nodal)#

static void getHydroParameters(General general, Element element, Hydro hydro, Solidmat solidmat, Nodal nodal)#

static void getHydroBoundaries(Hydro hydro, Boudary boudary)#

static void initializeHydroData(General general, Hydro hydro, Nodal nodal, Element element, Cohelement cohelement, Solidmat solidmat, Boudary boudary)#

class InitializeModule : public OpenFdemAbstract#

#include <solver_initialize_module.h>

Public Functions

inline InitializeModule()#

inline ~InitializeModule()#

Public Static Functions

static void initialize(Openfdem openfdem, char *inputFileName)#

static void getSolidNodalMass(Openfdem openfdem)#

class InitializeMPMModule : public OpenFdemAbstract#

#include <initialize_MPM_Data.h>

Public Functions

inline InitializeMPMModule()#

inline ~InitializeMPMModule()#

Public Static Functions

static void updateMPMmass(MPM mpm, Solidmat solidmat)#

static void updateMPMcontacts(General general, MPM mpm, Boudary boudary)#

static void initializeMPMData(General general, Element element, Nodal nodal, MPM mpm, Solidmat solidmat, Boudary boudary)#

class InitializeNodalModule : public OpenFdemAbstract#

#include <initialize_Node_Data.h>

Public Functions

inline InitializeNodalModule()#

inline ~InitializeNodalModule()#

Public Static Functions

static void initializeNodalData(General general, Nodal nodal, Element element, Cohelement cohelement)#

class InitializeParticleContactModule : public OpenFdemAbstract#

#include <initialize_ParticleContact_Data.h>

Public Functions

inline InitializeParticleContactModule()#

inline ~InitializeParticleContactModule()#

Public Static Functions

static void initializeParticleContactData(Particle particle, PContact pcontact, Solidmat solidmat)#

class InitializeParticleModule : public OpenFdemAbstract#

#include <initialize_Particle_Data.h>

Public Functions

inline InitializeParticleModule()#

inline ~InitializeParticleModule()#

Public Static Functions

static void initializeParticleData(General general, Particle particle, Solidmat solidmat)#

class InitializeThermalModule : public OpenFdemAbstract#

#include <initialize_Thermal_Data.h>

Public Functions

inline InitializeThermalModule()#

inline ~InitializeThermalModule()#

Public Static Functions

static void buildThermalMemory(General general, Thermal thermal, Nodal nodal, Element element)#

static void buildThermalCavity(General general, Thermal thermal, Nodal nodal)#

static void transferThermaldataforNewMesh(General general, Thermal thermal, Nodal nodal)#

static void getThermalBoundaries(Thermal thermal, Boudary boudary)#

static void getThermalParameters(General general, Element element, Thermal thermal, Solidmat solidmat, Nodal nodal)#

static void initializeThermalData(General general, Thermal thermal, Nodal nodal, Element element, Solidmat solidmat, Boudary boudary)#

struct OpenFDEM_structure#

#include <openfdem.h>

Public Members

struct General_structure general#

struct Element_structure element#

struct Intergration_structure intergration#

struct Coh_element_structure cohelement#

struct Contact_structure contact#

struct Nodal_structure nodal#

struct Entity_structure entity#

struct Edge_structure edge#

struct Particle_structure particle#

struct MaterialPoint_structure mpm#

struct PContact_structure pcontact#

struct Group_structure group#

struct Geometry_structure geometry#

struct History_structure history#

struct Solid_mat_structure solidmat#

struct Boundary_structure boudary#

struct Mesh_insert_structure mesh#

struct DFN_structure dfn#

struct Seismic_structure seismic#

struct Blast_structure blast#

struct Hydro_structure hydro#

struct Thermal_structure thermal#

class PushBoundary : public OpenFdemAbstract, public ns_solve::BoundaryUtils #

#include <push_boundaries.h>

Public Functions

inline PushBoundary()#

inline ~PushBoundary()#

Public Static Functions

static void push_nodal_boudary(General general, Boudary boudary, Group group, char *keyword, boundary_mechanical_enum type)#

static void push_pressure_boudary(General general, Boudary boudary, Nodal nodal, Element element, Group group, char *keyword, boundary_mechanical_enum type)#

static void UpdateTimeDependentExcavationBoundary(General general, Nodal nodal, Element element, Cohelement cohelement, Boudary boudary, Group group, Edge edge, const char *keyword)#

static void push_element_boudary(General general, Boudary boudary, Element element, Group group, char *groupTag, boundary_mechanical_enum type)#

static void push_edge_boudary(General general, Boudary boudary, Nodal nodal, Element element, Group group, char *keyword, boundary_mechanical_enum type)#

static void push_hydro_boudary(General general, Boudary boudary, Nodal nodal, Element element, Group group, char *keyword, boundary_fluid_enum type)#

static void push_blast_boudary(General general, Boudary boudary, Nodal nodal, Element element, Group group, Blast blast, char *keyword)#

static void push_thermal_boudary_table(General general, Boudary boudary, Group group, char *keyword, boundary_thermal_enum type)#

static void pushInstantaneousExcavationBoundary(General general, Boudary boudary, Nodal nodal, Element element, Edge edge, Group group, const char *keyword)#

static void pushInstantaneousExcavationBoundary(General general, Boudary boudary, Nodal nodal, Element element, Group group, const char *keyword)#

static void pushTimeDependentExcavationboudary(General general, Nodal nodal, Boudary boudary, Element element, Solidmat solidmat, Group group, char *keyword)#

static void push_uncontacted_boudary(Element element, Group group, char **grouptags, const int groupcount)#

static void push_particle_boudary(General general, Boudary boudary, Particle particle, Group group, char *keyword, boundary_mechanical_enum type)#

static void push_point_boundary(General general, Boudary boudary, Group group, char *keyword, boundary_mechanical_enum type)#

static void push_inletflow_boundary(General general, Boudary boudary, Solidmat solidmat, MPM mpm, char *keyword, UInt type)#

static void push_outletflow_boundary(General general, Boudary boudary, MPM mpm, UInt type)#

class SolveEnergy#

#include <solver_update_energy.h>

Public Functions

inline SolveEnergy()#

inline ~SolveEnergy()#

Public Static Functions

static void solver_update_energy(General general, Nodal nodal, Element element, Intergration intergration, Cohelement cohelement, Contact contact)#

static inline Real computeKineticonNode(Real mass, Vector2 &vel)#

compute the kinetic energy on the node. E_k = 1/2 * m * v^2;

Parameters:

nodal –
nodeid –

Returns:

static inline Real computeGravityenergyconNode(Real mass, Vector2 &gravity, Vector2 &coord)#

compute the gravity potentional energy on the node.

Parameters:

general –
nodal –
nodeid –

Returns:

class SolveParticle : public ns_solve::BoundaryUtils #

#include <solve_particles.h>

Subclassed by ns_solve::SolverModule

Public Functions

inline SolveParticle()#

inline ~SolveParticle()#

Public Static Functions

static void solver_particles(General general, Nodal nodal, Particle particle, Boudary boudary)#

static bool applyParticlegravity(General general, Particle particle)#

static void applyParticleExternalForce(General general, Particle particle, Boudary boudary)#

static void applyParticleExternalVelocity(General general, Particle particle, Boudary boudary)#

static Real computeMaxParticleVelocity(General general, Particle particle)#

static void updateParticleinDomain(General general, Particle particle)#

static bool applyParticleRotation(General general, Particle particle, Boudary boudary)#

class SolveRigid : public ns_solve::BoundaryUtils #

#include <solve_rigid_entities.h>

Subclassed by ns_solve::SolverModule

Public Functions

inline SolveRigid()#

inline ~SolveRigid()#

Public Static Functions

static void solver_rigid(Element element, General general, Nodal nodal, Entity entity, Boudary boudary)#

static bool applyRigidGravity(General general, Nodal nodal, Vector2 *gravity)#

static void applyRigidExternalForce(Vector2 &value, Real &spin, Int &spintype, const UInt bi, General general, Entity entity, Boudary boudary)#

static void applyRigidRotation(Real spin, const UInt bi, Nodal nodal, General general, Entity entity, Boudary boudary)#

class SolverModule : public ns_solve::SolveParticle, public ns_solve::SolveSolid, public ns_solve::SolveRigid, public ns_solve::ExplicitTimestep #

#include <openfdem_solve_module.h>

Public Functions

inline SolverModule()#

inline ~SolverModule()#

Public Static Functions

static void Openfdem_main_solve(Openfdem openfdem)#

class SolveSolid : public ns_solve::BoundaryModule #

#include <solve_deformable_solids.h>

Subclassed by ns_solve::SolverModule

Public Functions

inline SolveSolid()#

inline ~SolveSolid()#

Public Static Functions

static void solver_deformable(General general, Boudary boudary, Solidmat solidmat, Element element, Edge edge, Cohelement cohelement, Nodal nodal, Entity entity, MPM mpm)#

struct table_type#

#include <openfdem_boundary.h>

Public Functions

table_type() = default#

void clear()#

Public Members

std::string tag#

UInt size = 0#

std::vector<Vector2> value#

Real activateTime = 0.0#

namespace ns_common

namespace ns_solve

file boundary_utils.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “iohelper/parser/parser_module.h”

file openfdem_boundary.h

#include “common/openfdem_common.h”

#include “common/openfdem_enum.h”

Defines

BOUNDARY_TABLE_SIZE#

BOUNDARY_TABLE_COMPOMENT_SIZE#

BOUNDARY_X_TABLE_ID#

BOUNDARY_Y_TABLE_ID#

BOUNDARY_R_TABLE_ID#

Typedefs

typedef struct Boundary_structure *Boudary#

file push_boundaries.h: #include <solver/boudary/boundary_utils.h>

#include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “iohelper/parser/parser_module.h”

file solver_boundary_module.h: #include <solver/boudary/boundary_utils.h>

#include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “iohelper/parser/parser_module.h”

file explicit_timestep.h: #include “solver/openfdem.h”

file initialize_Blast_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_Cohesive_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_CohesiveMat_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_Contact_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_ContactMat_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_Element_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_History_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_Hydro_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_MPM_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_Node_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_Particle_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_ParticleContact_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file initialize_Thermal_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file inline_initialize_General_Data.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solver/openfdem.h”

file solver_initialize_module.h: #include “common/memory_manager.h”

#include “common/openfdem_abstract.h”

#include “common/openfdem_message.h”

#include “solid/integration/integratorbase.h”

#include “solver/initialize/initialize_Blast_Data.h”

#include “solver/initialize/initialize_CohesiveMat_Data.h”

#include “solver/initialize/initialize_Cohesive_Data.h”

#include “solver/initialize/initialize_ContactMat_Data.h”

#include “solver/initialize/initialize_Contact_Data.h”

#include “solver/initialize/initialize_Element_Data.h”

#include “solver/initialize/initialize_Hydro_Data.h”

#include “solver/initialize/initialize_MPM_Data.h”

#include “solver/initialize/initialize_Node_Data.h”

#include “solver/initialize/initialize_ParticleContact_Data.h”

#include “solver/initialize/initialize_Particle_Data.h”

#include “solver/initialize/initialize_Thermal_Data.h”

#include “solver/initialize/inline_initialize_General_Data.h”

#include <solver/initialize/initialize_History_Data.h>

#include “solver/openfdem.h”

file openfdem.h

#include “blast/openfdem_blast.h”

#include “boudary/openfdem_boundary.h”

#include “common/openfdem_general.h”

#include “contact/openfdem_solid_contact.h”

#include “geometry/openfdem_geometry.h”

#include “hydro/openfdem_hydro.h”

#include “iohelper/dumper/openfdem_history.h”

#include “mesh/group/openfdem_group.h”

#include “mesh/openfdem_mesh_insert.h”

#include “mpm/openfdem_MPM.h”

#include “particles/openfdem_pContact.h”

#include “particles/openfdem_particle.h”

#include “solid/integration/openfdem_intergration.h”

#include “solid/materials/openfdem_mat.h”

#include “solid/openfdem_edge.h”

#include “solid/openfdem_entity.h”

#include “solid/openfdem_nodal.h”

#include “solid/solid_mechanics/openfdem_solid.h”

#include “solid/solid_mechanics_cohesive/DFN/openfdem_DFN.h”

#include “solid/solid_mechanics_cohesive/openfdem_solid_cohesive.h”

#include “solid/solid_mechanics_cohesive/sesmic/openfdem_sesmic.h”

#include “thermal/openfdem_thermal.h”

Typedefs

typedef struct OpenFDEM_structure *Openfdem#

file openfdem_solve_module.h: #include “solver/openfdem.h”

#include “solver/solve_particles.h”

#include “solver/solve_rigid_entities.h”

#include “solver/solve_deformable_solids.h”

#include “solver/solver_update_energy.h”

#include <solver/explicit_timestep.h>

file solve_deformable_solids.h: #include <solver/boudary/solver_boundary_module.h>

#include “common/memory_manager.h”

#include “solver/openfdem.h”

#include “solver/solve_deformable_solids.h”

file solve_particles.h: #include <solver/boudary/boundary_utils.h>

#include “solver/openfdem.h”

file solve_rigid_entities.h: #include <solver/boudary/boundary_utils.h>

#include “common/memory_manager.h”

#include “solver/openfdem.h”

file solver_update_energy.h: #include “common/memory_manager.h”

#include “solver/openfdem.h”

dir boudary

dir initialize

dir solver

dir src