fedoo.problem.ExplicitDynamic

class ExplicitDynamic(assembly, time_step, integrator=None, mass_lumping=True, name='MainProblem')

Explicit structural dynamics with a user-controlled increment loop.

The low-level workflow intentionally mirrors the other Fedoo problems:

pb.initialize()
pb.apply_boundary_conditions()
while ...:
    pb.solve()
    pb.update()

solve() only solves the effective system already prepared for the current increment. update() advances displacement, velocity and acceleration. Updating the weakform and constitutive law is optional; the default linear path uses the stiffness matrix cached by initialize().

For nonlinear work, solve_time_increment() manages the integrator’s force-evaluation state, weakform update, solve, kinematic update and optional state commit. evaluate() exposes the prediction/evaluation stage for advanced user loops. That stage mainly matters for explicit generalized-alpha schemes; centered difference evaluates forces at the current state. solve_history() provides the same linear/nonlinear choice for a complete time history.

Parameters:

• assembly (AssemblyBase or str) – Static structural assembly, or its registered name.

• time_step (float) – Constant time increment used by the manual loop.

• integrator (ExplicitSecondOrderIntegrator, optional) – Explicit time integrator. Defaults to CentralDifference.

• mass_lumping (bool, default=True) – Row-sum lump finite-element storage. Assembly-level storage providers keep their declared matrix blocks and are never lumped implicitly.

• name (str, default="MainProblem") – Problem name.

Notes

Finite-element stiffness and mass are cached after initialization. A mass refresh is therefore opt-in through update_mass=True. Assembly-level providers are conservatively treated as configuration-dependent unless they define storage_matrix_is_constant = True.

update_weakform=False is appropriate only when the cached stiffness describes the internal force, for example linear elasticity with fixed geometry. Use update_weakform=True for nonlinear constitutive laws, changing geometry, contact, or other state-dependent contributions.

__init__(assembly, time_step, integrator=None, mass_lumping=True, name='MainProblem')

Methods

ExplicitDynamic.add_global_dof(variable_names)	Add global degrees of freedom to the problem.
ExplicitDynamic.add_output(filename, assembly)	Add output requirement for automatic saving during nlsolve.
ExplicitDynamic.apply_boundary_conditions([...])
ExplicitDynamic.evaluate([update_weakform, ...])	Prepare the integrator's force-evaluation state.
ExplicitDynamic.get_A()
ExplicitDynamic.get_B()
ExplicitDynamic.get_D()
ExplicitDynamic.get_X()
ExplicitDynamic.get_acceleration([name])
ExplicitDynamic.get_active()	Return the active Problem.
ExplicitDynamic.get_all()	Return the list of all problems.
ExplicitDynamic.get_damping_power()
ExplicitDynamic.get_disp([name])
ExplicitDynamic.get_dof_solution([name])
ExplicitDynamic.get_elastic_energy()
ExplicitDynamic.get_ext_forces([name, ...])	Return the nodal Forces in global coordinates system.
ExplicitDynamic.get_kinetic_energy()
ExplicitDynamic.get_results(*args, **kargs)	Extract some results from the current problem.
ExplicitDynamic.get_velocity([name])
ExplicitDynamic.init_bc_start_value()
ExplicitDynamic.initialize()	Initialize constitutive data and cache stiffness and mass.
ExplicitDynamic.invalidate_factorization()	Invalidate any cached factorization.
ExplicitDynamic.make_active()	Define the problem instance as the active Problem.
ExplicitDynamic.prepare_time_increment([...])	Prepare A and D for one subsequent call to solve().
ExplicitDynamic.reset()
ExplicitDynamic.save_results([iterOutput])
ExplicitDynamic.set_A(A)
ExplicitDynamic.set_B(B)
ExplicitDynamic.set_D(D)
ExplicitDynamic.set_X(value)
ExplicitDynamic.set_active(name)	Define the active Problem from its name.
ExplicitDynamic.set_dof_solution(name, value)
ExplicitDynamic.set_initial_acceleration(...)
ExplicitDynamic.set_initial_displacement(...)
ExplicitDynamic.set_initial_velocity(name, value)
ExplicitDynamic.set_rayleigh_damping(alpha, beta)	Override weakform damping with C = alpha*M + beta*K.
ExplicitDynamic.set_reuse_factorization([reuse])	Enable or disable factorization reuse for repeated solves.
ExplicitDynamic.set_solver([solver])	Define the solver for the linear system resolution.
ExplicitDynamic.set_start([save_results, ...])	Commit assembly history and optionally save the accepted state.
ExplicitDynamic.set_time_integrator(...)	Attach an explicit second-order time integrator.
ExplicitDynamic.solve(**kwargs)	Solve the current effective system using Problem.
ExplicitDynamic.solve_history(tmax[, dt, ...])	Solve a complete explicit-dynamic time history.
ExplicitDynamic.solve_time_increment([...])	Prepare, solve and update one complete explicit increment.
ExplicitDynamic.to_start()	Restore the last state committed by set_start().
ExplicitDynamic.update([compute, ...])	Advance kinematics and optionally update the assembly.
ExplicitDynamic.update_boundary_conditions()

ExplicitDynamic.active
ExplicitDynamic.assembly
ExplicitDynamic.global_dof
ExplicitDynamic.n_dof
ExplicitDynamic.n_global_dof
ExplicitDynamic.n_node_dof
ExplicitDynamic.name	Return the name of the Problem.
ExplicitDynamic.results
ExplicitDynamic.solver	Return the current solver used for the problem.
ExplicitDynamic.space	Return the ModelingSpace associated to the Problem if defined.
ExplicitDynamic.time_integrator
ExplicitDynamic.bc	Boundary conditions defined on the problem.