Cardiac tissue primarily consists of interconnected cardiac cells which contract in a synchronized manner as the heart beats. Most computational models of cardiac tissue, however, homogenize out the individual cells and their surroundings. This approach has been immensely useful for describing cardiac mechanics on an overall level, but gives very limited understanding of the interaction between individual cells and their intermediate surroundings. Several models have been developed for single cells, see e.g. [1, 2]. In this work, we extend the mechanical part of these frameworks to a domain representing multiple cells, allowing us to investigate cell-matrix and cell-cell interactions. We present a mechanical model in which each cell and the extracellular matrix have an explicit geometrical representation, similar to the electrophysiological model presented in [3]. The strain energy functions are defined separately for each of the intracellular and extracellular subdomains, while we assume continuity of displacement and stresses along the membrane. Active tension is only assigned to the intracellular subdomain. For each state, we find an equilibrium solution using the finite element method. We explore passive and active mechanics for a single cell surrounded by an extracellular matrix and for small collections of cells combined into tissue blocks. The explicit geometric representation gives rise to highly varying strain and stress patterns. We show that the extracellular matrix stiffness highly influences the cardiomyocyte stresses during contraction. Through large-scale simulations enabled by high-performance computing, we also demonstrate that our model can be scaled to small collections of cells, resembling small cardiac tissue samples.

[1] Tracqui, T. and Ohayon, J. An integrated formulation of anisotropic force–calcium relations driving spatio-temporal contractions of cardiac myocytes. Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences (2009).
[2] Ruiz-Baier, R. Gizzi, A., Rossi, S. Cherubini, C. Laadhari, A. Filippi, S. and Quarteroni, A. Mathematical modelling of active contraction in isolated cardiomyocytes. Mathematical Medicine and Biology (2014).
[3] Tveito, A., Jæger, KH. Kuchta, M. Mardal, K-A. and Rognes, ME. A cell-based framework for numerical modeling of electrical conduction in cardiac tissue. Frontiers in Physics (2017).
\end{thebibliography}

Developing high-performance finite element codes normally requires hand-crafting and fine tuning of computational kernels, which is not an easy task to carry out for each and every problem. Automated code generation has proved to be a highly productive alternative for frameworks like FEniCS, where a compiler is used to automatically generate suitable kernels from high-level mathematical descriptions of finite element problems. This strategy has so far enabled users to develop and run a variety of high-performance finite element solvers on clusters of multicore CPUs. We have recently enhanced FEniCS with GPU acceleration by enabling its internal compiler to generate CUDA kernels that are needed to offload finite element calculations to GPUs, particularly the assembly of linear systems. This poster presents the results of GPU-accelerating FEniCS and explores performance characteristics of auto-generated CUDA kernels and GPU-based assembly of linear systems for finite element methods.

Parallel computations with irregular memory access patterns are often limited by the memory subsystems of multi-core CPUs, though it can be difficult to pinpoint and quantify performance bottlenecks precisely. We present a method for estimating volumes of data traffic caused by irregular, parallel computations on multi-core CPUs with memory hierarchies containing both private and shared caches. Further, we describe a performance model based on these estimates that applies to bandwidth-limited computations. As a case study, we consider two standard algorithms for sparse matrix–vector multiplication, a widely used, irregular kernel. Using three different multi-core CPU systems and a set of matrices that induce a range of irregular memory access patterns, we demonstrate that our cache simulation combined with the proposed performance model accurately quantifies performance bottlenecks that would not be detected using standard best- or worst-case estimates of the data traffic volume.

We present an experimental form compiler for exploring GPU-based algorithms for assembling vectors, matrices, and higher-order tensors from finite element variational forms.

Previous studies by Cecka et al. (2010), Markall et al. (2013), and Reguly and Giles (2015) have explored different strategies for using GPUs for finite element assembly, demonstrating the potential rewards and highlighting some of the difficulties in offloading assembly to a GPU. Even though these studies are limited to a few specific cases, mostly related to the Poisson problem, they already indicate that to achieve high performance, the appropriate assembly strategy depends on the problem at hand and the chosen discretisation.

By using a form compiler to automatically generate code for GPU-based assembly, we can explore a range of problems based on different variational forms and finite element discretisations. In this way, we aim to get a better picture of the potential benefits and challenges of assembling finite element variational forms on a GPU. Ultimately, the goal is to explore algorithms based on automated code generation that offload entire finite element methods to a GPU, including assembly of vectors and matrices and solution of linear systems.

In this talk, we give an exact characterisation of the class of finite element variational forms supported by our compiler, comprising a small subset of the Unified Form Language that is used by FEniCS and Firedrake. Furthermore, we describe a denotational semantics that explains how expressions in the form language are translated to low-level C or CUDA code for performing assembly over a computational mesh. We also present some initial results and discuss the performance of the generated code.