CIEM1110#
The written exam for CIEM1110 is closed-book and covers content across the whole of Unit 1. 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 weeks 1 to 4. 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 and diffusionmodel.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 and here
FEM for diffusion#
Semi-discrete form for diffusion: Arriving at a semi-discrete form for diffusion problems is an important concept that might appear in the exam. The different possible physical interpretations of the terms in the PDE are provided for context but will not be assessed. The effect of adding extra terms to the strong form PDE (c.f. the Poisson 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 diffusion equation. When necessary, Eq. (6.4) will be given to you. Familiarizing yourself with both notations on the page is a useful way to understand how FEM works, but converting between these notations will not be part of the exam.
Time stepping algorithms for diffusion: You might see questions about time steppers for diffusion. 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 time steppers for diffusion. Discerning the different roles of FEM and the time stepper in reaching a fully-discretized system of equations is important.
Where is this in pyJive?
Code for computing and assembling \(\mathbf{K}\) and \(\mathbf{M}\) can be found in diffusionmodel.py. All three time steppers we cover for diffusion are implemented in trapezoidalmodule.py. Time-dependent BCs can also be handled by dirimodel.py and neumannmodel.py, through the dispIncr, loadIncr and timeSignal properties.
Relevant lecture slides for this part can be found here
Nonlinear FEM for mechanics#
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. Geometric nonlinearities will not be part of the exam.
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.
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?
The code for computing \(\mathbf{K}\) is the same as for the linear case (solidmodel.py). 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.
Relevant lecture slides for this part can be found here, here and here.
Coding, Python and pyJive#
Implementing FEM and extending existing implementations are essential parts of the learning outcomes of CIEM1110. 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.
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:
../dynamics/Exercises/pyjive_diffusion
../solid_nonlinear/Exercises/pyjive_nonlinmodule
../solid_nonlinear/Exercises/pyjive_material
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.