CIEM5110#
The written exam is closed-book. You will see primarily open questions, but we also include multiple-choice questions on occasion. The questions will cover both theoretical and implementational aspects.
Below we give an overview of exam tips that can be used as a study guide for the contents of Unit 2. Going through the following sections in order and making use of the provided links should provide you with a structured way to prepare for the written exam. Looking at related pyJive code as you study can also be insightful.
Preliminaries#
Tensor basics: Tensor concepts will not be assessed in isolation in the exam, but they are crucial in deriving finite element formulations. You will not be asked to use a specific notation when performing derivations, you are therefore free to pick the one that makes most sense for the derivation you are performing.
Linear algebra: Linear algebra concepts will not be assessed in isolation in the exam, but they are crucial in deriving finite element formulations.
Tensor calculus: Tensor calculus concepts will not be assessed in isolation in the exam, but they are crucial in deriving finite element formulations. You will not be asked to manually arrive at expressions for integration by parts, but you should be able to use the final results of Eqs. (1.32) and (1.34) during the exam without being given the expressions.
Where is this in pyJive?
In pyJive we rely heavily on numpy for linear algebra computations. Matrix multiplications can be seen for instance in models such as solidmodel.py. We also use scipy for handling sparse matrices and solving systems of equations, for instance in solvermodule.py and nonlinmodule.py.
Lecture slides from this part can be found here.
MUDE recap and additional material#
Strong form of the 1D Poisson equation: You might see questions about the strong form of the Poisson equation, but mainly as the starting point for an FE derivation. You will not be asked to arrive at strong-form PDEs during the exam. Any strong forms you might need will be given to you.
From strong to weak form: Deriving weak forms for FEM starting from the strong form is a crucial concept that you will likely see in the exam. This includes applying integration by parts and enforcing Dirichlet and Neumann boundary conditions. You should also keep in mind how boundary integrals arise from the formulation and why some of these boundary terms drop from the expressions. The Poisson PDE is a good place to start, but you should be ready to perform these steps for any given PDE.
From weak to discrete form: This page contains several important concepts. You should be ready to answer questions about properties of shape functions, the role and derivation of the \(\mathbf{B}\) matrix, transitioning from the weak to the discrete form, and arriving at expressions for \(\mathbf{K}\) and \(\mathbf{f}\). Again the Poisson PDE is used for illustration but you should be able to use the same conceptual steps for any PDE. You might be asked to reproduce these formulations step by step.
Finite element implementation: This page contains a standalone implementation which is quite insightful before studying more complex pyJive code. Details of this specific implementation will not be part of the exam, but you might see questions about assembling \(\mathbf{K}\) and \(\mathbf{f}\) and applying Dirichlet boundary conditions. The fact that \(\mathbf{K}\) is singular before any BCs are enforced is also important to remember.
Elements and shape functions: You might be asked about basic properties of shape functions and questions about the continuity of the solution and of derived fields across element boundaries. You do not need to memorize the given expressions for \(N_i\), but you might be asked to derive polynomial expressions for shape functions for simple elements with given nodal coordinates.
Numerical integration: Questions about numerical integration might be part of the exam, especially regarding the highest polynomial order that can be achieved with a given number of integration points. Given a certain discrete FE problem, you might be asked to compute how many integration points would be needed to guarantee exact integration. You do not need to memorize quadrature tables such as the one at the end of the page.
Poisson equation in 2D: When considering formulations of general dimensionality (i.e. 1D, 2D or 3D), the formulation steps are the same but keep an eye out for questions about the sizes of the resulting matrices and vectors.
Isoparametric mapping: This page contains crucial concepts in understanding how FEM is implemented in computer code. You might see questions about isoparametric mapping in the exam, including how it enables numerical integration to be performed on the reference element and the role of the Jacobian matrix in transforming derivatives of shape functions between systems.
Where is this in pyJive?
Strong/weak form PDEs do not appear in pyJive. The formulations are directly implemented in discrete form. In fact the motivation for the strong–weak–discrete derivation is to arrive at a formulation that can be translated to computer code. Code for computing \(\mathbf{K}\) for Poisson problems can be found in poissonmodel.py. Boundary conditions are applied with a combination of dirimodel.py (Dirichlet), neumannmodel.py (Neumann) and the utility class utils/constrainer.py. Code used to implement isoparametric mapping and numerical integration can be found in utils/paramshapes.py
FEM for linear elastostatics#
Strong form for linear elasticity: You will not be asked to derive the strong form PDE for equilibrium in the exam. When needed, the final PDE of Eq. (3.18) will be given to you. Understanding how to move from displacements to strain, and the relationship between strains and stresses might nevertheless be necessary to answer formulation questions.
From strong to discrete form: You might see a range of exam questions about the topics in this page. Being able to arrive at a discrete FE form starting from a strong form PDE is an essential learning outcome of this course, with the formulation on this page providing a representative example. Aside from formulation questions, you might also be asked conceptual questions related to implementing and assembling \(\mathbf{K}\), the sizes of the involved matrices and vectors, and the different ways boundary conditions can be applied.
Where is this in pyJive?
The implementation of \(\mathbf{K}\) for elastostatics can be found in elasticmodel.py and solidmodel.py. Assembling \(\mathbf{K}\) also requires each element to know its own DOF indices. This is facilitated by utils/dofspace.py. The solution of linear FEM systems is performed by solvermodule.py. Boundary conditions are still handled by dirimodel.py, neumannmodel.py and utils/constrainer.py.
Relevant lecture slides for this part can be found here
FEM for linear frame analysis#
Timoshenko Beam: Arriving at the discrete form for the Timoshenko problem is an important formulation which you might see appearing in the exam. The formlation is also a good example of solving coupled differential equations with FEM, a concept that might be explored with exam questions about systems of PDEs other than Timoshenko. You should also be able to explain the source of the phenomenon of shear locking and how to solve it, which might be assessed either with conceptual questions or demonstrated with simple calculations.
2D frame analysis: The extension of the Timoshenko formulation with yet another PDE for extension is another demonstration of solving multiple PDEs together with FEM, but you should be aware of the difference between solving coupled and uncoupled PDEs.
Where is this in pyJive?
The implementation of \(\mathbf{K}\) for Timoshenko beam elements without extension can be found in timoshenkomodel.py. As this model cannot be used for frame analysis, the extensible version of the element is implemented in framemodel.py, including coordinate transformations. To get the linear version of the element, we set subtype = linear when using the model.
Relevant lecture slides for this part can be found here
Nonlinear FEM#
Towards nonlinear problems: There might be conceptual questions about incremental FE simulations in the exam. The concept of tangent stiffness matrices and the need for path following algorithms is also important.
Linearized discrete form: The consistent linearization of \(\mathbf{f}_\mathrm{int}\) can be the subject of exam questions. Arriving at the two potentially nonlinear terms and assigning them a physical interpretation are crucial concepts. The definition of tangent stiffnesses \(\mathbf{K}\) and \(\mathbf{D}\) might also be necessary when solving exam questions. You might be asked to reproduce the virtual work formulation needed to arrive at an expression for \(\mathbf{f}_\mathrm{int}\).
Incremental-iterative algorithms: The algorithms for load and displacement control might be the subject of exam questions. You are not expected to be able to write down the algorithms from scratch, but the main operations involved and the order with which they happen should be familiar to you. You might also see questions related to the advantages and limitations of load and displacement control.
Geometrically nonlinear problems: You need to know that a nonlinear definition of strain causes the \(\mathbf{B}\)-matrix to depend on the solution. The stiffness matrix then has two terms, coming from the product rule of differentiation. The exam might have questions about how an eigenvalue problem can be formulated for linear buckling analysis and how type of output obtained from the linear buckling analysis differs from that obtained from an incremental-iterative algorithm. It is important that you know the assumptions under which linear buckling analysis is accurate.
Material non-linearity: The way in which the displacement control algorithm is extended to accommodate nonlinear materials is quite important to remember, especially the relation between the incremental analysis approach and handling of internal variables. You might see questions about the different material models in the overview, but you do not need to memorize any of the expressions on the page. Possible formulation questions will include all necessary expressions to get you started.
Where is this in pyJive?
For frame analysis, geometric nonlinearity is implemented directly in framemodel.py and can be used by setting subtype = nonlin, while material nonlinearity in the form of plastic hinges can be enabled by setting a suitable value for Mp. For continuum simulations, code for computing \(\mathbf{K}\) is the same as for the linear case (solidmodel.py). Material nonlinearity arises directly from the computed \(\boldsymbol\sigma\) and \(\mathbf{D}\) at the integration points. This means that the update function (e.g. from materials/j2material.py or materials/maxwellmaterial.py) return the tangent material stiffness. Path following in load or displacement control is performed by nonlinmodule.py, while code for arc-length path following can be found in arclenmodule.py.
Relevant lecture slides for this part can be found here, here, here, here and here.
Dynamics with FEM#
Semi-discrete form for elasto-dynamics: Arriving at a semi-discrete form for dynamics problems is an important concept that might appear in the exam. The effect of adding extra terms to the strong form PDE (c.f. the static equilibrium equation) and the resulting consequences for the discrete form are important. You will not be asked to arrive at the strong-form version of the equilibrium equation. When necessary, Eq. (6.38) will be given to you.
Time stepping schemes for elasto-dynamics: You might see questions about time steppers for dynamics. You do not need to memorize any expressions but might be asked to arrive at them in a step-by-step fashion. You might also see conceptual questions about accuracy and stability of different time steppers. Discerning the different roles of FEM and the time stepper in reaching a fully-discretized system of equations is important.
Modal Analysis: The analogy between frequency analysis and linear buckling analysis is an important concept. You should be familiar with the interpretation of the result that comes from the eigenvalue problem that is solved.
Dynamics simulations with FEM come in different flavors. Depending on the application, we might be satisfied with just computing vibration frequencies and modes, or opt for implicit or explicit simulations. The exam might include conceptual questions about picking different dynamics models for different applications.
Where is this in pyJive?
Aside from \(\mathbf{K}\), we also need the mass matrix to perform dynamics simulations. You can find it in solidmodel.py and framemodel.py for continuum and frame elements, respectively. Different modules can be used together with these models to achieve different types of simulation: modeshapemodule.py for modal analysis, explicittimemodule.py for central difference time stepping and newmarkmodule.py for implicit time stepping.
Relevant lecture slides for this part can be found here.
Coding, Python and pyJive#
Implementing FEM and extending existing implementations are essential parts of the learning outcomes of CIEM5110. However, implementation details specific to pyJive will not be part of the exam.
You should therefore NOT worry about, for instance:
How the FE mesh is read and how it is stored
How to write an input file for pyJive and how it is read
Naming conventions, data storage structures
Postprocessing routines
Coding style, efficiency and elegance
The main idea behind dividing tasks between models and modules is important, namely that models handle the physics of the problem (e.g. computing \(\mathbf{K}\)) and modules perform the necessary algorithmic operations (e.g. solving systems). You do not need to memorize model/module names or a list of which ones are included in the code. We have showed several times that the same module can be used for different models, and vice versa. You might therefore see questions about combining different models and modules to achieve different types of analysis.
The code is implemented in Python, but exam questions will not be specifically aimed at assessing your Python knowledge (e.g. finding bugs). Coding questions will focus instead on algorithms that link with the theory part of the course and on can be found in any FEM code, for instance:
Conceptual steps in computing and assembling \(\mathbf{K}\) and \(\mathbf{f}\)
Handling boundary conditions
Conceptual steps of common solution algorithms (e.g. assemble \(\mathbf{K}\) \(\Rightarrow\) assemble \(\mathbf{f}\) \(\Rightarrow\) apply constraints \(\Rightarrow\) solve \(\mathbf{K}\mathbf{a}=\mathbf{f}\))
Handling problems of different natures and sizes (e.g. sizes and contents of \(\mathbf{N}\), \(\mathbf{B}\) and \(\mathbf{K}\))
Obviously and most importantly, you do not need to memorize any code.
Introduction slides about pyJive can be found here.
Exercises, past exams and other practice materials#
It is useful to revisit the exercises covered during our workshops:
../solid_nonlinear/Exercises/pyjive_buckling
../solid_nonlinear/Exercises/pyjive_plastic_hinges
../solid_nonlinear/Exercises/pyjive_frame_exercise
../solid_nonlinear/Exercises/pyjive_nonlinmodule
../dynamics/Exercises/pyjive_frequency
../dynamics/Exercises/pyjive_transient
../dynamics/Exercises/pyjive_hammer
You can also find example conceptual questions here:
Sample questions (with solutions): These are questions from a FEM course from the old curriculum. Some questions are therefore slightly out of scope for this course, although it is still possible to work them out with the contents of this book.