PyLith Application Flow#

The PyLith application driver performs two main functions. First, it collects all user parameters from input files (e.g., .cfg files) and the command line, and then it performs from simple checks on the parameters. Second, it launches the MPI job.

Once the MPI job launches, the application flow is:

  1. Read the finite-element mesh; pylith.meshio.MeshImporter.

    1. Read the mesh (serial); pylith::meshio::MeshIO.

    2. Reorder the mesh, if desired; pylith::topology::ReverseCuthillMcKee.

    3. Insert cohesive cells as necessary (serial); pylith::faults::FaultCohesive.

    4. Distribute the mesh across processes (parallel); pylith::topology::Distributor.

    5. Refine the mesh, if desired (parallel); pylith::topology::RefineUniform.

  2. Setup the problem.

    1. Preinitialize the problem by passing information from Python to C++ and doing minimal setup pylith.Problem.preinitialize().

    2. Perform consistency checks and additional checks of user parameters; pylith.Problem verifyConfiguration().

    3. Complete initialization of the problem; pylith::problems::Problem::initialize().

  3. Run the problem; pylith.problems.Problem.run().

  4. Cleanup; pylith.problems.Problem.finalize().

    1. Close output files.

    2. Deallocate memory.

    3. Output PETSc log summary, if desired.

In the first step, we list the object performing the work, whereas in subsequent steps we list the top-level object method responsible for the work. Python objects are listed using the path.class syntax while C++ objects are listed using namespace::class syntax. Note that a child class may redefine or perform additional work compared to what is listed in the parent class method.

Reading the mesh and the first two steps of the problem setup are controlled from Python. That is, at each step Python calls the corresponding C++ methods using SWIG. Starting with the complete initialization of the problem, the flow is controlled at the C++ level.

Time-Dependent Problem#

In a time-dependent problem the PETSc TS object (relabeled PetscTS within PyLith) controls the time stepping. Within each time step, the PetscTS object calls the PETSc linear and nonlinear solvers as needed, which call the following methods of the C++ pylith::problems::TimeDependent object as needed: computeRHSResidual(), computeLHSResidual(), and computeLHSJacobian(). The pylith::problems::TimeDependent object calls the corresponding methods in the boundary conditions, constraints, and materials objects. At the end of each time step, it calls problems::TimeDependent::poststep().