Add strong scaling GPU actions table

Currently buggy, there seems to be a mix-up in the ordering of x and y coordinates somewhere.

This probably stems from the use of row+column ordering.

.gitignore

@@ -1 +1,4 @@
 *.swp
+outdir
+venv
+dump

doc/README.md

@@ -0,0 +1,7 @@
+# Documentation
+
+## LaTeX
+
+LaTeX documents are hosted on Overleaf:
+
+- [Exposé](https://www.overleaf.com/project/64aebb0f1f9c35e8b5d1f294)

doc/research/references.bib

@@ -1,3 +1,101 @@
+@article{chaudhuri2020,
+   abstract = {Substantial research over the past two decades has established that extracellular matrix (ECM) elasticity, or stiffness, affects fundamental cellular processes, including spreading, growth, proliferation, migration, differentiation and organoid formation. Linearly elastic polyacrylamide hydrogels and polydimethylsiloxane (PDMS) elastomers coated with ECM proteins are widely used to assess the role of stiffness, and results from such experiments are often assumed to reproduce the effect of the mechanical environment experienced by cells in vivo. However, tissues and ECMs are not linearly elastic materials—they exhibit far more complex mechanical behaviours, including viscoelasticity (a time-dependent response to loading or deformation), as well as mechanical plasticity and nonlinear elasticity. Here we review the complex mechanical behaviours of tissues and ECMs, discuss the effect of ECM viscoelasticity on cells, and describe the potential use of viscoelastic biomaterials in regenerative medicine. Recent work has revealed that matrix viscoelasticity regulates these same fundamental cell processes, and can promote behaviours that are not observed with elastic hydrogels in both two- and three-dimensional culture microenvironments. These findings have provided insights into cell–matrix interactions and how these interactions differentially modulate mechano-sensitive molecular pathways in cells. Moreover, these results suggest design guidelines for the next generation of biomaterials, with the goal of matching tissue and ECM mechanics for in vitro tissue models and applications in regenerative medicine. This Review explores the role of viscoelasticity of tissues and extracellular matrices in cell–matrix interactions and mechanotransduction and the potential utility of viscoelastic biomaterials in regenerative medicine.},
+   author = {Ovijit Chaudhuri and Justin Cooper-White and Paul A. Janmey and David J. Mooney and Vivek B. Shenoy},
+   doi = {10.1038/s41586-020-2612-2},
+   issn = {1476-4687},
+   issue = {7822},
+   journal = {Nature 2020 584:7822},
+   keywords = {Humanities and Social Sciences,Science,multidisciplinary},
+   month = {8},
+   pages = {535-546},
+   pmid = {32848221},
+   publisher = {Nature Publishing Group},
+   title = {Effects of extracellular matrix viscoelasticity on cellular behaviour},
+   volume = {584},
+   url = {https://www.nature.com/articles/s41586-020-2612-2},
+   year = {2020},
+}
+@article{sheu2001,
+   abstract = {The influence of glutaraldehyde as a crosslinking agent to increase the strength of collagen matrices for cell culture was examined in this study. Collagen solutions of 1% were treated with different concentrations (0-0.2%) of glutaraldehyde for 24h. The viscoelasticity of the resulting collagen gel solution was measured using dynamic mechanical analysis (DMA), which demonstrated that all collagen gel solutions examined followed the same model pattern. The creep compliance model of Voigt-Kelvin satisfactorily described the change of viscoelasticity expressed by these collagen gel solutions. These crosslinked collagen gel solutions were freeze-dried to form a matrix with a thickness of about 0.2-0.3mm. The break modulus of these collagen matrices measured by DMA revealed that the higher the degree of crosslinking, the higher the break modulus. The compatibility of fibroblasts isolated from nude mouse skin with these collagen matrices was found to be acceptable at a cell density of 3×105cells/cm2 with no contraction, even when using a concentration of glutaraldehyde of up to 0.2%. Copyright © 2001 Elsevier Science Ltd.},
+   author = {Ming Thau Sheu and Ju Chun Huang and Geng Chang Yeh and Hsiu O. Ho},
+   doi = {10.1016/S0142-9612(00)00315-X},
+   issn = {0142-9612},
+   issue = {13},
+   journal = {Biomaterials},
+   keywords = {Collagen,Dynamic mechanical analysis,Glutaraldehyde,Viscoelasticity},
+   month = {7},
+   pages = {1713-1719},
+   pmid = {11396874},
+   publisher = {Elsevier},
+   title = {Characterization of collagen gel solutions and collagen matrices for cell culture},
+   volume = {22},
+   year = {2001},
+}
+@report{slater2017,
+   author = {Katie Slater and Jeff Partridge and Himabindu Nandivada},
+   title = {Tuning the Elastic Moduli of Corning ® Matrigel ® and Collagen I 3D Matrices by Varying the Protein Concentration Application Note},
+   url = {https://www.corning.com/ catalog/cls/documents/application-notes/CLS-AC-AN-449.pdf},
+   year = {2017},
+}
+@article{aisenbrey2020,
+   abstract = {Matrigel, a basement-membrane matrix extracted from Engelbreth–Holm–Swarm mouse sarcomas, has been used for more than four decades for a myriad of cell-culture applications. However, Matrigel is limited in its applicability to cellular biology, therapeutic-cell manufacturing and drug discovery, owing to its complex, ill-defined and variable composition. Variations in the mechanical and biochemical properties within a single batch of Matrigel — and between batches — have led to uncertainty in cell-culture experiments and a lack of reproducibility. Moreover, Matrigel is not conducive to physical or biochemical manipulation, making it difficult to fine-tune the matrix to promote intended cell behaviours and achieve specific biological outcomes. Recent advances in synthetic scaffolds have led to the development of xenogenic-free, chemically defined, highly tunable and reproducible alternatives. In this Review, we assess the applications of Matrigel in cell culture, regenerative medicine and organoid assembly, detailing the limitations of Matrigel and highlighting synthetic-scaffold alternatives that have shown equivalent or superior results. Additionally, we discuss the hurdles that are limiting a full transition from Matrigel to synthetic scaffolds and provide a brief perspective on the future directions of synthetic scaffolds for cell-culture applications.},
+   author = {Elizabeth A. Aisenbrey and William L. Murphy},
+   doi = {10.1038/S41578-020-0199-8},
+   issn = {20588437},
+   issue = {7},
+   journal = {Nature reviews. Materials},
+   month = {7},
+   pages = {539},
+   pmid = {32953138},
+   publisher = {NIH Public Access},
+   title = {Synthetic alternatives to Matrigel},
+   volume = {5},
+   url = {/pmc/articles/PMC7500703/ /pmc/articles/PMC7500703/?report=abstract https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7500703/},
+   year = {2020},
+}
+@article{puxkandl2002,
+   abstract = {Collagen type I is the most abundant structural protein in tendon, skin and bone, and largely determines the mechanical behaviour of these connective tissues. To obtain a better understanding of th...},
+   author = {R. Puxkandl and I. Zizak and O. Paris and J. Keckes and W. Tesch and S. Bernstorff and P. Purslow and P. Fratzl},
+   doi = {10.1098/RSTB.2001.1033},
+   issn = {09628436},
+   issue = {1418},
+   journal = {Philosophical Transactions of the Royal Society of London. Series B: Biological Sciences},
+   keywords = {Xray,collagen,mechanical properties,synchrotron,viscolelastic},
+   month = {2},
+   pages = {191-197},
+   pmid = {11911776},
+   publisher = {
+				The Royal Society
+			},
+   title = {Viscoelastic properties of collagen: synchrotron radiation investigations and structural model},
+   volume = {357},
+   url = {https://royalsocietypublishing.org/doi/10.1098/rstb.2001.1033},
+   year = {2002},
+}
+@article{giraud1998,
+   abstract = {In this letter, we show that an eleven-velocity two-dimensional lattice Boltzmann model using several relaxation times obeys a Jeffreys viscoelastic constitutive law with full isotropic behavior. The connection between the free parameters of the model and the Jeffreys transport coefficients is made with the help of a modified Chapman-Enskog expansion taking into account large relaxation time effects. Numerical simulation of a pulsed Couette flow is performed leading to an excellent agreement with predictions.},
+   author = {L. Giraud and D. D'Humières and P. Lallemand},
+   doi = {10.1209/EPL/I1998-00296-0},
+   issn = {0295-5075},
+   issue = {6},
+   journal = {Europhysics Letters},
+   month = {6},
+   pages = {625},
+   publisher = {IOP Publishing},
+   title = {A lattice Boltzmann model for Jeffreys viscoelastic fluid},
+   volume = {42},
+   url = {https://iopscience.iop.org/article/10.1209/epl/i1998-00296-0 https://iopscience.iop.org/article/10.1209/epl/i1998-00296-0/meta},
+   year = {1998},
+}
+@article{roylance2001,
+   author = {David Roylance},
+   journal = {Department of Materials Science and Engineering--Massachusetts Institute of Technology, Cambridge MA},
+   pages = {1-37},
+   title = {Engineering viscoelasticity},
+   volume = {2139},
+   url = {https://mitocw.ups.edu.ec/courses/materials-science-and-engineering/3-11-mechanics-of-materials-fall-1999/modules/MIT3_11F99_visco.pdf},
+   year = {2001},
+}
 @article{levental2009,
    abstract = {Tumors are characterized by extracellular matrix (ECM) remodeling and stiffening. The importance of ECM remodeling to cancer is appreciated; the relevance of stiffening is less clear. We found that breast tumorigenesis is accompanied by collagen crosslinking, ECM stiffening, and increased focal adhesions. Induction of collagen crosslinking stiffened the ECM, promoted focal adhesions, enhanced PI3 kinase (PI3K) activity, and induced the invasion of an oncogene-initiated epithelium. Inhibition of integrin signaling repressed the invasion of a premalignant epithelium into a stiffened, crosslinked ECM and forced integrin clustering promoted focal adhesions, enhanced PI3K signaling, and induced the invasion of a premalignant epithelium. Consistently, reduction of lysyl oxidase-mediated collagen crosslinking prevented MMTV-Neu-induced fibrosis, decreased focal adhesions and PI3K activity, impeded malignancy, and lowered tumor incidence. These data show how collagen crosslinking can modulate tissue fibrosis and stiffness to force focal adhesions, growth factor signaling and breast malignancy. © 2009 Elsevier Inc. All rights reserved.},
    author = {Kandice R. Levental and Hongmei Yu and Laura Kass and Johnathon N. Lakins and Mikala Egeblad and Janine T. Erler and Sheri F.T. Fong and Katalin Csiszar and Amato Giaccia and Wolfgang Weninger and Mitsuo Yamauchi and David L. Gasser and Valerie M. Weaver},
@@ -14,6 +112,177 @@
    volume = {139},
    year = {2009},
 }
+@article{malaspinas2010,
+   abstract = {The simulation of viscoelastic fluids is a challenging task from the theoretical and numerical points of view. This class of fluids has been extensively studied with the help of classical numerical methods. In this paper we propose a new approach based on the lattice Boltzmann method in order to simulate linear and non-linear viscoelastic fluids and in particular those described by the Oldroyd-B and FENE-P constitutive equations. We study the accuracy and stability of our model on three different benchmarks: the 3D Taylor-Green vortex decay, the simplified 2D four-rolls mill, and the 2D Poiseuille flow. To our knowledge, the methodology described in this work is a first attempt for the simulation of non-trivial flows of viscoelastic fluids using the lattice Boltzmann method to discretize the constitutive and conservation equations. © 2010 Elsevier B.V.},
+   author = {O. Malaspinas and N. Fiétier and M. Deville},
+   doi = {10.1016/J.JNNFM.2010.09.001},
+   issn = {0377-0257},
+   issue = {23-24},
+   journal = {Journal of Non-Newtonian Fluid Mechanics},
+   keywords = {Lattice Boltzmann method,Viscoelastic fluid flows},
+   month = {12},
+   pages = {1637-1653},
+   publisher = {Elsevier},
+   title = {Lattice Boltzmann method for the simulation of viscoelastic fluid flows},
+   volume = {165},
+   year = {2010},
+}
+@article{ispolatov2002,
+   abstract = {A lattice Boltzmann model for viscoelastic flow simulation is proposed. Elastic effects are taken into account within the framework of a Maxwell model. To test the approach, we estimate the transverse velocity autocorrelation function for a freely evolving system, and find clear manifestations of shear at large frequencies. We then characterize boundary-driven shear waves, and the resonant enhancement of shear oscillations in a periodically driven fluid confined within a capillary. The measured shear-wave dispersion relation is compared to that obtained from the Navier-Stokes equation with a Maxwell viscoelastic term, and good agreement is obtained. © 2002 The American Physical Society.},
+   author = {Iaroslav Ispolatov and Martin Grant},
+   doi = {10.1103/PhysRevE.65.056704},
+   issn = {1063651X},
+   issue = {5},
+   journal = {Physical Review E},
+   month = {5},
+   pages = {056704},
+   publisher = {American Physical Society},
+   title = {Lattice Boltzmann method for viscoelastic fluids},
+   volume = {65},
+   url = {https://journals.aps.org/pre/abstract/10.1103/PhysRevE.65.056704},
+   year = {2002},
+}
+@article{sherman2015,
+   abstract = {Collagen is the principal biopolymer in the extracellular matrix of both vertebrates and invertebrates. It is produced in specialized cells (fibroblasts) and extracted into the body by a series of intra and extracellular steps. It is prevalent in connective tissues, and the arrangement of collagen determines the mechanical response. In biomineralized materials, its fraction and spatial distribution provide the necessary toughness and anisotropy. We review the structure of collagen, with emphasis on its hierarchical arrangement, and present constitutive equations that describe its mechanical response, classified into three groups: hyperelastic macroscopic models based on strain energy in which strain energy functions are developed; macroscopic mathematical fits with a nonlinear constitutive response; structurally and physically based models where a constitutive equation of a linear elastic material is modified by geometric characteristics. Viscoelasticity is incorporated into the existing constitutive models and the effect of hydration is discussed. We illustrate the importance of collagen with descriptions of its organization and properties in skin, fish scales, and bone, focusing on the findings of our group.},
+   author = {Vincent R. Sherman and Wen Yang and Marc A. Meyers},
+   doi = {10.1016/J.JMBBM.2015.05.023},
+   issn = {1751-6161},
+   journal = {Journal of the Mechanical Behavior of Biomedical Materials},
+   month = {12},
+   pages = {22-50},
+   pmid = {26144973},
+   publisher = {Elsevier},
+   title = {The materials science of collagen},
+   volume = {52},
+   year = {2015},
+}
+@article{gautieri2013,
+   abstract = {Computer simulation has emerged as a powerful tool to investigate and design materials without ever making them. Predicting the properties and behavior of materials by computer simulation from the bottom-up perspective has long been a vision of computational materials scientists and, as computational power increases, modeling and simulation tools are becoming crucial to the investigation of material systems. The key to achieving this goal is using hierarchies of paradigms that seamlessly connect quantum mechanics to macroscopic systems. Particular progress has been made in relating molecular-scale chemistry to mesoscopic and macroscopic material properties essential to define the materiome. This chapter reviews large-scale atomistic and coarse-grain modeling methods commonly implemented to investigate the properties and behavior of natural and biological materials with nanostructured hierarchies. We present basic concepts of hierarchical multiscale modeling capable of providing a bottom-up description of chemically complex materials and some example applications related to the study of collagen material at different hierarchical levels.},
+   author = {Alfonso Gautieri and Markus J. Buehler},
+   doi = {10.1007/978-3-7091-1574-9_2/COVER},
+   issn = {23093706},
+   journal = {CISM International Centre for Mechanical Sciences, Courses and Lectures},
+   keywords = {Bead Type,Collagen Molecule,Multiscale Modeling,Osteogenesis Imperfecta,Persistence Length},
+   pages = {13-55},
+   publisher = {Springer International Publishing},
+   title = {Multi-scale modeling of biomaterials and tissues},
+   volume = {546},
+   url = {https://link.springer.com/chapter/10.1007/978-3-7091-1574-9_2},
+   year = {2013},
+}
+@article{krueger2017,
+   author = {Timm Krüger and Halim Kusumaatmaja and Alexandr Kuzmin and Orest Shardt and Goncalo Silva and Erlend Magnus Viggen},
+   institution = {Springer International Publishing},
+   journal = {Springer International Publishing},
+   note = {https://github.com/lbm-principles-practice},
+   title = {The lattice Boltzmann method},
+   volume = {10},
+   year = {2017},
+}
+@article{abhilash2014,
+   abstract = {Contractile forces exerted on the surrounding extracellular matrix (ECM) lead to the alignment and stretching of constituent fibers within the vicinity of cells. As a consequence, the matrix reorganizes to form thick bundles of aligned fibers that enable force transmission over distances larger than the size of the cells. Contractile force-mediated remodeling of ECM fibers has bearing on a number of physiologic and pathophysiologic phenomena. In this work, we present a computational model to capture cell-mediated remodeling within fibrous matrices using finite element-based discrete fiber network simulations. The model is shown to accurately capture collagen alignment, heterogeneous deformations, and long-range force transmission observed experimentally. The zone of mechanical influence surrounding a single contractile cell and the interaction between two cells are predicted from the strain-induced alignment of fibers. Through parametric studies, the effect of cell contractility and cell shape anisotropy on matrix remodeling and force transmission are quantified and summarized in a phase diagram. For highly contractile and elongated cells, we find a sensing distance that is ten times the cell size, in agreement with experimental observations.},
+   author = {A. S. Abhilash and Brendon M. Baker and Britta Trappmann and Christopher S. Chen and Vivek B. Shenoy},
+   doi = {10.1016/j.bpj.2014.08.029},
+   issn = {15420086},
+   issue = {8},
+   journal = {Biophysical Journal},
+   month = {10},
+   note = {Focuses on "pulling" effects},
+   pages = {1829-1840},
+   pmid = {25418164},
+   publisher = {Biophysical Society},
+   title = {Remodeling of fibrous extracellular matrices by contractile cells: Predictions from discrete fiber network simulations},
+   volume = {107},
+   year = {2014},
+}
+@article{guo2022,
+   abstract = {Tissues grow and remodel in response to mechanical cues, extracellular and intracellular signals experienced through various biological events, from the developing embryo to disease and aging. The macroscale response of soft tissues is typically nonlinear, viscoelastic anisotropic, and often emerges from the hierarchical structure of tissues, primarily their biopolymer fiber networks at the microscale. The adaptation to mechanical cues is likewise a multiscale phenomenon. Cell mechanobiology, the ability of cells to transform mechanical inputs into chemical signaling inside the cell, and subsequent regulation of cellular behavior through intra- and inter-cellular signaling networks, is the key coupling at the microscale between the mechanical cues and the mechanical adaptation seen macroscopically. To fully understand mechanics of tissues in growth and remodeling as observed at the tissue level, multiscale models of tissue mechanobiology are essential. In this review, we summarize the state-of-the art modeling tools of soft tissues at both scales, the tissue level response, and the cell scale mechanobiology models. To help the interested reader become more familiar with these modeling frameworks, we also show representative examples. Our aim here is to bring together scientists from different disciplines and enable the future leap in multiscale modeling of tissue mechanobiology.},
+   author = {Yifan Guo and Mohammad R. K. Mofrad and Adrian Buganza Tepole},
+   doi = {10.1063/5.0085025},
+   issue = {3},
+   journal = {Biophysics Reviews},
+   month = {9},
+   note = {Another review containing a bunch of nice references. Kind of hard to pull apart though since its very dense in information.},
+   pages = {031303},
+   publisher = {AIP Publishing},
+   title = {On modeling the multiscale mechanobiology of soft tissues: Challenges and progress},
+   volume = {3},
+   year = {2022},
+}
+@article{liedekerke2015,
+   abstract = {In this paper we present an overview of agent-based models that are used to simulate mechanical and physiological phenomena in cells and tissues, and we discuss underlying concepts, limitations, and future perspectives of these models. As the interest in cell and tissue mechanics increase, agent-based models are becoming more common the modeling community. We overview the physical aspects, complexity, shortcomings, and capabilities of the major agent-based model categories: lattice-based models (cellular automata, lattice gas cellular automata, cellular Potts models), off-lattice models (center-based models, deformable cell models, vertex models), and hybrid discrete-continuum models. In this way, we hope to assist future researchers in choosing a model for the phenomenon they want to model and understand. The article also contains some novel results.},
+   author = {P Van Liedekerke and M M Palm and N Jagiella and D Drasdo},
+   doi = {10.1007/s40571-015-0082-3},
+   journal = {Comp. Part. Mech},
+   keywords = {Agent-based modeling,Cell mechanics,Deformable cell models,Hybrid models,Lattice-based models,Lattice-free models},
+   note = {Overview over ECM models},
+   pages = {401-444},
+   title = {Simulating tissue mechanics with agent-based models: concepts, perspectives and some novel results},
+   volume = {2},
+   year = {2015},
+}
+@article{rens2017,
+   abstract = {During animal development and homeostasis, the structure of tissues, including muscles, blood vessels, and connective tissues, adapts to mechanical strains in the extracellular matrix (ECM). These strains originate from the differential growth of tissues or forces due to muscle contraction or gravity. Here we show using a computational model that by amplifying local strain cues, active cell contractility can facilitate and accelerate the reorientation of single cells to static strains. At the collective cell level, the model simulations show that active cell contractility can facilitate the formation of strings along the orientation of stretch. The computational model is based on a hybrid cellular Potts and finite-element simulation framework describing a mechanical cell-substrate feedback, where: 1) cells apply forces on the ECM, such that 2) local strains are generated in the ECM and 3) cells preferentially extend protrusions along the strain orientation. In accordance with experimental observations, simulated cells align and form stringlike structures parallel to static uniaxial stretch. Our model simulations predict that the magnitude of the uniaxial stretch and the strength of the contractile forces regulate a gradual transition between stringlike patterns and vascular networklike patterns. Our simulations also suggest that at high population densities, less cell cohesion promotes string formation.},
+   author = {Elisabeth G. Rens and Roeland M.H. Merks},
+   doi = {10.1016/J.BPJ.2016.12.012},
+   issn = {0006-3495},
+   issue = {4},
+   journal = {Biophysical Journal},
+   month = {2},
+   pages = {755-766},
+   pmid = {28256235},
+   publisher = {Cell Press},
+   title = {Cell Contractility Facilitates Alignment of Cells and Tissues to Static Uniaxial Stretch},
+   volume = {112},
+   year = {2017},
+}
+@article{tsingos2022,
+   abstract = {The mechanical interaction between cells and the extracellular matrix (ECM) is fundamental to coordinate collective cell behavior in multicellular tissues. Relating individual cell-level mechanics to tissue-scale collective behavior is an outstanding challenge which cell-based models such as the cellular Potts model (CPM) are well-positioned to address. These models generally represent the ECM with mean-field approaches, which assume substrate homogeneity. This assumption breaks down with fibrous ECM, which has non-trivial structure and mechanics. Here, we extend the CPM with a bead-spring chain model of ECM fiber networks modelled using molecular dynamics. We model contractile cells pulling with discrete focal adhesion-like sites on the ECM fiber network, and demonstrate agreement with experimental spatiotemporal fiber densification and displacement. We show that contractile cell forces propagate over multiple cell radii scaling with power law exponent of ≈ −0.5 typical of viscoelastic ECM. Further, we use in silico atomic force microscopy to measure local cell-induced network stiffening consistent with experiments. Our model lays the foundation to investigate how local and long-ranged cell-ECM mechanobiology contributes to multicellular morphogenesis.
+
+### Competing Interest Statement
+
+The authors have declared no competing interest.},
+   author = {Erika Tsingos and Bente Hilde Bakker and Koen A.E. Keijzer and Hermen Jan Hupkes and Roeland M.H. Merks},
+   doi = {10.1101/2022.06.10.495667},
+   journal = {bioRxiv},
+   month = {7},
+   pages = {2022.06.10.495667},
+   publisher = {Cold Spring Harbor Laboratory},
+   title = {Modelling the mechanical cross-talk between cells and fibrous extracellular matrix using hybrid cellular Potts and molecular dynamics methods},
+   url = {https://www.biorxiv.org/content/10.1101/2022.06.10.495667v3 https://www.biorxiv.org/content/10.1101/2022.06.10.495667v3.abstract},
+   year = {2022},
+}
+@article{rubenstein2008,
+   abstract = {In this work, a cellular Potts model based on the differential adhesion hypothesis is employed to analyze the relative importance of select cell-cell and cell-extracellular matrix (ECM) contacts in glioma invasion. To perform these simulations, three types of cells and two ECM components are included. The inclusion of explicit ECM with an inhomogeneous fibrous component and a homogeneously dispersed afibrous component allows exploration of the importance of relative energies of cell-cell and cell-ECM contacts in a variety of environments relevant to in vitro and in vivo experimental investigations of glioma invasion. Simulations performed here focus chiefly on reproducing findings of in vitro experiments on glioma spheroids embedded in collagen I gels. For a given range and set ordering of energies associated with key cell-cell and cell-ECM interactions, our model qualitatively reproduces the dispersed glioma invasion patterns found for most glioma cell lines embedded as spheroids in collagen I gels of moderate concentration. In our model, we find that invasion is maximized at intermediate collagen concentrations, as occurs experimentally. This effect is seen more strongly in model gels composed of short collagen fibers than in those composed of long fibers, which retain significant connectivity even at low density. Additional simulations in aligned model matrices further elucidate how matrix structure dictates invasive patterns. Finally, simulations that allow invading cells to both dissolve and deposit ECM components demonstrate how Q-Potts models may be elaborated to allow active cell alteration of their surroundings. The model employed here provides a quantitative framework with which to bound the relative values of cell-cell and cell-ECM interactions and investigate how varying the magnitude and type of these interactions, as well as ECM structure, could potentially curtail glioma invasion. © 2008 by the Biophysical Society.},
+   author = {Brenda M. Rubenstein and Laura J. Kaufman},
+   doi = {10.1529/BIOPHYSJ.108.140624},
+   issn = {0006-3495},
+   issue = {12},
+   journal = {Biophysical Journal},
+   month = {12},
+   note = {1 Type for Stroma, 1 Type for Collagen<br/><br/>Initial experiments: Static ECM<br/><br/>Then: ECM dissolution/deposition<br/>Not aligned with in vivo results<br/>Posits idea: Simulate more than two types of matrix},
+   pages = {5661-5680},
+   pmid = {18835895},
+   publisher = {Cell Press},
+   title = {The Role of Extracellular Matrix in Glioma Invasion: A Cellular Potts Model Approach},
+   volume = {95},
+   year = {2008},
+}
+@article{berghoff2018,
+   abstract = {In the last decades, simulations have been established in several fields of science and industry to study various phenomena by solving, inter alia, partial differential equations. For an efficient use of current and future high performance computing systems, with many thousands of computation ranks, high node-level performance, scalable communication, and the omission of unnecessary calculations are of high priority in the development of new solvers. The challenge of contemporary simulation applications is to bridge the gap between the scales of the various physical processes. We introduce the NAStJA framework, a block-based MPI parallel solver for arbitrary algorithms, based on stencil code or other regular grid methods. NAStJA decomposes the domain of spatially complex structures into small cuboid blocks. A special feature of NAStJA is the dynamic block adaption which modifies the calculation domain around the region where the computation currently takes place, and hence avoids unnecessary calculations. This often occurs, inter alia, in phase-field simulations. Block creation and deletion is managed autonomously within local neighborhoods. A basic load balancing mechanism allows a re-distribution of newly created blocks to the involved computing ranks. The use of a multi-hop network, to distribute information to the entire domain, avoids collective all-gather communications. Thus, we can demonstrate excellent scaling. The present scaling tests substantiate the enormous advantage of this adaptive method. For certain simulation scenarios, we can show that the calculation effort and memory consumption can be reduced to only 3.5 percent, compared to the classical full-domain reference simulation. The overhead of 70-100 percent for the dynamic adapting block creation is significantly lower than the gain. The approach is not restricted to phase-field simulations, and can be employed in other domains of computational science to exploit sparsity of computing regions.},
+   author = {Marco Berghoff and Ivan Kondov and Johannes Hotzer},
+   doi = {10.1109/TPDS.2018.2819672},
+   issn = {15582183},
+   issue = {10},
+   journal = {IEEE Transactions on Parallel and Distributed Systems},
+   keywords = {Stencil code,distributed memory,load balancing,massively parallel performance,multi-hop network,partial differential equation,phase-field method,scalable parallel algorithms},
+   month = {10},
+   pages = {2282-2296},
+   publisher = {IEEE Computer Society},
+   title = {Massively Parallel Stencil Code Solver with Autonomous Adaptive Block Distribution},
+   volume = {29},
+   year = {2018},
+}
 @generic{frantz2010,
    author = {Christian Frantz and Kathleen M. Stewart and Valerie M. Weaver},
    doi = {10.1242/jcs.023820},
@@ -27,3 +296,47 @@
    volume = {123},
    year = {2010},
 }
+@article{herold2023,
+   abstract = {Progress continues in the field of cancer biology, yet much remains to be unveiled regarding the mechanisms of cancer invasion. In particular, complex biophysical mechanisms enable a tumor to remodel the surrounding extracellular matrix (ECM), allowing cells to invade alone or collectively. Tumor spheroids cultured in collagen represent a simplified, reproducible 3D model system, which is sufficiently complex to recapitulate the evolving organization of cells and interaction with the ECM that occur during invasion. Recent experimental approaches enable high resolution imaging and quantification of the internal structure of invading tumor spheroids. Concurrently, computational modeling enables simulations of complex multicellular aggregates based on first principles. The comparison between real and simulated spheroids represents a way to fully exploit both data sources, but remains a challenge. We hypothesize that comparing any two spheroids requires first the extraction of basic features from the raw data, and second the definition of key metrics to match such features. Here, we present a novel method to compare spatial features of spheroids in 3D. To do so, we define and extract features from spheroid point cloud data, which we simulated using Cells in Silico (CiS), a high-performance framework for large-scale tissue modeling previously developed by us. We then define metrics to compare features between individual spheroids, and combine all metrics into an overall deviation score. Finally, we use our features to compare experimental data on invading spheroids in increasing collagen densities. We propose that our approach represents the basis for defining improved metrics to compare large 3D data sets. Moving forward, this approach will enable the detailed analysis of spheroids of any origin, one application of which is informing in silico spheroids based on their in vitro counterparts. This will enable both basic and applied researchers to close the loop between modeling and experiments in cancer research.},
+   author = {Julian Herold and Eric Behle and Jakob Rosenbauer and Jacopo Ferruzzi and Alexander Schug},
+   doi = {10.1371/journal.pcbi.1010471},
+   issn = {15537358},
+   issue = {3},
+   journal = {PLoS Computational Biology},
+   month = {3},
+   pmid = {36996248},
+   publisher = {Public Library of Science},
+   title = {Development of a scoring function for comparing simulated and experimental tumor spheroids},
+   volume = {19},
+   year = {2023},
+}
+@article{berghoff2020,
+   abstract = {Background: Discoveries in cellular dynamics and tissue development constantly reshape our understanding of fundamental biological processes such as embryogenesis, wound-healing, and tumorigenesis. High-quality microscopy data and ever-improving understanding of single-cell effects rapidly accelerate new discoveries. Still, many computational models either describe few cells highly detailed or larger cell ensembles and tissues more coarsely. Here, we connect these two scales in a joint theoretical model. Results: We developed a highly parallel version of the cellular Potts model that can be flexibly applied and provides an agent-based model driving cellular events. The model can be modular extended to a multi-model simulation on both scales. Based on the NAStJA framework, a scaling implementation running efficiently on high-performance computing systems was realized. We demonstrate independence of bias in our approach as well as excellent scaling behavior. Conclusions: Our model scales approximately linear beyond 10,000 cores and thus enables the simulation of large-scale three-dimensional tissues only confined by available computational resources. The strict modular design allows arbitrary models to be configured flexibly and enables applications in a wide range of research questions. Cells in Silico (CiS) can be easily molded to different model assumptions and help push computational scientists to expand their simulations to a new area in tissue simulations. As an example we highlight a 10003 voxel-sized cancerous tissue simulation at sub-cellular resolution.},
+   author = {Marco Berghoff and Jakob Rosenbauer and Felix Hoffmann and Alexander Schug},
+   doi = {10.1186/s12859-020-03728-7},
+   issn = {14712105},
+   issue = {1},
+   journal = {BMC Bioinformatics},
+   keywords = {Cellular Potts model,Massively parallel,Tissue growth},
+   month = {10},
+   pmid = {33023471},
+   publisher = {BioMed Central Ltd},
+   title = {Cells in Silico-introducing a high-performance framework for large-scale tissue modeling},
+   volume = {21},
+   year = {2020},
+}
+@inproceedings{scianna2013,
+   abstract = {Cell migration on and through extracellular matrix is fundamental in a wide variety of physiological and pathological phenomena, and is exploited in scaffold-based tissue engineering. Migration is regulated by a number of extracellular matrix- or cell-derived biophysical parameters, such as matrix fiber orientation, pore size, and elasticity, or cell deformation, proteolysis, and adhesion. We here present an extended Cellular Potts Model (CPM) able to qualitatively and quantitatively describe cell migration efficiencies and phenotypes both on two-dimensional substrates and within three-dimensional matrices, close to experimental evidence. As distinct features of our approach, cells are modeled as compartmentalized discrete objects, differentiated into nucleus and cytosolic region, while the extracellular matrix is composed of a fibrous mesh and a homogeneous fluid. Our model provides a strong correlation of the directionality of migration with the topological extracellular matrix distribution and a biphasic dependence of migration on the matrix structure, density, adhesion, and stiffness, and, moreover, simulates that cell locomotion in highly constrained fibrillar obstacles requires the deformation of the cell's nucleus and/or the activity of cell-derived proteolysis. In conclusion, we here propose a mathematical modeling approach that serves to characterize cell migration as a biological phenomenon in healthy and diseased tissues and in engineering applications.},
+   author = {Marco Scianna and Luigi Preziosi and Katarina Wolf},
+   doi = {10.3934/mbe.2013.10.235},
+   issn = {15471063},
+   issue = {1},
+   journal = {Mathematical Biosciences and Engineering},
+   keywords = {Cell migration,Cellular Potts model,Extracellular matrix},
+   month = {2},
+   pages = {235-261},
+   pmid = {23311371},
+   title = {A cellular potts model simulating cell migration on and in matrix environments},
+   volume = {10},
+   year = {2013},
+}

doc/research/research.tex

@@ -1,14 +1,19 @@
 \documentclass[a4paper]{article}
 
+\usepackage{caption}
 \usepackage{csquotes}
 \usepackage[acronym]{glossaries}
+\usepackage{hyperref}
 \usepackage[utf8x]{inputenc}
 \usepackage{siunitx}
+\usepackage{todonotes}
 
 \makeglossaries{}
 \newacronym{cis}{CiS}{Cells in Silico}
 \newacronym{cpm}{CPM}{Cellular Potts Model}
 \newacronym{ecm}{ECM}{Extracellular Matrix}
+\newacronym{fem}{FEM}{Finite Element Method}
+\newacronym{lbm}{LBM}{Lattice Boltzmann Model}
 \newacronym{mcs}{MCS}{Monte-Carlo Step}
 \newacronym{nastja}{NAStJA}{Neoteric Autonomous Stencil code for Jolly Algorithms}
 
@@ -45,17 +50,67 @@ Individual fibrils/fibers should not be modeled.
 Nevertheless we include some microscopic properties.
 
 \begin{itemize}
-	\item \textbf{Density}
 	\item \textbf{Stiffness}: Matrix stiffness has an effect on tumor gowth, e.g. \cite{levental2009}.
-	Measured using Young's modulus/elastic modulus which is given in \si{\Pa}.
-	\item \textbf{Viscoelasticity}
+	Measured using Young's modulus/elastic modulus $E$ which is given in \si{\giga\pascal}.
+	\item \textbf{Viscoelasticity}: Creep, Stress relaxation (see below), $E$, $\eta$
 	\item \textbf{Pore size}
+	\item \textbf{Density}
 \end{itemize}
 
-\cite{frantz2010} mentions Matrigel™ and collagen type I gels, so we will focus on these.
+\subsection{Viscoelasticity}
+
+\todo{What is viscoelasticity? Show some graphs and \enquote{oral} explanation}
+
+\begin{itemize}
+	\item \textbf{Creep}:
+	\item \textbf{Stress relexation}:
+\end{itemize}
+
+Generally modeled using differential equations involving the elastic modulus $E$, viscosity $\eta$, stress $\sigma$ and strain $\epsilon$.
+\cite{roylance2001} mentions these constitutive models:
+
+\begin{itemize}
+	\item Maxwell: Viscous flow on the long timescale, but additional elastic resistance to fast deformations (e.g. silly putty, warm tar).
+	      Does not describe creep or recovery.
+	\item Kelvin-Voigt: Does not describe stress relaxation.
+	\item Zener/Standard linear solid: Models creep and stress relexation.
+\end{itemize}
+
+The Lethersich and Jeffreys models are models for viscoelasticity that specifically model fluids.
+
+\subsection{Rheology and Materials Science of the \acrshort{ecm}}
+
+\cite{frantz2010} mentions Matrigel and collagen type I gels, so we will focus on these.
+
+Great review with great figures: \cite{chaudhuri2020}.
+
+\begin{itemize}
+	\item \cite{sherman2015} lists the elastic modulus of collagen structures at different scales, see \autoref{fig:sherman2015-table1}.
+	\item \cite{puxkandl2002} defines a model for the viscoelasticity of collagen.
+	\todo{expand, give actual values}
+	\item \cite{slater2017} discusses properties of Corning® Matrigel®.
+	\begin{itemize}
+		\item Lists elastic moduli for different concentrations and mixtures involving collagen type I around $10^1$ to $10^3$ \si{\pascal}.
+		\todo{This seems very low; investigate sources}
+		\item This paper shows the viscuous component in the graphs but doesn't really go into it.
+	\end{itemize}
+	\item \cite{aisenbrey2020} discusses alternatives to Corning® Matrigel®.
+	\item \cite{sheu2001} experimentally investigate the elastic and viscous moduli of collagen gels.
+	      They find that the Kelvin-Voigt model can be used to model their viscoelastic behavior.
+\end{itemize}
+
+\begin{figure}[h]
+	\includegraphics[width=\textwidth]{figures/sherman2015-table1}
+	\caption{Comparison of Young's modulus of collagen at multiple hierarchical levels. From \cite{sherman2015}.}.
+	\label{fig:sherman2015-table1}
+\end{figure}
+
+Since viscoelastic behavior is inherently time-dependent, it will be a challenge to choose a sensible time step resolution for the model.
 
 \section{\acrfull{cpm}}
 
+\todo{cites}
+
 \begin{itemize}
 	\item The \acrshort{cpm} is a grid-based Monte-Carlo simulation for cells.
 	\item Each cell consists of many voxels.
@@ -69,19 +124,65 @@ Nevertheless we include some microscopic properties.
 \section{\acrshort{nastja} \& \acrshort{cis}}
 
 \begin{itemize}
-	\item \acrfull{nastja} is a massively parallel stencil code solver based on OpenMPI.
-	\item \acrfull{cis} is an implementation of the \acrshort{cpm} in \acrshort{nastja}.
+	\item \acrfull{nastja} is a massively parallel stencil code solver based on OpenMPI \cite{berghoff2018}.
+	\item \acrfull{cis} is an implementation of the \acrshort{cpm} in \acrshort{nastja} \cite{berghoff2020, herold2023}.
 \end{itemize}
 
-\section{The \acrshort{ecm} in the \acrshort{cpm}}
+\section{Models of Viscoelastic Materials}
+
+\subsection{Chopard (Cellular Automaton)}
+
+\subsection{\acrfull{lbm}}
+
+\begin{itemize}
+	\item A general-purpose model of hydrodynamics discrete in time and space.
+	\item Discretisation in space makes it possible to calculate \acrshort{lbm} time steps using stencil codes.
+	\item Extensive literature exists including implementation details, e.g. \cite{krueger2017}
+	\item Can be used to model viscoelasticity, e.g. \cite{giraud1998, malaspinas2010, ispolatov2002}
+	\item Probably not that simple to model matrix porosity.
+	\todo{Elaborate}
+\end{itemize}
+
+\section{\acrshort{ecm} Models in the \acrshort{cpm}}
+
+Reviews: \cite{liedekerke2015, guo2022}
+
+\todo{Elaborate a bit}
+
+\subsection{\acrshort{ecm} as a Cell}
+
+\begin{itemize}
+	\item Simple idea: Model \acrshort{ecm} as a special cell, i.e. a set of voxels.
+	\item Set properties of the \acrshort{ecm} \enquote{cell} such that the model makes sense.
+	\item Can model simple interactions such as matrix decomposition and deposition
+	\item Can't really model matrix strains and deformation
+\end{itemize}
+
+E.g. \cite{rubenstein2008, scianna2013, herold2023}
+
+\subsection{Substrate Strain \acrshort{fem}}
+
+\cite{rens2017}
+
+\subsection{Discrete Fiber Networks}
+
+\todo{expand}
+
+See papers cited in \cite{guo2022}, e.g. \cite{abhilash2014}.
+
+\subsection{Molecular Dynamics Bead-Chain Model}
+
+\cite{tsingos2022}
+
 
 \clearpage
 
+
 \section{Glossary}
 
 \printglossary[type=\acronymtype]
 
-\bibliographystyle{plain}
+\bibliographystyle{acm}
 \bibliography{references}
 
 \end{document}

experiments/.gitignore

@@ -0,0 +1,10 @@
+venv
+.ipynb_checkpoints
+logs
+__pycache__
+generated/*
+batch/measurements/strong/*
+configs/measurements/strong/*
+*.dat
+*.db
+eval/generated/*

experiments/ELM_Debug.ipynb

@@ -0,0 +1,256 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2342d5ae-1839-4132-ace8-da8449223a1c",
+   "metadata": {},
+   "source": [
+    "> (O'Brien, 2008)\n",
+    "\n",
+    "The force acting on node $i$ is given by\n",
+    "\n",
+    "$$\n",
+    "\\mathbf{F}_i = \\sum^N_j \\mathbf{F}_{ij}\n",
+    "$$\n",
+    "\n",
+    "Where $N = 8$ (for the 2D case) is the number of neighbors $j$.\n",
+    "The force $\\mathbf{F}_{ij}$ on node $i$ from node $j$ is given by\n",
+    "\n",
+    "$$\n",
+    "\\mathbf{F}_{ij} = K_{ij} (\\mathbf{u}_{ij} \\cdot \\mathbf{x}_{ij}) + \\frac{c \\mathbf{u}_{ij}}{|\\mathbf{x}_{ij}|^2}\n",
+    "$$\n",
+    "\n",
+    "where\n",
+    "\n",
+    "* $K_{ij}$ is the elastic spring constant\n",
+    "* $\\mathbf{u}_{ij} = \\mathbf{u}_i - \\mathbf{u}_j \\in \\mathbb{R}^2$ is the displacement\n",
+    "* $\\mathbf{x}_{ij} = \\mathbf{x}_i - \\mathbf{x}_j \\in \\mathbb{R}^2$ is the vector connecting nodes $i$ and $j$ on the undistorted lattice\n",
+    "* $c \\in \\mathbb{R}$ is the bond-bending constant\n",
+    "\n",
+    "The Lamé constants are given by\n",
+    "\n",
+    "$\\lambda_\\text{2D} = K - \\frac{c}{\\Delta x^2}$\n",
+    "\n",
+    "and\n",
+    "\n",
+    "$\\mu_\\text{2D} = K + \\frac{c}{\\Delta x^2}$\n",
+    "\n",
+    "where $\\Delta x$ is the lattice grid spacing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "05d4e22c-3d7d-4ac2-bf22-59b78aa40b84",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "from ipywidgets import interact\n",
+    "from typing import Tuple"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50ba2e84-bb40-44c8-bb86-8804fd26f674",
+   "metadata": {},
+   "source": [
+    "$$\n",
+    "\\mathbf{F}_{ij} = K_{ij} (\\mathbf{u}_{ij} \\cdot \\mathbf{x}_{ij}) + \\frac{c \\mathbf{u}_{ij}}{|\\mathbf{x}_{ij}|^2}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "82bb4a02-1ecf-4c84-8b9d-b753dee75337",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "j=(0, 0) K_ij=2.0000000000000004 u_ij=array([0.1, 0. ]) x_ij=array([1., 1.])\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def calculate_force_elastic(\n",
+    "    displacement: np.ndarray,\n",
+    "    i: Tuple[int, int],\n",
+    "    j: Tuple[int, int]\n",
+    ") -> np.ndarray:\n",
+    "    u_ij = displacement[i] - displacement[j]\n",
+    "    x_ij = np.array(i, dtype=float) - np.array(j, dtype=float)\n",
+    "    K_ij = np.linalg.norm(x_ij) ** 2\n",
+    "    r_ij = x_ij + u_ij\n",
+    "\n",
+    "    print(f\"{j=} {K_ij=} {u_ij=} {x_ij=}\")\n",
+    "\n",
+    "    return 0\n",
+    "    return -K_ij * np.dot(u_ij, x_ij) * r_ij / np.linalg.norm(r_ij)\n",
+    "\n",
+    "def calculate_force_bond(\n",
+    "    displacement: np.ndarray,\n",
+    "    i: Tuple[int, int],\n",
+    "    j: Tuple[int, int]\n",
+    ") -> np.ndarray:\n",
+    "    u_ij = displacement[i] - displacement[j]\n",
+    "    x_ij = np.array(i, dtype=float) - np.array(j, dtype=float)\n",
+    "    c_ij = 1.0\n",
+    "\n",
+    "    return (-c_ij * u_ij) / (np.linalg.norm(x_ij) ** 2)\n",
+    "\n",
+    "def calculate_force(\n",
+    "    displacement: np.ndarray,\n",
+    "    i: Tuple[int, int],\n",
+    "    j: Tuple[int, int]\n",
+    ") -> np.ndarray:\n",
+    "    return calculate_force_elastic(displacement, i, j) + calculate_force_bond(displacement, i, j)\n",
+    "\n",
+    "displacement = np.array([\n",
+    "    [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]],\n",
+    "    [[0.0, 0.0], [0.1, 0.0], [0.0, 0.0]],\n",
+    "    [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]]\n",
+    "])\n",
+    "calculate_force_elastic(displacement, (1, 1), (0, 0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f7a019c2-8d20-4e84-9e0c-ef788781a07a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "10515f6b18554cd1bd86dd56891eed2b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=0.0, description='dp_x', max=1.5, min=-1.5, step=0.05), FloatSlider(va…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.do_plot(dp_x: float, dp_y: float) -> None>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def do_plot(dp_x: float, dp_y: float) -> None:\n",
+    "    i = (1, 1)\n",
+    "    displacement[i] = np.array([dp_x, dp_y])\n",
+    "    \n",
+    "    width, height, _ = displacement.shape\n",
+    "\n",
+    "    xs = []\n",
+    "    ys = []\n",
+    "    elastic_xs = []\n",
+    "    elastic_ys = []\n",
+    "        \n",
+    "    for x in range(width):\n",
+    "        for y in range(height):\n",
+    "            j = (x, y)\n",
+    "            xs.append(x + displacement[j][0])\n",
+    "            ys.append(y + displacement[j][1])\n",
+    "\n",
+    "            if j != i:\n",
+    "                F_ij = calculate_force(displacement, i, j)\n",
+    "                print(f\"{F_ij=}\")\n",
+    "                elastic_xs.append(F_ij[0])\n",
+    "                elastic_ys.append(F_ij[1])\n",
+    "\n",
+    "    pi = i + displacement[i]\n",
+    "    plt.xlim(-1, 3)\n",
+    "    plt.ylim(-1, 3)\n",
+    "    plt.scatter(xs, ys)\n",
+    "    plt.quiver(\n",
+    "        [pi[0]] * len(elastic_xs),\n",
+    "        [pi[1]] * len(elastic_ys),\n",
+    "        elastic_xs,\n",
+    "        elastic_ys,\n",
+    "        angles = \"xy\",\n",
+    "        pivot = \"tip\",\n",
+    "        scale = 5,\n",
+    "        width = 0.005\n",
+    "    )\n",
+    "    plt.quiver(\n",
+    "        pi[0], pi[1],\n",
+    "        sum(elastic_xs),\n",
+    "        sum(elastic_ys),\n",
+    "        pivot = \"tip\",\n",
+    "        scale = 5,\n",
+    "        angles = \"xy\",\n",
+    "        color = \"red\"\n",
+    "    )\n",
+    "    \n",
+    "\n",
+    "interact(\n",
+    "    do_plot,\n",
+    "    dp_x = (-1.5, 1.5, 0.05),\n",
+    "    dp_y = (-1.5, 1.5, 0.05)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4c55b68-903a-48de-8226-9cfbbbca4af6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f283012a-6b7c-48c3-8bdc-f45f5b458edc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

experiments/Makefile

@@ -0,0 +1,27 @@
+VARIED_FILLINGS_IS := $(shell seq -w 0 10 100)
+VARIED_FILLINGS_JOBS := $(addprefix generated/varied-fillings-, $(addsuffix .json, ${VARIED_FILLINGS_IS}))
+
+all: varied-fillings strong
+
+varied-fillings: ${VARIED_FILLINGS_JOBS}
+
+strong:
+	python scripts/gen/strong.py
+
+clean-strong:
+	rm -f batch/measurements/strong/*
+	rm -f configs/measurements/strong/spheroid*.json
+
+clean:
+	rm -f generated/*
+
+clean-logs:
+	rm -f logs/*
+
+clean-outs:
+	rm -rf /p/scratch/cellsinsilico/paul/nastja-out/*
+
+generated/varied-fillings-%.json: scripts/gen/varied_fillings.py templates/varied-fillings.json
+	python scripts/gen/varied_fillings.py $* > $@
+
+.PHONY: varied-fillings strong clean clean-logs clean-outs

experiments/README.md

@@ -0,0 +1,26 @@
+# experiments
+
+## Running
+
+(Optional: Use [virtualenv](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/))
+
+```
+pip install -r requirements.txt
+jupyter-lab
+```
+
+The `shell.nix` contains a workaround for NixOS and is not necessary for normal use.
+
+## Building NAStJA for Experiments
+
+Build it either with or without CUDA support.
+When NAStJA is built with CUDA support it will automatically switch to the GPU implementation of the dynamic ECM.
+I use the `mold` linker because it makes the code-build-test-loop slightly shorter.
+This shouldn't have any impact on the performance of the produced binary.
+If you would like to shorten the linking time even further you can add `-DNASTJA_ENABLE_IPO=OFF` to turn of Link Time Optimization (LTO).
+However, it is likely that will have an impact on performance.
+
+```
+cmake .. -DCMAKE_CXX_FLAGS="-fuse-ld=mold"
+cmake .. -DCMAKE_CXX_FLAGS="-fuse-ld=mold" -DNASTJA_ENABLE_CUDA=ON
+```

experiments/batch/build-cuda

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=build-cuda
+# Forschergruppe Schug
+#SBATCH --account=hkf6
+#SBATCH --partition=develbooster
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=48
+#SBATCH --time=01:00:00
+#SBATCH --output=logs/build-cuda-%j.log
+#SBATCH --error=logs/build-cuda-%j.log
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+
+source "${SOURCE_DIR}/activate-nastja-modules"
+cd "${SOURCE_DIR}/nastja/build-cuda"
+
+srun make -j48

experiments/batch/build-nocuda

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=build-nocuda
+# Forschergruppe Schug
+#SBATCH --account=hkf6
+#SBATCH --partition=develbooster
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=48
+#SBATCH --time=01:00:00
+#SBATCH --output=logs/build-nocuda-%j.log
+#SBATCH --error=logs/build-nocuda-%j.log
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+
+source "${SOURCE_DIR}/activate-nastja-modules"
+cd "${SOURCE_DIR}/nastja/build-nocuda"
+
+srun make -j48

experiments/batch/cuda

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=cuda
+# Forschergruppe Schug
+#SBATCH --account=hkf6
+# 48 Cores, 512GiB RAM, 4x NVIDIA A100 GPUs
+#SBATCH --partition=booster
+# Right now we're using a single node
+#SBATCH --nodes=1
+# Number of MPI processes
+# TODO: Change the config and set to this the maximum of 48
+#SBATCH --ntasks=16
+#SBATCH --cpus-per-task=1
+# For now, we are using a single GPU only
+#SBATCH --gres=gpu:1
+#SBATCH --time=01:00:00
+#SBATCH --output=logs/cuda-%j.log
+#SBATCH --error=logs/cuda-%j.log
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR=/p/scratch/cellsinsilico/paul/nastja-out/cuda
+
+mkdir -p "${OUTPUT_DIR}"
+source "${SOURCE_DIR}/activate-nastja-modules"
+
+# This is actually the default behavior for a single task anyways
+# However I'm leaving this here for documentation reasons
+export CUDA_VISIBLE_DEVICES=0
+
+srun --unbuffered "${SOURCE_DIR}/nastja/build-cuda/nastja" \
+  -c "${SOURCE_DIR}/ma/experiments/configs/genesis.json" \
+  -o "${OUTPUT_DIR}"

experiments/batch/cuda-singleblock

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=cuda-singleblock
+# Forschergruppe Schug
+#SBATCH --account=hkf6
+# 48 Cores, 512GiB RAM, 4x NVIDIA A100 GPUs
+#SBATCH --partition=booster
+# Right now we're using a single node
+#SBATCH --nodes=1
+# Number of MPI processes
+#SBATCH --ntasks=1
+# For now, we are using a single GPU only
+#SBATCH --gres=gpu:1
+#SBATCH --time=01:00:00
+#SBATCH --output=logs/cuda-singleblock-%j.log
+#SBATCH --error=logs/cuda-singleblock-%j.log
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR=/p/scratch/cellsinsilico/paul/nastja-out/cuda-singleblock
+
+mkdir -p "${OUTPUT_DIR}"
+source "${SOURCE_DIR}/activate-nastja-modules"
+
+# This is actually the default behavior for a single task anyways
+# However I'm leaving this here for documentation reasons
+export CUDA_VISIBLE_DEVICES=0
+
+srun --unbuffered "${SOURCE_DIR}/nastja/build-cuda/nastja" \
+  -c "${SOURCE_DIR}/ma/experiments/configs/genesis-singleblock.json" \
+  -o "${OUTPUT_DIR}"

experiments/batch/ecm-debug

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=ecm-debug
+# Forschergruppe Schug
+#SBATCH --account=hkf6
+# 48 Cores, 512GiB RAM, 4x NVIDIA A100 GPUs
+#SBATCH --partition=booster
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+# For now, we are using a single GPU only
+#SBATCH --gres=gpu:1
+#SBATCH --time=00:10:00
+#SBATCH --output=logs/ecm-debug-%j.log
+#SBATCH --error=logs/ecm-debug-%j.log
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR=/p/scratch/cellsinsilico/paul/nastja-out/ecm-debug
+
+mkdir -p "${OUTPUT_DIR}"
+source "${SOURCE_DIR}/activate-nastja-modules"
+
+# This is actually the default behavior for a single task anyways
+# However I'm leaving this here for documentation reasons
+export CUDA_VISIBLE_DEVICES=0
+
+srun "${SOURCE_DIR}/nastja/build-cuda/nastja" \
+  -c "${SOURCE_DIR}/ma/experiments/configs/ecm-debug.json" \
+  -o "${OUTPUT_DIR}"

experiments/batch/julian-animation

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=julian-animation
+#SBATCH --account=hkf6
+#SBATCH --partition=booster
+#SBATCH --nodes=8
+#SBATCH --ntasks=32
+# Counted per node
+#SBATCH --gres=gpu:4
+#SBATCH --time=03:30:00
+#SBATCH --output=logs/%x-%A_%a.log
+#SBATCH --error=logs/%x-%A_%a.log
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR="/p/scratch/cellsinsilico/paul/nastja-out/${SLURM_JOB_NAME}"
+
+echo "outdir is ${OUTPUT_DIR}"
+
+mkdir -p "${OUTPUT_DIR}"
+source "${SOURCE_DIR}/activate-nastja-modules"
+
+srun --unbuffered "${SOURCE_DIR}/nastja/build-cuda/nastja" \
+  -c "${SOURCE_DIR}/ma/experiments/configs/${SLURM_JOB_NAME}.json" \
+  -o "${OUTPUT_DIR}"

experiments/batch/measurements/strong/.gitkeep

@@ -0,0 +1 @@
+Generated by scripts/gen/strong.py

experiments/batch/nocuda

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=nocuda
+# Forschergruppe Schug
+#SBATCH --account=hkf6
+# 48 Cores, 512GiB RAM, 4x NVIDIA A100 GPUs
+#SBATCH --partition=booster
+# Right now we're using a single node
+#SBATCH --nodes=1
+# Number of MPI processes
+# TODO: Change the config and set to this the maximum of 48
+#SBATCH --ntasks=16
+#SBATCH --cpus-per-task=1
+#SBATCH --time=01:00:00
+#SBATCH --output=logs/nocuda-%j.log
+#SBATCH --error=logs/nocuda-%j.log
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR=/p/scratch/cellsinsilico/paul/nastja-out/nocuda
+
+mkdir -p "${OUTPUT_DIR}"
+source "${SOURCE_DIR}/activate-nastja-modules"
+
+srun --unbuffered "${SOURCE_DIR}/nastja/build-nocuda/nastja" \
+  -c "${SOURCE_DIR}/ma/experiments/configs/genesis.json" \
+  -o "${OUTPUT_DIR}"

experiments/batch/nocuda-noecm

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=nocuda-noecm
+# Forschergruppe Schug
+#SBATCH --account=hkf6
+# 48 Cores, 512GiB RAM, 4x NVIDIA A100 GPUs
+#SBATCH --partition=booster
+# Right now we're using a single node
+#SBATCH --nodes=1
+# Number of MPI processes
+# TODO: Change the config and set to this the maximum of 48
+#SBATCH --ntasks-per-node=16
+#SBATCH --cpus-per-task=1
+#SBATCH --time=01:00:00
+#SBATCH --output=logs/nocuda-noecm-%j.log
+#SBATCH --error=logs/nocuda-noecm-%j.log
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR=/p/scratch/cellsinsilico/paul/nastja-out/nocuda-noecm
+
+mkdir -p "${OUTPUT_DIR}"
+source "${SOURCE_DIR}/activate-nastja-modules"
+
+srun "${SOURCE_DIR}/nastja/build-nocuda/nastja" \
+  -c "${SOURCE_DIR}/ma/experiments/configs/genesis-noecm.json" \
+  -o "${OUTPUT_DIR}"

experiments/batch/nocuda-singleblock

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=nocuda-singleblock
+# Forschergruppe Schug
+#SBATCH --account=hkf6
+# 48 Cores, 512GiB RAM, 4x NVIDIA A100 GPUs
+#SBATCH --partition=booster
+# Right now we're using a single node
+#SBATCH --nodes=1
+# Number of MPI processes
+#SBATCH --ntasks=1
+#SBATCH --time=06:00:00
+#SBATCH --output=logs/nocuda-singleblock-%j.log
+#SBATCH --error=logs/nocuda-singleblock-%j.log
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR=/p/scratch/cellsinsilico/paul/nastja-out/nocuda-singleblock
+
+mkdir -p "${OUTPUT_DIR}"
+source "${SOURCE_DIR}/activate-nastja-modules"
+
+srun --unbuffered "${SOURCE_DIR}/nastja/build-nocuda/nastja" \
+  -c "${SOURCE_DIR}/ma/experiments/configs/genesis-singleblock.json" \
+  -o "${OUTPUT_DIR}"

experiments/batch/varied-fillings-nocuda

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name=varied-fillings-nocuda
+# Forschergruppe Schug
+#SBATCH --account=hkf6
+# 48 Cores, 512GiB RAM, 4x NVIDIA A100 GPUs
+#SBATCH --partition=booster
+# Right now we're using a single node
+#SBATCH --nodes=1
+#SBATCH --ntasks=48
+#SBATCH --cpus-per-task=1
+#SBATCH --time=02:00:00
+#SBATCH --output=logs/varied-fillings-nocuda-%A-%3a.log
+#SBATCH --error=logs/varied-fillings-nocuda-%A-%3a.log
+#SBATCH --array=0-100:10
+
+IDENT=$(printf "%03d" "${SLURM_ARRAY_TASK_ID}")
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR="/p/scratch/cellsinsilico/paul/nastja-out/varied-fillings-nocuda-${IDENT}"
+
+mkdir -p "${OUTPUT_DIR}"
+source "${SOURCE_DIR}/activate-nastja-modules"
+
+srun "${SOURCE_DIR}/nastja/build-nocuda/nastja" \
+  -c "${SOURCE_DIR}/ma/experiments/generated/varied-fillings-${IDENT}.json" \
+  -o "${OUTPUT_DIR}"

experiments/collatz.py

@@ -0,0 +1,31 @@
+import time
+
+def collatz(x):
+    seq = [x]
+    while x != 1:
+        if x % 2 == 0:
+            x //= 2
+        else:
+            x = 3 * x + 1
+        seq.append(x)
+    return seq
+
+if __name__ == "__main__":
+    best = None
+    try:
+        i = 1
+        start = time.time()
+        while True:
+            pair = (i, collatz(i))
+
+            if (not best or len(pair[1]) > len(best[1])) and not any(c >= 2**31 for c in pair[1]):
+                best = pair
+
+            if i % 10000 == 0:
+                now = time.time()
+                print(f"{i:>10}   best: {best[0]:>10} {len(best[1]):>5} {(now - start) * 1000 / i:5.2}ns/seq")
+            i += 1
+    except KeyboardInterrupt:
+        pass
+    
+    print(best)

experiments/configs/comp.json

@@ -0,0 +1,102 @@
+{
+  "#Testing": {
+    "description": "Small experiment for comparing CPU and GPU implementations"
+  },
+  "Application": "Cells",
+  "Geometry": {
+    "blocksize": [10, 10, 10],
+    "blockcount": [1, 1, 1]
+  },
+  "Settings": {
+    "timesteps": 4,
+    "randomseed": 42
+  },
+  "Filling": {
+    "cells": [
+      {
+        "_comment": "This is for the dynamic ECM",
+        "shape": "cube",
+        "box": [
+          [0, 0, 0],
+          [9, 9, 9]
+        ],
+        "value": 0,
+        "celltype": 0
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [4, 4, 4],
+          [7, 7, 7]
+        ],
+        "celltype": 2
+      }
+    ]
+  },
+  "CellsInSilico": {
+    "liquid": 1,
+    "adhesion": {
+      "matrix": [
+        [0, 0,  0, 0],
+        [0, 0,  0, 0],
+        [0, 0, 10, 5],
+        [0, 0,  5, 5]
+      ]
+    },
+    "temperature": 15,
+    "volume": {
+      "default": [0, 0, 64, 64],
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "surface": {
+      "default": [0, 0, 80, 80],
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "cleaner": {
+      "killdistance": 100
+    },
+    "checkerboard": "00",
+    "energyfunctions": ["Volume00", "Surface00", "Adhesion00", "DynamicECM00"],
+    "centerofmass": {
+      "steps": 10
+    },
+    "dynamicecm": {
+      "enabled": true,
+      "stepsPerMcs": 10,
+      "pushSteps": 10,
+      "pushWeight": 2,
+      "ecmCellID": 0,
+      "deltat": 0.1,
+      "eta": 0.25,
+      "k0": 0.1,
+      "k1": 0.1,
+      "c": 4,
+      "alpha": 2,
+      "d": 0.3,
+      "phi": 1,
+      "lambda": 50
+    }
+  },
+  "Writers": {
+    "ParallelVTK_Cells": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "UInt32",
+      "field": "cells",
+      "steps": 1
+    },
+    "ParallelVTK_Displacement": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "Float32",
+      "field": "dynamicecm",
+      "components": [0, 1, 2],
+      "steps": 1
+    }
+  },
+  "WriteActions": ["ParallelVTK_Cells", "ParallelVTK_Displacement"]
+}

experiments/configs/ecm-debug.json

@@ -0,0 +1,88 @@
+{
+  "#Testing": {
+    "description": "Just dynamic ECM for debugging"
+  },
+  "Application": "Cells",
+  "Geometry": {
+    "blocksize": [5, 5, 5],
+    "blockcount": [1, 1, 1]
+  },
+  "Settings": {
+    "timesteps": 10,
+    "randomseed": 42
+  },
+  "Filling": {
+    "cells": [
+      {
+        "_comment": "This is for the dynamic ECM",
+        "shape": "cube",
+        "box": [
+          [0, 0, 0],
+          [4, 4, 4]
+        ],
+        "value": 0,
+        "celltype": 0
+      }
+    ]
+  },
+  "CellsInSilico": {
+    "liquid": 1,
+    "adhesion": {
+      "matrix": [
+        [0, 0,  0, 0],
+        [0, 0,  0, 0],
+        [0, 0, 10, 5],
+        [0, 0,  5, 5]
+      ]
+    },
+    "temperature": 15,
+    "volume": {
+      "default": [0, 0, 7000, 1000],
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "surface": {
+      "default": [0, 0, 2500, 1000],
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "checkerboard": "00",
+    "energyfunctions": ["Volume00", "Surface00", "Adhesion00", "DynamicECM00"],
+    "dynamicecm": {
+      "enabled": true,
+      "stepsPerMcs": 1,
+      "pushSteps": 1,
+      "pushWeight": 2,
+      "ecmCellID": 0,
+      "deltat": 0.1,
+      "eta": 0.25,
+      "k0": 0.1,
+      "k1": 0.1,
+      "c": 4,
+      "alpha": 2,
+      "d": 0.3,
+      "phi": 1,
+      "lambda": 50
+    }
+  },
+  "Writers": {
+    "ParallelVTK_Cells": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "UInt32",
+      "field": "cells",
+      "steps": 1
+    },
+    "ParallelVTK_Displacement": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "Float32",
+      "field": "dynamicecm",
+      "components": [0, 1, 2],
+      "steps": 1
+    }
+  },
+  "WriteActions": ["ParallelVTK_Cells", "ParallelVTK_Displacement"]
+}

experiments/configs/genesis-noecm.json

@@ -0,0 +1,109 @@
+{
+  "#Testing": {
+    "description": "Cellular Potts Model with dynamic ECM"
+  },
+  "Application": "Cells",
+  "Geometry": {
+    "blocksize": [20, 40, 40],
+    "blockcount": [4, 2, 2]
+  },
+  "Settings": {
+    "timesteps": 250,
+    "randomseed": 42
+  },
+  "Filling": {
+    "cells": [
+      {
+        "_comment": "This is for the dynamic ECM",
+        "shape": "cube",
+        "box": [
+          [0, 0, 0],
+          [79, 79, 79]
+        ],
+        "value": 0,
+        "celltype": 0
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [41, 35, 10],
+          [45, 39, 15]
+        ],
+        "celltype": 2
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [40, 15, 14],
+          [47, 22, 20]
+        ],
+        "celltype": 2
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [40, 20, 20],
+          [47, 27, 26]
+        ],
+        "celltype": 3
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [38, 20, 60],
+          [45, 27, 66]
+        ],
+        "celltype": 3
+      }
+    ]
+  },
+  "CellsInSilico": {
+    "liquid": 1,
+    "adhesion": {
+      "matrix": [
+        [0, 0,  0, 0],
+        [0, 0,  0, 0],
+        [0, 0, 10, 5],
+        [0, 0,  5, 5]
+      ]
+    },
+    "temperature": 15,
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 2000
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 800
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "cleaner": {
+      "killdistance": 100
+    },
+    "checkerboard": "00",
+    "energyfunctions": ["Volume00", "Surface00", "Adhesion00"],
+    "centerofmass": {
+      "steps": 10
+    }
+  },
+  "Writers": {
+    "ParallelVTK_Cells": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "UInt32",
+      "field": "cells",
+      "steps": 1
+    }
+  },
+  "WriteActions": ["ParallelVTK_Cells"]
+}

experiments/configs/genesis-singleblock.json

@@ -0,0 +1,131 @@
+{
+  "#Testing": {
+    "description": "Cellular Potts Model with dynamic ECM"
+  },
+  "Application": "Cells",
+  "Geometry": {
+    "blocksize": [80, 80, 80],
+    "blockcount": [1, 1, 1]
+  },
+  "Settings": {
+    "timesteps": 250,
+    "randomseed": 42
+  },
+  "Filling": {
+    "cells": [
+      {
+        "_comment": "This is for the dynamic ECM",
+        "shape": "cube",
+        "box": [
+          [0, 0, 0],
+          [79, 79, 79]
+        ],
+        "value": 0,
+        "celltype": 0
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [41, 35, 10],
+          [45, 39, 15]
+        ],
+        "celltype": 2
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [40, 15, 14],
+          [47, 22, 20]
+        ],
+        "celltype": 2
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [40, 20, 20],
+          [47, 27, 26]
+        ],
+        "celltype": 3
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [38, 20, 60],
+          [45, 27, 66]
+        ],
+        "celltype": 3
+      }
+    ]
+  },
+  "CellsInSilico": {
+    "liquid": 1,
+    "adhesion": {
+      "matrix": [
+        [0, 0,  0, 0],
+        [0, 0,  0, 0],
+        [0, 0, 10, 5],
+        [0, 0,  5, 5]
+      ]
+    },
+    "temperature": 15,
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 2000
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 800
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "cleaner": {
+      "killdistance": 100
+    },
+    "checkerboard": "00",
+    "energyfunctions": ["Volume00", "Surface00", "Adhesion00", "DynamicECM00"],
+    "centerofmass": {
+      "steps": 10
+    },
+    "dynamicecm": {
+      "enabled": true,
+      "stepsPerMcs": 100,
+      "pushSteps": 10,
+      "pushWeight": 2,
+      "ecmCellID": 0,
+      "deltat": 0.1,
+      "eta": 0.25,
+      "k0": 0.1,
+      "k1": 0.1,
+      "c": 4,
+      "alpha": 2,
+      "d": 0.3,
+      "phi": 1
+    }
+  },
+  "Writers": {
+    "ParallelVTK_Cells": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "UInt32",
+      "field": "cells",
+      "steps": 1
+    },
+    "ParallelVTK_Displacement": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "Float32",
+      "field": "dynamicecm",
+      "components": [0, 1, 2],
+      "steps": 1
+    }
+  },
+  "WriteActions": ["ParallelVTK_Cells", "ParallelVTK_Displacement"]
+}

experiments/configs/genesis.json

@@ -0,0 +1,131 @@
+{
+  "#Testing": {
+    "description": "Cellular Potts Model with dynamic ECM"
+  },
+  "Application": "Cells",
+  "Geometry": {
+    "blocksize": [20, 40, 40],
+    "blockcount": [4, 2, 2]
+  },
+  "Settings": {
+    "timesteps": 250,
+    "randomseed": 42
+  },
+  "Filling": {
+    "cells": [
+      {
+        "_comment": "This is for the dynamic ECM",
+        "shape": "cube",
+        "box": [
+          [0, 0, 0],
+          [79, 79, 79]
+        ],
+        "value": 0,
+        "celltype": 0
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [41, 35, 10],
+          [45, 39, 15]
+        ],
+        "celltype": 2
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [40, 15, 14],
+          [47, 22, 20]
+        ],
+        "celltype": 2
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [40, 20, 20],
+          [47, 27, 26]
+        ],
+        "celltype": 3
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [38, 20, 60],
+          [45, 27, 66]
+        ],
+        "celltype": 3
+      }
+    ]
+  },
+  "CellsInSilico": {
+    "liquid": 1,
+    "adhesion": {
+      "matrix": [
+        [0, 0,  0, 0],
+        [0, 0,  0, 0],
+        [0, 0, 10, 5],
+        [0, 0,  5, 5]
+      ]
+    },
+    "temperature": 15,
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 2000
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 800
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "cleaner": {
+      "killdistance": 100
+    },
+    "checkerboard": "00",
+    "energyfunctions": ["Volume00", "Surface00", "Adhesion00", "DynamicECM00"],
+    "centerofmass": {
+      "steps": 10
+    },
+    "dynamicecm": {
+      "enabled": true,
+      "stepsPerMcs": 100,
+      "pushSteps": 10,
+      "pushWeight": 2,
+      "ecmCellID": 0,
+      "deltat": 0.1,
+      "eta": 0.25,
+      "k0": 0.1,
+      "k1": 0.1,
+      "c": 4,
+      "alpha": 2,
+      "d": 0.3,
+      "phi": 1
+    }
+  },
+  "Writers": {
+    "ParallelVTK_Cells": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "UInt32",
+      "field": "cells",
+      "steps": 1
+    },
+    "ParallelVTK_Displacement": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "Float32",
+      "field": "dynamicecm",
+      "components": [0, 1, 2],
+      "steps": 1
+    }
+  },
+  "WriteActions": ["ParallelVTK_Cells", "ParallelVTK_Displacement"]
+}

experiments/configs/julian-animation.json

@@ -0,0 +1,330 @@
+{
+  "Comments": [
+    "Celltype         Usage",
+    "0                Dynamic ECM",
+    "1-5             Not Used",
+    "6               Liquid  ",
+    "7               Apoptotic cell Type ",
+    "8               Basic Non Dividing Cell type (surrounding)",
+    "9               Cancer"
+  ],
+  "Application": "Cells",
+  "CellsInSilico": {
+    "ecmdegradation": {
+      "enabled": "false",
+      "steps": 99999,
+      "stochastic": "true",
+      "probability": 0.5
+    },
+    "energyfunctions": [
+      "Volume00",
+      "Surface01",
+      "Motility00",
+      "Adhesion01",
+      "DynamicECM00"
+    ],
+    "liquid": 6,
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 500
+      },
+      "lambda": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        7.5,
+        7.5,
+        7.5
+      ],
+      "sizechange": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        -0.05,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 400
+      },
+      "lambda": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        5.625,
+        5.625,
+        1
+      ],
+      "sizechange": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        -0.05,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    "adhesion": {
+      "matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          450
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          450,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          50
+        ]
+      ]
+    },
+    "temperature": 50,
+    "division": {
+      "enabled": "true",
+      "condition": [
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "( volume >= 0.9 * volume0 )  & ( rnd() <= 0.00001 ) & generation < 1"
+      ]
+    },
+    "centerofmass": {
+      "steps": 1
+    },
+    "signaling": {
+      "enabled": false
+    },
+    "orientation": {
+      "enabled": true,
+      "motility": "persistentRandomWalk",
+      "persistenceMagnitude": 0.0,
+      "recalculationtime": 200,
+      "motilityamount": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    },
+    "visitor": {
+      "stepwidth": 10,
+      "checkerboard": "01"
+    },
+    "cleaner": {
+      "killDistance": 20
+    },
+    "dynamicecm": {
+      "enabled": true,
+      "stepsPerMcs": 100,
+      "pushSteps": 10,
+      "pushWeight": 2,
+      "ecmCellID": 0,
+      "deltat": 0.1,
+      "eta": 0.25,
+      "k0": 0.1,
+      "k1": 0.1,
+      "c": 4,
+      "alpha": 2,
+      "d": 0.3,
+      "phi": 1
+    }
+  },
+  "Geometry": {
+    "blockcount": [
+      2,
+      4,
+      4
+    ],
+    "blocksize": [
+      200,
+      100,
+      100
+    ]
+  },
+  "Settings": {
+    "randomseed": 0,
+    "timesteps": 5000,
+    "statusoutput": 1
+  },
+  "WriteActions": ["ParallelVTK_Cells", "ParallelVTK_Displacement"],
+  "Writers": {
+    "CellInfo": {
+      "field": "",
+      "groupsize": 0,
+      "steps": 1,
+      "writer": "CellInfo"
+    },
+    "ParallelVTK_Cells": {
+      "field": "cells",
+      "outputtype": "UInt32",
+      "printhints": false,
+      "steps": 100,
+      "writer": "ParallelVtkImage"
+    },
+    "ParallelVTK_Displacement": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "Float32",
+      "field": "dynamicecm",
+      "components": [
+        0,
+        1,
+        2
+      ],
+      "steps": 100
+    }
+  },
+  "Include": "measurements/strong/config_filling_1.json"
+}

experiments/configs/measurements/.gitkeep

@@ -0,0 +1 @@
+Autogenerated by scripts/gen/strong.py

experiments/configs/measurements/strong/config_filling_1.json

@@ -0,0 +1,44 @@
+{
+    "DefineFunctions": [
+        "r_angle()=360*rnd()",
+        "r_size()=400*rnd()"
+    ],
+    "Filling": {
+        "cells": [
+            {
+                "_comment": "This is for the dynamic ECM",
+                "shape": "cube",
+                "box": [
+                  [0, 0, 0],
+                  [399, 399, 401]
+                ],
+                "value": 0,
+                "celltype": 0
+            },
+            {
+                "shape": "sphere",
+                "pattern": "voronoi",
+                "count": 5500,
+                "radius": 75,
+                "center": [
+                    200,
+                    200,
+                    200
+                ],
+                "box": [
+                    [
+                        110,
+                        110,
+                        110
+                    ],
+                    [
+                        290,
+                        290,
+                        290
+                    ]
+                ],
+                "celltype": 9
+            }
+        ]
+    }
+}

experiments/configs/medium.json

@@ -0,0 +1,110 @@
+{
+  "#Testing": {
+    "description": "Cellular Potts Model with dynamic ECM"
+  },
+  "Application": "Cells",
+  "Geometry": {
+    "blocksize": [180, 180, 180],
+    "blockcount": [1, 1, 1]
+  },
+  "Settings": {
+    "timesteps": 100,
+    "randomseed": 42,
+    "statusoutput": 1
+  },
+  "Filling": {
+    "cells": [
+      {
+        "_comment": "This is for the dynamic ECM",
+        "shape": "cube",
+        "box": [
+          [0, 0, 0],
+          [179, 179, 179]
+        ],
+        "value": 0,
+        "celltype": 0
+      },
+      {
+        "shape": "cube",
+        "pattern": "voronoi",
+        "box": [
+            [20, 20, 20],
+            [159, 159, 159]
+        ],
+        "count": 1500,
+        "celltype": [0, 0, 750, 750]
+      }
+    ]
+  },
+  "CellsInSilico": {
+    "liquid": 1,
+    "adhesion": {
+      "matrix": [
+        [0, 0,  0, 0],
+        [0, 0,  0, 0],
+        [0, 0, 10, 5],
+        [0, 0,  5, 5]
+      ]
+    },
+    "temperature": 15,
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 2000
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 800
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "cleaner": {
+      "killdistance": 100
+    },
+    "checkerboard": "00",
+    "energyfunctions": ["Volume00", "Surface00", "Adhesion00", "DynamicECM00"],
+    "centerofmass": {
+      "steps": 10
+    },
+    "dynamicecm": {
+      "enabled": true,
+      "stepsPerMcs": 100,
+      "pushSteps": 10,
+      "pushWeight": 2,
+      "ecmCellID": 0,
+      "deltat": 0.1,
+      "eta": 0.25,
+      "k0": 0.1,
+      "k1": 0.1,
+      "c": 4,
+      "alpha": 2,
+      "d": 0.3,
+      "phi": 1
+    }
+  },
+  "Writers": {
+    "ParallelVTK_Cells": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "UInt32",
+      "field": "cells",
+      "steps": 10
+    },
+    "ParallelVTK_Displacement": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "Float32",
+      "field": "dynamicecm",
+      "components": [0, 1, 2],
+      "steps": 10
+    }
+  },
+  "WriteActions": ["ParallelVTK_Cells", "ParallelVTK_Displacement"]
+}

experiments/configs/mini.json

@@ -0,0 +1,110 @@
+{
+  "#Testing": {
+    "description": "Cellular Potts Model with dynamic ECM, small experiment"
+  },
+  "Application": "Cells",
+  "Geometry": {
+    "blocksize": [40, 20, 20],
+    "blockcount": [1, 1, 1]
+  },
+  "Settings": {
+    "timesteps": 200,
+    "randomseed": 42
+  },
+  "Filling": {
+    "cells": [
+      {
+        "_comment": "This is for the dynamic ECM",
+        "shape": "cube",
+        "box": [
+          [10, 0, 0],
+          [39, 19, 19]
+        ],
+        "value": 0,
+        "celltype": 0
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [2, 8, 8],
+          [9, 13, 13]
+        ],
+        "celltype": 2
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [30, 8, 8],
+          [37, 13, 13]
+        ],
+        "celltype": 3
+      }
+    ]
+  },
+  "CellsInSilico": {
+    "liquid": 1,
+    "adhesion": {
+      "matrix": [
+        [0, 0,  0, 0],
+        [0, 0,  0, 0],
+        [0, 0, 10, 5],
+        [0, 0,  5, 5]
+      ]
+    },
+    "temperature": 15,
+    "volume": {
+      "default": [0, 0, 7000, 1000],
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "surface": {
+      "default": [0, 0, 2500, 1000],
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "cleaner": {
+      "killdistance": 100
+    },
+    "checkerboard": "00",
+    "energyfunctions": ["Volume00", "Surface00", "Adhesion00", "DynamicECM00"],
+    "centerofmass": {
+      "steps": 10
+    },
+    "dynamicecm": {
+      "enabled": true,
+      "stepsPerMcs": 10,
+      "pushSteps": 10,
+      "pushWeight": 2,
+      "ecmCellID": 0,
+      "deltat": 0.1,
+      "eta": 0.25,
+      "k0": 0.1,
+      "k1": 0.1,
+      "c": 4,
+      "alpha": 2,
+      "d": 0.3,
+      "phi": 1,
+      "lambda": 50
+    }
+  },
+  "Writers": {
+    "ParallelVTK_Cells": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "UInt32",
+      "field": "cells",
+      "steps": 1
+    },
+    "ParallelVTK_Displacement": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "Float32",
+      "field": "dynamicecm",
+      "components": [0, 1, 2],
+      "steps": 1
+    }
+  },
+  "WriteActions": ["ParallelVTK_Cells", "ParallelVTK_Displacement"]
+}

experiments/configs/small.json

@@ -0,0 +1,97 @@
+{
+  "#Testing": {
+    "description": "Minimal config for debugging CUDA code"
+  },
+  "Application": "Cells",
+  "Geometry": {
+    "blocksize": [5, 5, 5],
+    "blockcount": [1, 1, 1]
+  },
+  "Settings": {
+    "timesteps": 3,
+    "randomseed": 42
+  },
+  "Filling": {
+    "cells": [
+      {
+        "_comment": "This is for the dynamic ECM",
+        "shape": "cube",
+        "box": [
+          [0, 0, 0],
+          [4, 2, 4]
+        ],
+        "value": 0,
+        "celltype": 0
+      },
+      {
+        "shape": "cube",
+        "box": [
+          [1, 1, 1],
+          [3, 3, 3]
+        ],
+        "celltype": 2
+      }
+    ]
+  },
+  "CellsInSilico": {
+    "liquid": 1,
+    "adhesion": {
+      "matrix": [
+        [0, 0, 0, 0],
+        [0, 20, 5, 5],
+        [0, 5, 10, 5],
+        [0, 5, 5, 5]
+      ]
+    },
+    "temperature": 15,
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 300
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "potential": {
+      "direction": [1, 1, 0],
+      "coupling": [0, 150, 100, 50]
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 400
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "cleaner": {
+      "killdistance": 100
+    },
+    "checkerboard": "00",
+    "energyfunctions": ["Volume00", "Surface00", "Adhesion00", "Potential00", "DynamicECM00"],
+    "centerofmass": {
+      "steps": 10
+    },
+    "dynamicecm": {
+      "enabled": true,
+      "ecmCellID": 0,
+      "stepsPerMcs": 1,
+      "pushSteps": 1,
+      "deltat": 0.1,
+      "eta": 0.5
+    }
+  },
+  "Writers": {
+    "ParallelVTK_Displacement": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "Float32",
+      "field": "dynamicecm",
+      "steps": 1
+    }
+  },
+  "WriteActions": ["ParallelVTK_Displacement"]
+}

experiments/configs/spheroid/config.json

@@ -0,0 +1,116 @@
+{
+    "Comments": ["Celltype         Usage", "0                Not Used", "1-5             Solids for blood vessels / ECM", "6               Liquid  ", "7               Apoptotic cell Type ", "8               Basic Non Dividing Cell type (surrounding)", "9               Cancer"],
+    "Application": "Cells",
+    "CellsInSilico": {
+        "ecmdegradation": {
+            "enabled": "false",
+            "steps": 99999,
+            "stochastic": "true",
+            "probability": 0.5
+        },
+        "energyfunctions": ["Volume00", "Surface01", "Motility00", "Adhesion01", "DynamicECM00"],
+        "liquid": 6,
+        "volume": {
+            "default": {
+                "storage": "const",
+                "value": 500
+            },
+            "lambda": [0, 0, 0, 0, 0, 0, 0, 7.5, 7.5, 7.5],
+            "sizechange": [0, 0, 0, 0, 0, 0, 0, -0.05, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "surface": {
+            "default": {
+                "storage": "const",
+                "value": 400
+            },
+            "lambda": [0, 0, 0, 0, 0, 0, 0, 5.625, 5.625, 1],
+            "sizechange": [0, 0, 0, 0, 0, 0, 0, -0.05, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "adhesion": {
+            "matrix": [
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 450],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 450, 0, 0, 0, 0, 0, 0, 0, 50]
+            ]
+        },
+        "temperature": 50,
+        "division": {
+            "enabled": "true",
+            "condition": ["", "", "", "", "", "", "", "", "", "( volume >= 0.9 * volume0 )  & ( rnd() <= 0.00001 ) & generation < 1"]
+        },
+        "centerofmass": {
+            "steps": 1
+        },
+        "signaling": {
+            "enabled": false
+        },
+        "orientation": {
+            "enabled": true,
+            "motility": "persistentRandomWalk",
+            "persistenceMagnitude": 0.0,
+            "recalculationtime": 200,
+            "motilityamount": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "visitor": {
+            "stepwidth": 10,
+            "checkerboard": "01"
+        },
+        "cleaner": {
+            "killDistance": 20
+        },
+        "dynamicecm": {
+            "enabled": true,
+            "stepsPerMcs": 100,
+            "pushSteps": 10,
+            "pushWeight": 2,
+            "ecmCellID": 0,
+            "deltat": 0.1,
+            "eta": 0.25,
+            "k0": 0.1,
+            "k1": 0.1,
+            "c": 4,
+            "alpha": 2,
+            "d": 0.3,
+            "phi": 1
+        }
+    },
+    "Geometry": {
+        "blockcount": [8, 8, 6],
+        "blocksize": [50, 50, 67]
+    },
+    "Settings": {
+        "randomseed": 0,
+        "timesteps": 100
+    },
+    "WriteActions": ["CellInfo"],
+    "Writers": {
+        "CellInfo": {
+            "field": "",
+            "groupsize": 0,
+            "steps": 1,
+            "writer": "CellInfo"
+        },
+        "ParallelVTK_Cells": {
+            "field": "cells",
+            "outputtype": "UInt32",
+            "printhints": false,
+            "steps": 1,
+            "writer": "ParallelVtkImage"
+        },
+        "ParallelVTK_Displacement": {
+            "writer": "ParallelVtkImage",
+            "outputtype": "Float32",
+            "field": "dynamicecm",
+            "components": [0, 1, 2],
+            "steps": 1
+        }
+    },
+    "Include": "config_filling_1.json"
+}

experiments/configs/spheroid/config_filling_1.json

@@ -0,0 +1,44 @@
+{
+    "DefineFunctions": [
+        "r_angle()=360*rnd()",
+        "r_size()=400*rnd()"
+    ],
+    "Filling": {
+        "cells": [
+            {
+                "_comment": "This is for the dynamic ECM",
+                "shape": "cube",
+                "box": [
+                  [0, 0, 0],
+                  [399, 399, 401]
+                ],
+                "value": 0,
+                "celltype": 0
+            },
+            {
+                "shape": "sphere",
+                "pattern": "voronoi",
+                "count": 5500,
+                "radius": 75,
+                "center": [
+                    200,
+                    200,
+                    200
+                ],
+                "box": [
+                    [
+                        110,
+                        110,
+                        110
+                    ],
+                    [
+                        290,
+                        290,
+                        290
+                    ]
+                ],
+                "celltype": 9
+            }
+        ]
+    }
+}

experiments/eval/Makefile

@@ -0,0 +1,13 @@
+generate-batch-strong-cpu:
+	python scripts/substitute.py strong-batch.j2 < strong-cpu.json
+
+generate-batch-strong-gpu:
+	python scripts/substitute.py strong-batch.j2 < strong-gpu.json
+
+generate-batch-strong-booster:
+	python scripts/substitute.py strong-batch.j2 < strong-booster.json
+
+clean-logs:
+	rm logs/*
+
+.PHONY: generate-batch-strong-cpu clean-logs

experiments/eval/data/actions-normalized.csv

@@ -0,0 +1,4 @@
+label,BC:cells,BC:dynamicecm,Sweep:Cells,Sweep:DynamicECM,Sweep:DynamicECMDampers,Filling,Other
+CPU,0.04629667717328299,3.88243023434036,0.002164069189058585,82.18255346583861,13.842310640806883,0.005797982839735358,0.03844692981207934
+GPU,0.034897486509106485,41.227398706349675,13.180664898871365,22.432483220415783,19.749714111977486,1.9939606413394697,1.3808809345371023
+Booster,0.09128030041871667,42.736382370072874,12.260298369798207,22.36492489089858,16.070196185259338,4.364304866307413,2.1126130172448816

experiments/eval/data/actions.csv

@@ -0,0 +1,4 @@
+label,BC:cells,BC:dynamicecm,Sweep:Cells,Sweep:DynamicECM,Sweep:DynamicECMDampers,Other
+CPU,0.9047934333333334,75.87579921250001,0.04229322083333333,1606.12465625,270.5255006333333,0.8646950250000001
+GPU,0.11372260000000001,134.35027680000002,42.952648800000006,73.102122,64.3596162,10.9978052
+Booster,0.155221,72.67267939999999,20.848482800000003,38.0312728,27.327165999999995,11.013917200000002

experiments/eval/data/strong-booster.tsv

@@ -0,0 +1,9 @@
+label	nodes	tasks	mean_time	std_time	speedup	speedup_std	speedup_error
+1	1	1	161.08257980000002	1.0725827874500897	1.0	0.0066585895804611986	0.004614167168572558
+1	1	2	109.2771463	1.3498701967829918	1.474073813730255	0.018208823861030076	0.012618071172974463
+1	1	4	94.5763083	2.921107861707173	1.7032022363258181	0.052605536545441436	0.03645377698685362
+2	2	8	75.06436665	5.345617315509918	2.145926049720424	0.15281950626022228	0.10589851499069955
+4	4	16	42.842002025	1.5314070839490197	3.759921856733072	0.13440013758310768	0.09313454370387199
+8	8	32	16.40522446875	4.395440141154071	9.818980539208297	2.6307924825691393	1.823046180232846
+16	16	64	9.361684956249999	5.010216046116417	17.206579857449583	9.208671612370724	6.381283859970849
+32	32	128	5.214438346875	0.113661681579046	30.891645290338204	0.6733604113945479	0.4666149588180552

experiments/eval/data/strong-cpu.tsv

@@ -0,0 +1,10 @@
+label	nodes	tasks	mean_time	std_time	speedup	speedup_std	speedup_error
+1	1	48	1953.3832839708334	14.087268287606769	1.0	0.007211727674340593	0.004711662080569187
+2	2	96	1046.3540047312501	6.0880471399828595	1.866847429396085	0.010861959816590314	0.007096480413505672
+4	4	192	566.0709002166666	5.005298021298787	3.4507749527897755	0.030512356378918384	0.019934739500893344
+8	8	384	318.1225953708333	9.706195475255436	6.1403475024896865	0.18734731205020752	0.12240024387280224
+16	16	768	178.56471887994792	9.393026972005948	10.939357428631386	0.5754422263707719	0.375955587895571
+32	32	1536	99.82801128216144	1.4413062581268035	19.56748670921274	0.28251330150299214	0.18457535698195485
+64	64	3072	55.75610567220052	1.0303316198245824	35.034428255357376	0.6474103379133267	0.42297475410337343
+128	128	6144	31.589132888118492	0.32226687791817415	61.83719226764697	0.6308523555205254	0.41215687227340997
+256	256	12288	19.11704500200738	0.18528928846832715	102.18018965617955	0.9903672160087601	0.6470399144590566

experiments/eval/data/strong-gpu-actions.csv

@@ -0,0 +1,9 @@
+label,BC:cells,BC:dynamicecm,Sweep:Cells,Sweep:DynamicECM,Sweep:DynamicECMDampers,Filling,Other
+1,0.034897486509106485,41.227398706349675,13.180664898871365,22.432483220415783,19.749714111977486,1.9939606413394697,1.3808809345371023
+2,0.7137918070198439,50.7137377526309,8.923981074147767,19.35772833011394,17.571497161475467,1.320924803923136,1.3983390706889622
+4,0.6647403410134337,58.291944402330074,7.087118055335309,16.67352093599457,15.236952119238136,1.092645293437499,0.953078852650984
+8,0.6788278363464717,65.05900206274784,5.2089254465999275,14.249993130938188,13.176763096049008,0.7851584656500297,0.8413299616685318
+16,1.441574901760373,61.1245906198054,4.832237599492141,16.029377636605524,14.996293924006913,0.716990077435801,0.858935240893841
+32,3.3736940900007966,47.94830950907802,5.622259685491874,21.238716402604393,19.97281149065964,0.8196124452570666,1.0245963769081996
+64,6.284545018581091,45.28808866195176,4.502683326147901,21.66574860147326,20.522789117514915,0.6460791296539419,1.0900661446771265
+128,11.788574344478201,40.04977497065291,3.2677482351392375,22.1995263401806,21.209134936528987,0.4598839494487746,1.0253572235712836

experiments/eval/data/strong-gpu.tsv

@@ -0,0 +1,9 @@
+label	nodes	tasks	mean_time	std_time	speedup	speedup_std	speedup_error
+1	1	1	316.56674059999995	1.3298279828832311	1.0	0.004200782370133899	0.002910993666206366
+1	1	2	239.7297573	1.3705192585818793	1.3205150005797797	0.007549297425250635	0.00523139621453709
+1	1	4	150.86725470000002	1.463195211854327	2.098313124537819	0.020350616990413285	0.014102258089746373
+2	2	8	103.758313	1.3959932139830615	3.051001230137579	0.041049019495199714	0.028445519245192213
+4	4	16	56.423368849999996	0.8293394846143929	5.610560784514376	0.08246688711191473	0.057146637198176795
+8	8	32	24.168551143749998	0.5503559531334744	13.09829202078025	0.29826872726631265	0.20668968287257275
+16	16	64	15.05716248125	0.04648043269670786	21.024329185144023	0.06490066896072916	0.044973869063161365
+32	32	128	9.9111531140625	0.08848604506395903	31.940455056721632	0.28516203039001964	0.19760720531719309

experiments/eval/data/weak-booster.tsv

@@ -0,0 +1,9 @@
+nodes	tasks	mean_time	std_time	efficiency	efficiency_error
+1	1	41.98463099999999	1.4067920862965122	1.0	0.023219381860496473
+1	2	49.85189340000001	1.7669363566083227	0.8421872899214694	0.020685165974491628
+1	4	59.9694977	2.209151778903949	0.7000997608822725	0.01787171173813342
+2	8	72.810012625	0.5538313058789631	0.5766326565034021	0.003039461920431096
+4	16	84.718001525	5.20969191162485	0.4955809892140865	0.021118450727088397
+8	32	87.22569569999999	1.7018797711775082	0.4813332890390463	0.0065079080866405825
+16	64	85.36740952500001	1.0197522041876155	0.49181099946232654	0.004071100890302765
+32	128	87.5995021046875	0.8707125543332932	0.47927933368645675	0.003301208459097849

experiments/eval/data/weak-cpu.tsv

@@ -0,0 +1,10 @@
+nodes	tasks	mean_time	std_time	efficiency	efficiency_error
+1	48	234.09125610833334	4.9756238110995765	1.0	0.013886639526655382
+2	96	234.09269640000002	1.9886350551995884	0.9999938473447108	0.005550081636855162
+4	192	239.06532950520833	1.8931447841474947	0.9791936647310181	0.005066063671757703
+8	384	241.32357499479167	0.977728668984766	0.9700306160033705	0.0025676679349660694
+16	768	260.8008324059896	12.802824235961744	0.8975863073317291	0.028787758154736998
+32	1536	266.59983470546877	13.970338204797093	0.8780622702446538	0.03006125980502309
+64	3072	281.61153985800786	25.95560834859075	0.8312559074332151	0.05005532970709546
+128	6144	293.4177162058594	10.8076489888669	0.7978088683101088	0.019198998510810975
+256	12288	310.9775802693196	14.459893325743863	0.7527592693518308	0.022867934404056486

experiments/eval/data/weak-gpu.tsv

@@ -0,0 +1,9 @@
+nodes	tasks	mean_time	std_time	efficiency	efficiency_error
+1	1	60.658062599999994	1.8711952545625232	1.0	0.021376748626269895
+1	2	80.6903592	1.1554429061827625	0.751738661240214	0.007459415624087278
+1	4	89.01234124999999	1.3979557323025515	0.6814567704677693	0.00741639040919915
+2	8	101.357940575	4.784240687736861	0.5984539766286584	0.01957478845779047
+4	16	106.2530252	1.5044057675724636	0.5708831582519497	0.005601211794070455
+8	32	113.70197445	2.069642901549501	0.5334829310873062	0.006729131548114211
+16	64	119.22770070624999	0.7600051865549382	0.5087581345667959	0.00224730403456563
+32	128	121.8124414140625	0.5170666166834136	0.4979627852118346	0.0014647476739746731

experiments/eval/load-modules

@@ -0,0 +1 @@
+module load SciPy-Stack

experiments/eval/scripts/build-pgf-datafiles.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+
+
+import argparse
+import json
+import math
+
+
+def print_table(data, spec):
+    print("\t".join(column for column in spec.keys()))
+
+    for data_item in data:
+        values = []
+        for retrieve in spec.values():
+            raw_value = retrieve(data_item)
+            values.append(raw_value if isinstance(raw_value, str) else str(raw_value))
+        print("\t".join(values))
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(description="Turn files generated by timing.py into pgf datafiles")
+    p.add_argument("timing_file")
+    p.add_argument("--weak", action="store_true")
+    args = p.parse_args()
+
+    with open(args.timing_file, "r", encoding="utf8") as f:
+        jobs = json.load(f)
+
+    if not args.weak:
+        scaling_spec = {
+            "label": lambda job: job["accounting"][0]["nodes"]["count"],
+            "nodes": lambda job: job["accounting"][0]["nodes"]["count"],
+            "tasks": lambda job: job["accounting"][0]["tasks"]["count"],
+            "mean_time": lambda job: job["means"]["TimeStep"],
+            "std_time": lambda job: job["stds"]["TimeStep"],
+            "speedup": lambda job: jobs[0]["means"]["TimeStep"] / job["means"]["TimeStep"],
+            # Standard deviation scaled to speedup
+            "speedup_std": lambda job: (jobs[0]["means"]["TimeStep"] / job["means"]["TimeStep"]) * (job["stds"]["TimeStep"] / job["means"]["TimeStep"]),
+            # 95% confidence interval
+            "speedup_error": lambda job: (jobs[0]["means"]["TimeStep"] / job["means"]["TimeStep"]) * (job["stds"]["TimeStep"] / job["means"]["TimeStep"]) / math.sqrt(len(jobs)) * 1.96,
+        }
+    else:
+        scaling_spec = {
+            "nodes": lambda job: job["accounting"][0]["nodes"]["count"],
+            "tasks": lambda job: job["accounting"][0]["tasks"]["count"],
+            "mean_time": lambda job: job["means"]["TimeStep"],
+            "std_time": lambda job: job["stds"]["TimeStep"],
+            "efficiency": lambda job: jobs[0]["means"]["TimeStep"] / job["means"]["TimeStep"],
+            "efficiency_error": lambda job: (jobs[0]["means"]["TimeStep"] / job["means"]["TimeStep"]) * (job["stds"]["TimeStep"] / job["means"]["TimeStep"]) / math.sqrt(len(jobs)) * 1.96,
+        }
+
+    print_table(jobs, scaling_spec)

experiments/eval/scripts/generate-strong-booster-configs.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+import copy
+import json
+
+from pathlib import Path
+
+SIZE = [384, 384, 384]
+
+with (Path(__file__).parent.parent / "templates" / "strong-booster.json").open(encoding="utf8") as f:
+    template = json.load(f)
+
+configs = [
+    [  1,  1,  1],
+    [  1,  1,  2],
+    [  1,  2,  2],
+    [  2,  2,  2],
+    [  2,  2,  4],
+    [  2,  4,  4],
+    [  4,  4,  4],
+    [  4,  4,  8],
+]
+
+out_path = Path(__file__).parent.parent / "generated" / "config"
+
+for c in configs:
+    nc = copy.deepcopy(template)
+    nc["Geometry"]["blockcount"] = c
+    nc["Geometry"]["blocksize"] = [bs // bc for bc, bs in zip(c, SIZE)]
+
+    nc_out_path = out_path / f"strong-booster-{c[0]:02}-{c[1]:02}-{c[2]:02}.json"
+    print(f"Dumping {(c[0] * c[1] * c[2])} to {nc_out_path}")
+    with nc_out_path.open("w", encoding="utf8") as f:
+        json.dump(nc, f)

experiments/eval/scripts/generate-strong-cpu-configs.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+
+import copy
+import json
+
+from pathlib import Path
+
+SIZE = [384, 384, 384]
+
+with (Path(__file__).parent.parent / "templates" / "strong-cpu.json").open(encoding="utf8") as f:
+    template = json.load(f)
+
+configs = [
+    [  4,  4,  3],
+    [  4,  4,  6],
+    [  4,  4, 12],
+    [  4,  8, 12],
+    [  8,  8, 12],
+    [  8,  8, 24],
+    [  8, 16, 24],
+    [ 16, 16, 24],
+    [ 16, 16, 48]
+]
+
+out_path = Path(__file__).parent.parent / "generated" / "config"
+
+for c in configs:
+    nc = copy.deepcopy(template)
+    nc["Geometry"]["blockcount"] = c
+    nc["Geometry"]["blocksize"] = [bs // bc for bc, bs in zip(c, SIZE)]
+
+    nc_out_path = out_path / f"strong-cpu-{c[0]:02}-{c[1]:02}-{c[2]:02}.json"
+    print(f"Dumping {(c[0] * c[1] * c[2]) // 48} to {nc_out_path}")
+    with nc_out_path.open("w", encoding="utf8") as f:
+        json.dump(nc, f)

experiments/eval/scripts/generate-strong-gpu-configs.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+import copy
+import json
+
+from pathlib import Path
+
+SIZE = [384, 384, 384]
+
+with (Path(__file__).parent.parent / "templates" / "strong-gpu.json").open(encoding="utf8") as f:
+    template = json.load(f)
+
+configs = [
+    [  1,  1,  1],
+    [  1,  1,  2],
+    [  1,  2,  2],
+    [  2,  2,  2],
+    [  2,  2,  4],
+    [  2,  4,  4],
+    [  4,  4,  4],
+    [  4,  4,  8],
+]
+
+out_path = Path(__file__).parent.parent / "generated" / "config"
+
+for c in configs:
+    nc = copy.deepcopy(template)
+    nc["Geometry"]["blockcount"] = c
+    nc["Geometry"]["blocksize"] = [bs // bc for bc, bs in zip(c, SIZE)]
+
+    nc_out_path = out_path / f"strong-gpu-{c[0]:02}-{c[1]:02}-{c[2]:02}.json"
+    print(f"Dumping {(c[0] * c[1] * c[2])} to {nc_out_path}")
+    with nc_out_path.open("w", encoding="utf8") as f:
+        json.dump(nc, f)

experiments/eval/scripts/generate-weak-configs.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python
+
+
+import jinja2
+import json
+import sys
+
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple
+
+
+SIZE = (192, 192, 192)
+
+
+templates_env = jinja2.Environment(
+    loader=jinja2.FileSystemLoader(Path(__file__).parent.parent / "templates"),
+    autoescape=jinja2.select_autoescape()
+)
+        
+
+@dataclass
+class Experiment:
+    job_name: str
+    account: str
+    partition: str
+    nastja_binary_path: str
+    nodes: int
+    tasks: int
+    num_blocks: Tuple[int, int, int]
+    domain_scale: Tuple[int, int, int]
+    time: str = "00:15:00"
+    extra_sbatch_line: str = ""
+    logfile_path: str = "/p/project/cellsinsilico/paulslustigebude/ma/experiments/eval/logs/%x-%A.%a"
+    config_path: str = "/p/project/cellsinsilico/paulslustigebude/ma/experiments/eval/generated/config/${SLURM_JOB_NAME}.json"
+    output_dir_path: str = "/p/scratch/cellsinsilico/paul/nastja-out/${SLURM_JOB_NAME}-${SLURM_ARRAY_JOB_ID}.${SLURM_ARRAY_TASK_ID}"
+
+    def get_config(self):
+        with (Path(__file__).parent.parent / "templates" / "weak.json").open(encoding="utf8") as f:
+            config = json.load(f)
+
+        size = (
+            SIZE[0] * self.domain_scale[0],
+            SIZE[1] * self.domain_scale[1],
+            SIZE[2] * self.domain_scale[2],
+        )
+        blocksize = (
+            size[0] // self.num_blocks[0],
+            size[1] // self.num_blocks[1],
+            size[2] // self.num_blocks[2],
+        )
+        config["Geometry"] = {
+            "blockcount": list(self.num_blocks),
+            "blocksize": list(blocksize),
+        }
+
+        cells_filling = [{
+            "box": [
+                [0, 0, 0],
+                list(size)
+            ],
+            "celltype": 0,
+            "component": 0,
+            "pattern": "const",
+            "seed": 0,
+            "shape": "cube",
+            "value": 0,
+        }]
+        for z in range(self.domain_scale[2]):
+            for y in range(self.domain_scale[1]):
+                for x in range(self.domain_scale[0]):
+                    cx = x * SIZE[0] + SIZE[0] // 2
+                    cy = y * SIZE[1] + SIZE[1] // 2
+                    cz = z * SIZE[2] + SIZE[2] // 2
+                    cells_filling.append({
+                        "shape": "sphere",
+                        "pattern": "voronoi",
+                        "count": 715,
+                        "radius": 38,
+                        "center": [cx, cy, cz],
+                        "box": [
+                            [cx - 38, cy - 38, cz - 38],
+                            [cx + 38, cy + 38, cz + 38]
+                        ],
+                        "celltype": 9,
+                        "seed": 758960,
+                    })
+
+        config["Filling"]["cells"] = cells_filling
+
+        return config
+    
+    def write_batch_file(self, out_path: Path):
+        t = templates_env.get_template("strong-batch.j2")
+        t.stream(
+            name=self.job_name,
+            account=self.account,
+            partition=self.partition,
+            nodes=self.nodes,
+            tasks=self.tasks,
+            extra_sbatch_line=self.extra_sbatch_line,
+            time=self.time,
+            logfile_path=self.logfile_path,
+            nastja_binary_path=self.nastja_binary_path,
+            config_path=self.config_path,
+            output_dir_path=self.output_dir_path,
+        ).dump(str(out_path))
+
+
+def make_cpu_ex(x: int, y: int, z: int) -> Experiment:
+    num_blocks = x * y * z
+    assert num_blocks % 48 == 0
+    num_nodes = num_blocks // 48
+
+    assert x % 4 == 0
+    assert y % 4 == 0
+    assert z % 3 == 0
+
+    return Experiment(
+        job_name=f"weak-cpu-{x:02}-{y:02}-{z:02}",
+        account="cellsinsilico",
+        partition="batch",
+        nastja_binary_path="/p/project/cellsinsilico/paulslustigebude/nastja/build-nocuda/nastja",
+        nodes=num_nodes,
+        tasks=num_blocks,
+        num_blocks=(x, y, z),
+        domain_scale=(x // 4, y // 4, z // 3),
+    )
+
+
+def make_gpu_ex(x: int, y: int, z: int) -> Experiment:
+    num_blocks = x * y * z
+    gpus_per_node = num_blocks if num_blocks <= 4 else 4
+    num_nodes = 1 if num_blocks <= 4 else num_blocks // 4
+
+    return Experiment(
+        job_name=f"weak-gpu-{x:02}-{y:02}-{z:02}",
+        account="cellsinsilico",
+        partition="gpus",
+        extra_sbatch_line=f"#SBATCH --gres=gpu:{gpus_per_node}",
+        nastja_binary_path="/p/project/cellsinsilico/paulslustigebude/nastja/build-cuda/nastja",
+        nodes=num_nodes,
+        tasks=num_blocks,
+        num_blocks=(x, y, z),
+        domain_scale=(x, y, z),
+    )
+
+
+def make_booster_ex(x: int, y: int, z: int) -> Experiment:
+    num_blocks = x * y * z
+    gpus_per_node = num_blocks if num_blocks <= 4 else 4
+    num_nodes = 1 if num_blocks <= 4 else num_blocks // 4
+
+    return Experiment(
+        job_name=f"weak-booster-{x:02}-{y:02}-{z:02}",
+        account="hkf6",
+        partition="booster",
+        extra_sbatch_line=f"#SBATCH --gres=gpu:{gpus_per_node}",
+        nastja_binary_path="/p/project/cellsinsilico/paulslustigebude/nastja/build-cuda/nastja",
+        nodes=num_nodes,
+        tasks=num_blocks,
+        num_blocks=(x, y, z),
+        domain_scale=(x, y, z),
+    )
+
+
+experiments = [
+    make_cpu_ex(4, 4, 3),
+    make_cpu_ex(4, 4, 6),
+    make_cpu_ex(4, 4, 12),
+    make_cpu_ex(4, 8, 12),
+    make_cpu_ex(8, 8, 12),
+    make_cpu_ex(8, 8, 24),
+    make_cpu_ex(8, 16, 24),
+    make_cpu_ex(16, 16, 24),
+    make_cpu_ex(16, 16, 48),
+
+    make_gpu_ex(1, 1, 1),
+    make_gpu_ex(1, 1, 2),
+    make_gpu_ex(1, 2, 2),
+    make_gpu_ex(2, 2, 2),
+    make_gpu_ex(2, 2, 4),
+    make_gpu_ex(2, 4, 4),
+    make_gpu_ex(4, 4, 4),
+    make_gpu_ex(4, 4, 8),
+
+    make_booster_ex(1, 1, 1),
+    make_booster_ex(1, 1, 2),
+    make_booster_ex(1, 2, 2),
+    make_booster_ex(2, 2, 2),
+    make_booster_ex(2, 2, 4),
+    make_booster_ex(2, 4, 4),
+    make_booster_ex(4, 4, 4),
+    make_booster_ex(4, 4, 8),
+]
+
+if __name__ == "__main__":
+    outdir = Path(__file__).parent.parent / "generated"
+
+    for e in experiments:
+        print(f"Generating config for {e.job_name}", file=sys.stderr)
+        config_path = (outdir / "config" / e.job_name).with_suffix(".json")
+        with config_path.open("w", encoding="utf8") as f:
+            json.dump(e.get_config(), f, indent=2)
+        print(f"Generating batch file for {e.job_name}", file=sys.stderr)
+        e.write_batch_file(outdir / "batch" / e.job_name)

experiments/eval/scripts/make-latex-table.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+
+
+import argparse
+import pandas
+
+
+def show_seconds(s: float) -> str:
+    return f"{s:.2f}s"
+
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser(description="Make a latex table from a timings tsv")
+    p.add_argument("timingfile")
+    p.add_argument("--weak", action="store_true")
+    args = p.parse_args()
+
+    df = pandas.read_csv(args.timingfile, sep="\t")
+
+    for i in range(len(df)):
+        if not args.weak:
+            print(f"{df['nodes'][i]} & {df['tasks'][i]} & {show_seconds(df['mean_time'][i])} & {show_seconds(df['std_time'][i])} & {df['speedup'][i]:.02f} & {df['speedup_error'][i]:.02f} \\\\")
+        else:
+            print(f"{df['nodes'][i]} & {df['tasks'][i]} & {show_seconds(df['mean_time'][i])} & {show_seconds(df['std_time'][i])} & {df['efficiency'][i]:.02f} & {df['efficiency_error'][i]:.02f} \\\\")

experiments/eval/scripts/substitute.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+
+import jinja2
+import json
+import sys
+
+from pathlib import Path
+
+data = json.load(sys.stdin)
+
+templates_env = jinja2.Environment(
+    loader=jinja2.FileSystemLoader(Path(__file__).parent.parent / "templates"),
+    autoescape=jinja2.select_autoescape()
+)
+
+for possibly_incomplete_batch in data["batches"]:
+    batch = dict(list(data["common"].items()) + list(possibly_incomplete_batch.items()))
+    out_path = Path(__file__).parent.parent / "generated" / "batch" / batch["name"]
+    t = templates_env.get_template(sys.argv[1])
+    print(f"Dumping to {out_path}")
+    t.stream(**batch).dump(str(out_path))

experiments/eval/scripts/timing-actions.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+
+
+import argparse
+import sys
+
+
+import timing
+
+
+ignore = ["TimeStep"]
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser()
+    p.add_argument("jobs", nargs="+")
+    p.add_argument("--normalize", action="store_true")
+    p.add_argument("--extra-columns", nargs="*")
+    args = p.parse_args()
+
+    columns = [
+        "BC:cells",
+        "BC:dynamicecm",
+        "Sweep:Cells",
+        "Sweep:DynamicECM",
+        "Sweep:DynamicECMDampers",
+    ] + (args.extra_columns or [])
+
+    dfs = dict()
+    labels = []
+    for label, jobid in [jobarg.split(":") for jobarg in args.jobs]:
+        jobs, excluded_array_indices = timing.get_jobs(jobid)
+        df = timing.load_array_mean_timings(jobid, excluded_array_indices).mean()
+        dfs[label] = df
+        labels.extend(df.index)
+
+    labels = set(labels)
+    print(",".join(["label"] + columns + ["Other"]))
+
+    values_by_label = dict()
+    for label, df in dfs.items():
+        values = {"Other": 0}
+        for c in df.index:
+            if c in ignore:
+                continue
+            elif c not in columns:
+                values["Other"] += df[c]
+                print(f"Others+= {c}={df[c]}", file=sys.stderr)
+            else:
+                values[c] = df[c]
+        values_by_label[label] = values
+
+    if args.normalize:
+        print("Normalizing data to 100%...", file=sys.stderr)
+        for values in values_by_label.values():
+            row_length = sum(values.values())
+            for c in values.keys():
+                values[c] *= 100 / row_length
+
+    for label, values in values_by_label.items():
+        print(label + "," + ",".join(f"{values[c]}" for c in columns + ["Other"]))

experiments/eval/scripts/timing.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+
+
+import argparse
+import json
+import pandas
+import subprocess
+import sys
+
+
+from pathlib import Path
+
+
+def load_timing_file(timing_path: Path):
+    df = pandas.read_csv(timing_path, delim_whitespace=True)
+    headers = list(df["#Name"][1:])
+    times = list(df["TotalTime"][1:])
+    return pandas.DataFrame([times], columns=headers)
+
+
+def load_all_timings(outdir_path: Path):
+    timingdir_path = outdir_path / "timing"
+    timing_paths = sorted(timingdir_path.iterdir())
+
+    print(f"Loading {len(timing_paths)} timing files from {timingdir_path}...", file=sys.stderr)
+    dfs = []
+    for i, timing_path in enumerate(timing_paths, 1):
+        dfs.append(load_timing_file(timing_path))
+        sys.stderr.write("\x1b[1K\r")
+        sys.stderr.flush()
+        print(f"[{i:8}/{len(timing_paths):8}] {i/len(timing_paths)*100:6.2f}%", file=sys.stderr, end="", flush=True)
+    print(file=sys.stderr, flush=True)
+
+    return pandas.concat(dfs)
+
+
+def load_mean_timings(outdir_path: Path):
+    df = load_all_timings(outdir_path)
+    return df.mean() / 1000000
+
+
+def get_outdirs(jobid: str):
+    print(f"Globbing for {jobid}...", file=sys.stderr)
+    return sorted(Path("/p/scratch/cellsinsilico/paul/nastja-out").glob(f"*{jobid}*"))
+
+
+def load_array_mean_timings(jobid: str, excluded_array_indices):
+    mts = []
+    for outdir_path in get_outdirs(jobid):
+        if any(str(outdir_path).endswith(str(i)) for i in excluded_array_indices):
+            print(f"Not loading timings for {outdir_path} because it was excluded.", file=sys.stderr)
+            continue
+        mts.append(load_mean_timings(outdir_path))
+
+    return pandas.DataFrame(list(mts), columns=mts[0].index)
+
+
+def get_mean_mean_totaltimes(jobid: str):
+    return load_array_mean_timings(jobid).mean()
+
+
+def get_std_mean_totaltimes(jobid: str):
+    return load_array_mean_timings(jobid).std()
+
+
+def get_accounting_data(jobid: str):
+    sacct_results = subprocess.run(
+        ["sacct", "--json", "--jobs", jobid],
+        check=True, # Throw on non-zero exit code,
+        capture_output=True
+    )
+    return json.loads(sacct_results.stdout.decode("utf8"))
+
+
+def get_jobs(jobid: str):
+    accounting_data = get_accounting_data(jobid)
+    jobs = []
+    excluded_array_indices = []
+    for array_job in accounting_data["jobs"]:
+        # Get metadata related to array
+        array_main_job = array_job["array"]["job_id"]
+        array_index = array_job["array"]["task_id"]
+        # The last step is the actual job we want the data for
+        # The steps before set up cluster etc.
+        last_step = array_job["steps"][-1]
+        if last_step["state"] != "COMPLETED":
+            print(f"WARNING: {array_main_job}.{array_index} has state {last_step['state']}, excluding it from measurements", file=sys.stderr)
+            excluded_array_indices.append(array_index)
+            continue
+        jobs.append(last_step)
+
+    return jobs, excluded_array_indices
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(description="Load and analzye data from nastja timing files")
+    p.add_argument("jobid", nargs="+")
+    p.add_argument("--prettify", action="store_true")
+    p.add_argument("--dump-timings", action="store_true")
+    args = p.parse_args()
+
+    results = []
+    for i, jobid in enumerate(args.jobid, 1):
+        print(f"({i:2}/{len(args.jobid):2}) Loading accounting data for {jobid}", file=sys.stderr)
+        jobs, excluded_array_indices = get_jobs(jobid)
+        array_mean_timings = load_array_mean_timings(jobid, excluded_array_indices)
+        if args.dump_timings:
+            print(array_mean_timings, file=sys.stderr)
+
+        results.append({
+            "jobid": jobid,
+            "means": array_mean_timings.mean().to_dict(),
+            "stds": array_mean_timings.std().to_dict(),
+            "accounting": jobs
+        })
+    print(json.dumps(results, indent=2 if args.prettify else None))

experiments/eval/strong-booster.json

@@ -0,0 +1,63 @@
+{
+  "common": {
+    "account": "hkf6",
+    "partition": "booster",
+    "extra_sbatch_line": "#SBATCH --gres=gpu:4",
+    "logfile_path": "/p/project/cellsinsilico/paulslustigebude/ma/experiments/eval/logs/%x-%A.%a",
+    "nastja_binary_path": "/p/project/cellsinsilico/paulslustigebude/nastja/build-cuda/nastja",
+    "config_path": "/p/project/cellsinsilico/paulslustigebude/ma/experiments/eval/generated/config/${SLURM_JOB_NAME}.json",
+    "output_dir_path": "/p/scratch/cellsinsilico/paul/nastja-out/${SLURM_JOB_NAME}-${SLURM_ARRAY_JOB_ID}.${SLURM_ARRAY_TASK_ID}"
+  },
+  "batches": [
+    {
+      "name": "strong-booster-01-01-01",
+      "nodes": 1,
+      "tasks": 1,
+      "time": "00:15:00",
+      "extra_sbatch_line": "#SBATCH --gres=gpu:1"
+    },
+    {
+      "name": "strong-booster-01-01-02",
+      "nodes": 1,
+      "tasks": 2,
+      "time": "00:15:00",
+      "extra_sbatch_line": "#SBATCH --gres=gpu:2"
+    },
+    {
+      "name": "strong-booster-01-02-02",
+      "nodes": 1,
+      "tasks": 4,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-booster-02-02-02",
+      "nodes": 2,
+      "tasks": 8,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-booster-02-02-04",
+      "nodes": 4,
+      "tasks": 16,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-booster-02-04-04",
+      "nodes": 8,
+      "tasks": 32,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-booster-04-04-04",
+      "nodes": 16,
+      "tasks": 64,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-booster-04-04-08",
+      "nodes": 32,
+      "tasks": 128,
+      "time": "00:15:00"
+    }
+  ]
+}

experiments/eval/strong-cpu.json

@@ -0,0 +1,67 @@
+{
+  "common": {
+    "account": "cellsinsilico",
+    "partition": "batch",
+    "extra_sbatch_line": "",
+    "logfile_path": "/p/project/cellsinsilico/paulslustigebude/ma/experiments/eval/logs/%x-%A.%a",
+    "nastja_binary_path": "/p/project/cellsinsilico/paulslustigebude/nastja/build-nocuda/nastja",
+    "config_path": "/p/project/cellsinsilico/paulslustigebude/ma/experiments/eval/generated/config/${SLURM_JOB_NAME}.json",
+    "output_dir_path": "/p/scratch/cellsinsilico/paul/nastja-out/${SLURM_JOB_NAME}-${SLURM_ARRAY_JOB_ID}.${SLURM_ARRAY_TASK_ID}"
+  },
+  "batches": [
+    {
+      "name": "strong-cpu-04-04-03",
+      "nodes": 1,
+      "tasks": 48,
+      "time": "01:00:00"
+    },
+    {
+      "name": "strong-cpu-04-04-06",
+      "nodes": 2,
+      "tasks": 96,
+      "time": "01:00:00"
+    },
+    {
+      "name": "strong-cpu-04-04-12",
+      "nodes": 4,
+      "tasks": 192,
+      "time": "00:20:00"
+    },
+    {
+      "name": "strong-cpu-04-08-12",
+      "nodes": 8,
+      "tasks": 384,
+      "time": "00:10:00"
+    },
+    {
+      "name": "strong-cpu-08-08-12",
+      "nodes": 16,
+      "tasks": 768,
+      "time": "00:10:00"
+    },
+    {
+      "name": "strong-cpu-08-08-24",
+      "nodes": 32,
+      "tasks": 1536,
+      "time": "00:10:00"
+    },
+    {
+      "name": "strong-cpu-08-16-24",
+      "nodes": 64,
+      "tasks": 3072,
+      "time": "00:10:00"
+    },
+    {
+      "name": "strong-cpu-16-16-24",
+      "nodes": 128,
+      "tasks": 6144,
+      "time": "00:10:00"
+    },
+    {
+      "name": "strong-cpu-16-16-48",
+      "nodes": 256,
+      "tasks": 12288,
+      "time": "00:10:00"
+    }
+  ]
+}

experiments/eval/strong-gpu.json

@@ -0,0 +1,63 @@
+{
+  "common": {
+    "account": "cellsinsilico",
+    "partition": "gpus",
+    "extra_sbatch_line": "#SBATCH --gres=gpu:4",
+    "logfile_path": "/p/project/cellsinsilico/paulslustigebude/ma/experiments/eval/logs/%x-%A.%a",
+    "nastja_binary_path": "/p/project/cellsinsilico/paulslustigebude/nastja/build-cuda/nastja",
+    "config_path": "/p/project/cellsinsilico/paulslustigebude/ma/experiments/eval/generated/config/${SLURM_JOB_NAME}.json",
+    "output_dir_path": "/p/scratch/cellsinsilico/paul/nastja-out/${SLURM_JOB_NAME}-${SLURM_ARRAY_JOB_ID}.${SLURM_ARRAY_TASK_ID}"
+  },
+  "batches": [
+    {
+      "name": "strong-gpu-01-01-01",
+      "nodes": 1,
+      "tasks": 1,
+      "time": "00:15:00",
+      "extra_sbatch_line": "#SBATCH --gres=gpu:1"
+    },
+    {
+      "name": "strong-gpu-01-01-02",
+      "nodes": 1,
+      "tasks": 2,
+      "time": "00:15:00",
+      "extra_sbatch_line": "#SBATCH --gres=gpu:2"
+    },
+    {
+      "name": "strong-gpu-01-02-02",
+      "nodes": 1,
+      "tasks": 4,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-gpu-02-02-02",
+      "nodes": 2,
+      "tasks": 8,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-gpu-02-02-04",
+      "nodes": 4,
+      "tasks": 16,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-gpu-02-04-04",
+      "nodes": 8,
+      "tasks": 32,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-gpu-04-04-04",
+      "nodes": 16,
+      "tasks": 64,
+      "time": "00:15:00"
+    },
+    {
+      "name": "strong-gpu-04-04-08",
+      "nodes": 32,
+      "tasks": 128,
+      "time": "00:15:00"
+    }
+  ]
+}

experiments/eval/templates/strong-batch.j2

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+
+#SBATCH --job-name={{ name }}
+#SBATCH --account={{ account }}
+#SBATCH --partition={{ partition }}
+#SBATCH --nodes={{ nodes }}
+#SBATCH --ntasks={{ tasks }}
+# Counted per node
+{{ extra_sbatch_line }}
+#SBATCH --time={{ time }}
+#SBATCH --output={{ logfile_path }}
+#SBATCH --error={{ logfile_path }}
+#SBATCH --array=1-5
+
+NASTJA_BINARY="{{ nastja_binary_path }}"
+CONFIG_FILE="{{ config_path }}"
+OUTPUT_DIR="{{ output_dir_path }}"
+module load Stages/2024 GCC/12.3.0 ParaStationMPI/5.9.2-1 CMake/3.26.3 mold/1.11.0 jq/1.6 git Python
+
+echo "${NASTJA_BINARY_PATH}"
+echo "${CONFIG_FILE}"
+echo "${OUTPUT_DIR}"
+
+cat "${CONFIG_FILE}"
+
+mkdir -p "${OUTPUT_DIR}"
+
+srun "${NASTJA_BINARY}" \
+  -c "${CONFIG_FILE}" \
+  -o "${OUTPUT_DIR}"
+

experiments/eval/templates/strong-booster.json

@@ -0,0 +1,263 @@
+{
+  "Application": "Cells",
+  "CellsInSilico": {
+    "2D": false,
+    "adhesion": {
+      "matrix": [
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 450.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 450.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0]
+      ],
+      "polarityenabled": false
+    },
+    "centerofmass": {
+      "steps": 1
+    },
+    "cleaner": {
+      "killdistance": 0,
+      "steps": 100
+    },
+    "contactinhibition": {
+      "enabled": false
+    },
+    "division": {
+      "condition": [
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "( volume >= 0.9 * volume0 )  & ( rnd() <= 0.00001 ) & generation < 1"
+      ],
+      "enabled": true,
+      "halveSignals": false
+    },
+    "dynamicecm": {
+      "alpha": 2.0,
+      "beta": 0.5,
+      "c": 4.0,
+      "deltat": 0.10000000149011612,
+      "ecmCellID": 0,
+      "enabled": true,
+      "eta": 0.25,
+      "k0": 0.10000000149011612,
+      "k1": 0.10000000149011612,
+      "lambda": 10.0,
+      "phi": 1.0,
+      "pushSteps": 10,
+      "pushWeight": 0.5,
+      "stepsPerMcs": 100
+    },
+    "ecmdegradation": {
+      "enabled": false
+    },
+    "energyfunctions": [
+      "Volume00",
+      "Surface01",
+      "Motility00",
+      "Adhesion01",
+      "DynamicECM00"
+    ],
+    "liquid": 6,
+    "logcellproperties": {
+      "enabled": false
+    },
+    "orientation": {
+      "enabled": true,
+      "motility": "persistentRandomWalk",
+      "motilityamount": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "numRandomNumbers": 5,
+      "persistenceMagnitude": 0.0,
+      "persistentDecay": 0.8,
+      "recalculationtime": 200
+    },
+    "polarity": {
+      "enabled": false
+    },
+    "signaling": {
+      "constant": false,
+      "enabled": false
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 400.0
+      },
+      "lambda": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        5.625,
+        5.625,
+        1.0
+      ],
+      "sizechange": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        -0.05,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ]
+    },
+    "temperature": 50.0,
+    "visitor": {
+      "checkerboard": "01",
+      "stepwidth": 10
+    },
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 500.0
+      },
+      "lambda": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        7.5,
+        7.5,
+        7.5
+      ],
+      "sizechange": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        -0.05,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ]
+    }
+  },
+  "DefineFunctions": [
+    "r_angle()=360*rnd()",
+    "r_size()=400*rnd()"
+  ],
+  "Filling": {
+    "cells": [
+      {
+        "box": [
+          [
+            0,
+            0,
+            0
+          ],
+          [
+            384,
+            384,
+            384
+          ]
+        ],
+        "celltype": 0,
+        "component": 0,
+        "pattern": "const",
+        "seed": 0,
+        "shape": "cube",
+        "value": 0
+      },
+      {
+        "box": [
+          [117, 117, 177],
+          [267, 267, 267]
+        ],
+        "celltype": 9,
+        "center": [192, 192, 192],
+        "component": 0,
+        "count": 5500,
+        "pattern": "voronoi",
+        "radius": 75,
+        "seed": 758960,
+        "shape": "sphere",
+        "value": 8
+      }
+    ],
+    "initialoutput": false,
+    "randomseed": 758959
+  },
+  "Geometry": {
+    "blockcount": [
+      4,
+      4,
+      3
+    ],
+    "blockdefault": "fill",
+    "blocksize": [
+      96,
+      96,
+      128
+    ],
+    "blocktype": [
+      [
+        [
+          1
+        ]
+      ]
+    ]
+  },
+  "Settings": {
+    "deltat": 1.0,
+    "deltax": 1.0,
+    "handleFPE": "signal",
+    "logger": {
+      "group": 0,
+      "steps": 100
+    },
+    "randomseed": 42,
+    "statusoutput": 1,
+    "timestepguard": 1,
+    "timesteps": 10,
+    "cuda": {
+      "subblocks": {
+        "blockDim": [8, 8, 8]
+      }
+    }
+  }
+}

experiments/eval/templates/strong-cpu.json

@@ -0,0 +1,258 @@
+{
+  "Application": "Cells",
+  "CellsInSilico": {
+    "2D": false,
+    "adhesion": {
+      "matrix": [
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 450.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 450.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0]
+      ],
+      "polarityenabled": false
+    },
+    "centerofmass": {
+      "steps": 1
+    },
+    "cleaner": {
+      "killdistance": 0,
+      "steps": 100
+    },
+    "contactinhibition": {
+      "enabled": false
+    },
+    "division": {
+      "condition": [
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "( volume >= 0.9 * volume0 )  & ( rnd() <= 0.00001 ) & generation < 1"
+      ],
+      "enabled": true,
+      "halveSignals": false
+    },
+    "dynamicecm": {
+      "alpha": 2.0,
+      "beta": 0.5,
+      "c": 4.0,
+      "deltat": 0.10000000149011612,
+      "ecmCellID": 0,
+      "enabled": true,
+      "eta": 0.25,
+      "k0": 0.10000000149011612,
+      "k1": 0.10000000149011612,
+      "lambda": 10.0,
+      "phi": 1.0,
+      "pushSteps": 10,
+      "pushWeight": 0.5,
+      "stepsPerMcs": 100
+    },
+    "ecmdegradation": {
+      "enabled": false
+    },
+    "energyfunctions": [
+      "Volume00",
+      "Surface01",
+      "Motility00",
+      "Adhesion01",
+      "DynamicECM00"
+    ],
+    "liquid": 6,
+    "logcellproperties": {
+      "enabled": false
+    },
+    "orientation": {
+      "enabled": true,
+      "motility": "persistentRandomWalk",
+      "motilityamount": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "numRandomNumbers": 5,
+      "persistenceMagnitude": 0.0,
+      "persistentDecay": 0.8,
+      "recalculationtime": 200
+    },
+    "polarity": {
+      "enabled": false
+    },
+    "signaling": {
+      "constant": false,
+      "enabled": false
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 400.0
+      },
+      "lambda": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        5.625,
+        5.625,
+        1.0
+      ],
+      "sizechange": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        -0.05,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ]
+    },
+    "temperature": 50.0,
+    "visitor": {
+      "checkerboard": "01",
+      "stepwidth": 10
+    },
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 500.0
+      },
+      "lambda": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        7.5,
+        7.5,
+        7.5
+      ],
+      "sizechange": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        -0.05,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ]
+    }
+  },
+  "DefineFunctions": [
+    "r_angle()=360*rnd()",
+    "r_size()=400*rnd()"
+  ],
+  "Filling": {
+    "cells": [
+      {
+        "box": [
+          [
+            0,
+            0,
+            0
+          ],
+          [
+            384,
+            384,
+            384
+          ]
+        ],
+        "celltype": 0,
+        "component": 0,
+        "pattern": "const",
+        "seed": 0,
+        "shape": "cube",
+        "value": 0
+      },
+      {
+        "box": [
+          [117, 117, 177],
+          [267, 267, 267]
+        ],
+        "celltype": 9,
+        "center": [192, 192, 192],
+        "component": 0,
+        "count": 5500,
+        "pattern": "voronoi",
+        "radius": 75,
+        "seed": 758960,
+        "shape": "sphere",
+        "value": 8
+      }
+    ],
+    "initialoutput": false,
+    "randomseed": 758959
+  },
+  "Geometry": {
+    "blockcount": [
+      4,
+      4,
+      3
+    ],
+    "blockdefault": "fill",
+    "blocksize": [
+      96,
+      96,
+      128
+    ],
+    "blocktype": [
+      [
+        [
+          1
+        ]
+      ]
+    ]
+  },
+  "Settings": {
+    "deltat": 1.0,
+    "deltax": 1.0,
+    "handleFPE": "signal",
+    "logger": {
+      "group": 0,
+      "steps": 100
+    },
+    "randomseed": 42,
+    "statusoutput": 1,
+    "timestepguard": 1,
+    "timesteps": 10
+  }
+}

experiments/eval/templates/strong-gpu.json

@@ -0,0 +1,263 @@
+{
+  "Application": "Cells",
+  "CellsInSilico": {
+    "2D": false,
+    "adhesion": {
+      "matrix": [
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 450.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 450.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0]
+      ],
+      "polarityenabled": false
+    },
+    "centerofmass": {
+      "steps": 1
+    },
+    "cleaner": {
+      "killdistance": 0,
+      "steps": 100
+    },
+    "contactinhibition": {
+      "enabled": false
+    },
+    "division": {
+      "condition": [
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "( volume >= 0.9 * volume0 )  & ( rnd() <= 0.00001 ) & generation < 1"
+      ],
+      "enabled": true,
+      "halveSignals": false
+    },
+    "dynamicecm": {
+      "alpha": 2.0,
+      "beta": 0.5,
+      "c": 4.0,
+      "deltat": 0.10000000149011612,
+      "ecmCellID": 0,
+      "enabled": true,
+      "eta": 0.25,
+      "k0": 0.10000000149011612,
+      "k1": 0.10000000149011612,
+      "lambda": 10.0,
+      "phi": 1.0,
+      "pushSteps": 10,
+      "pushWeight": 0.5,
+      "stepsPerMcs": 100
+    },
+    "ecmdegradation": {
+      "enabled": false
+    },
+    "energyfunctions": [
+      "Volume00",
+      "Surface01",
+      "Motility00",
+      "Adhesion01",
+      "DynamicECM00"
+    ],
+    "liquid": 6,
+    "logcellproperties": {
+      "enabled": false
+    },
+    "orientation": {
+      "enabled": true,
+      "motility": "persistentRandomWalk",
+      "motilityamount": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "numRandomNumbers": 5,
+      "persistenceMagnitude": 0.0,
+      "persistentDecay": 0.8,
+      "recalculationtime": 200
+    },
+    "polarity": {
+      "enabled": false
+    },
+    "signaling": {
+      "constant": false,
+      "enabled": false
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 400.0
+      },
+      "lambda": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        5.625,
+        5.625,
+        1.0
+      ],
+      "sizechange": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        -0.05,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ]
+    },
+    "temperature": 50.0,
+    "visitor": {
+      "checkerboard": "01",
+      "stepwidth": 10
+    },
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 500.0
+      },
+      "lambda": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        7.5,
+        7.5,
+        7.5
+      ],
+      "sizechange": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        -0.05,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ]
+    }
+  },
+  "DefineFunctions": [
+    "r_angle()=360*rnd()",
+    "r_size()=400*rnd()"
+  ],
+  "Filling": {
+    "cells": [
+      {
+        "box": [
+          [
+            0,
+            0,
+            0
+          ],
+          [
+            384,
+            384,
+            384
+          ]
+        ],
+        "celltype": 0,
+        "component": 0,
+        "pattern": "const",
+        "seed": 0,
+        "shape": "cube",
+        "value": 0
+      },
+      {
+        "box": [
+          [117, 117, 177],
+          [267, 267, 267]
+        ],
+        "celltype": 9,
+        "center": [192, 192, 192],
+        "component": 0,
+        "count": 5500,
+        "pattern": "voronoi",
+        "radius": 75,
+        "seed": 758960,
+        "shape": "sphere",
+        "value": 8
+      }
+    ],
+    "initialoutput": false,
+    "randomseed": 758959
+  },
+  "Geometry": {
+    "blockcount": [
+      4,
+      4,
+      3
+    ],
+    "blockdefault": "fill",
+    "blocksize": [
+      96,
+      96,
+      128
+    ],
+    "blocktype": [
+      [
+        [
+          1
+        ]
+      ]
+    ]
+  },
+  "Settings": {
+    "deltat": 1.0,
+    "deltax": 1.0,
+    "handleFPE": "signal",
+    "logger": {
+      "group": 0,
+      "steps": 100
+    },
+    "randomseed": 42,
+    "statusoutput": 1,
+    "timestepguard": 1,
+    "timesteps": 10,
+    "cuda": {
+      "subblocks": {
+        "blockDim": [8, 8, 8]
+      }
+    }
+  }
+}

experiments/eval/templates/weak.json

@@ -0,0 +1,193 @@
+{
+  "Application": "Cells",
+  "CellsInSilico": {
+    "2D": false,
+    "adhesion": {
+      "matrix": [
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 450.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        [0.0, 450.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0]
+      ],
+      "polarityenabled": false
+    },
+    "centerofmass": {
+      "steps": 1
+    },
+    "cleaner": {
+      "killdistance": 0,
+      "steps": 100
+    },
+    "contactinhibition": {
+      "enabled": false
+    },
+    "division": {
+      "condition": [
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "( volume >= 0.9 * volume0 )  & ( rnd() <= 0.00001 ) & generation < 1"
+      ],
+      "enabled": true,
+      "halveSignals": false
+    },
+    "dynamicecm": {
+      "alpha": 2.0,
+      "beta": 0.5,
+      "c": 4.0,
+      "deltat": 0.1,
+      "ecmCellID": 0,
+      "enabled": true,
+      "eta": 0.25,
+      "k0": 0.1,
+      "k1": 0.1,
+      "lambda": 10.0,
+      "phi": 1.0,
+      "pushSteps": 10,
+      "pushWeight": 0.5,
+      "stepsPerMcs": 100
+    },
+    "ecmdegradation": {
+      "enabled": false
+    },
+    "energyfunctions": [
+      "Volume00",
+      "Surface01",
+      "Motility00",
+      "Adhesion01",
+      "DynamicECM00"
+    ],
+    "liquid": 6,
+    "logcellproperties": {
+      "enabled": false
+    },
+    "orientation": {
+      "enabled": true,
+      "motility": "persistentRandomWalk",
+      "motilityamount": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      "numRandomNumbers": 5,
+      "persistenceMagnitude": 0.0,
+      "persistentDecay": 0.8,
+      "recalculationtime": 200
+    },
+    "polarity": {
+      "enabled": false
+    },
+    "signaling": {
+      "constant": false,
+      "enabled": false
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 400.0
+      },
+      "lambda": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        5.625,
+        5.625,
+        1.0
+      ],
+      "sizechange": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        -0.05,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ]
+    },
+    "temperature": 50.0,
+    "visitor": {
+      "checkerboard": "01",
+      "stepwidth": 10
+    },
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 500.0
+      },
+      "lambda": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        7.5,
+        7.5,
+        7.5
+      ],
+      "sizechange": [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        -0.05,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ]
+    }
+  },
+  "DefineFunctions": [
+    "r_angle()=360*rnd()",
+    "r_size()=400*rnd()"
+  ],
+  "Filling": {
+    "initialoutput": false,
+    "randomseed": 758959
+  },
+  "Settings": {
+    "randomseed": 42,
+    "statusoutput": 1,
+    "timesteps": 10
+  }
+}

experiments/requirements.txt

@@ -0,0 +1 @@
+click==8.1.7

experiments/scripts/gen/strong.py

@@ -0,0 +1,96 @@
+import copy
+import json
+
+from typing import Tuple
+
+from toolkit import Configuration
+
+SIZE_X = 400
+SIZE_Y = 400
+SIZE_Z = 400
+
+def make_config(gpus: int, blockcount: Tuple[int, int, int]) -> Configuration:
+    assert gpus % 4 == 0
+    assert SIZE_X % blockcount[0] == 0
+    assert SIZE_Y % blockcount[1] == 0
+    assert SIZE_Z % blockcount[2] == 0
+    assert blockcount[0] * blockcount[1] * blockcount[2] == gpus
+
+    return Configuration(
+        gpus // 4,
+        gpus,
+        4,
+        blockcount,
+        (SIZE_X // blockcount[0], SIZE_Y // blockcount[1], SIZE_Z // blockcount[2])
+    )
+
+configurations = [
+    Configuration(1, 1, 1, (1, 1, 1), (400, 400, 400)),
+    Configuration(1, 2, 2, (1, 1, 2), (400, 400, 200)),
+    Configuration(1, 2, 2, (1, 2, 1), (400, 200, 400)),
+    Configuration(1, 2, 2, (2, 1, 1), (200, 400, 400)),
+    make_config(4, (1, 1, 4)),
+    make_config(4, (1, 4, 1)),
+    make_config(4, (4, 1, 1)),
+    make_config(4, (1, 2, 2)),
+    make_config(4, (2, 1, 2)),
+    make_config(4, (2, 2, 1)),
+    make_config(8, (2, 2, 2)),
+    make_config(8, (1, 2, 4)),
+    make_config(16, (1, 4, 4)),
+    make_config(16, (2, 2, 4)),
+    make_config(32, (2, 4, 4)),
+    make_config(64, (4, 4, 4)),
+    make_config(128, (4, 4, 8)),
+    make_config(256, (4, 8, 8)),
+    make_config(512, (8, 8, 8)),
+    make_config(1024, (8, 8, 16)),
+    make_config(2048, (8, 16, 16))
+]
+
+with open("templates/spheroid.json") as template_file:
+    template = json.load(template_file)
+
+for c in configurations:
+    print(c)
+    assert(c.get_domain_size() == configurations[0].get_domain_size())
+
+    nastja_config = copy.deepcopy(template)
+
+    nastja_config["Geometry"]["blockcount"] = c.blockcount
+    nastja_config["Geometry"]["blocksize"] = c.blocksize
+
+    label = c.get_label()
+
+    with open(f"configs/measurements/strong/spheroid_{label}.json", "w") as config_file:
+        json.dump(nastja_config, config_file, indent=2)
+
+    batch_config = f"""#!/usr/bin/env bash
+
+#SBATCH --job-name=strong-{label}
+#SBATCH --account=hkf6
+#SBATCH --partition=booster
+#SBATCH --nodes={c.nodes}
+#SBATCH --ntasks={c.tasks}
+# Counted per node
+#SBATCH --gres=gpu:{c.gpus_per_node}
+#SBATCH --time=00:30:00
+#SBATCH --output=logs/strong-{label}-%A_%a.log
+#SBATCH --error=logs/strong-{label}-%A_%a.log
+#SBATCH --array=1-5
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR="/p/scratch/cellsinsilico/paul/nastja-out/strong-{label}-${{SLURM_ARRAY_TASK_ID}}"
+
+echo "outdir is ${{OUTPUT_DIR}}"
+
+mkdir -p "${{OUTPUT_DIR}}"
+source "${{SOURCE_DIR}}/activate-nastja-modules"
+
+srun --unbuffered "${{SOURCE_DIR}}/nastja/build-cuda/nastja" \\
+  -c "${{SOURCE_DIR}}/ma/experiments/configs/measurements/strong/spheroid_{label}.json" \\
+  -o "${{OUTPUT_DIR}}"
+"""
+
+    with open(f"batch/measurements/strong/strong-{label}", "w", encoding="utf8") as batch_config_file:
+        batch_config_file.write(batch_config)

experiments/scripts/gen/toolkit.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import Tuple
+
+@dataclass
+class Configuration:
+    nodes: int
+    tasks: int
+    gpus_per_node: int
+    blockcount: Tuple[int, int, int]
+    blocksize: Tuple[int, int, int]
+
+    def get_domain_size(self) -> int:
+        return self.blockcount[0] * self.blocksize[0] * self.blockcount[1] * self.blocksize[1] * self.blockcount[2] * self.blocksize[2]
+
+    def get_label(self) -> str:
+        return f"t{self.tasks:04}n{self.nodes:03}g{self.gpus_per_node}x{self.blockcount[0]}y{self.blockcount[1]}z{self.blockcount[2]}"

experiments/scripts/gen/varied_fillings.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+import json
+import sys
+
+from functools import reduce
+from operator import mul
+from pathlib import Path
+
+percent_filled = float(sys.argv[1])
+template_path = Path("templates/varied-fillings.json")
+
+initial_cell_size = 4200
+
+with template_path.open(encoding="utf-8") as template_file:
+    config = json.load(template_file)
+
+dims = [
+    size * count
+    for size, count
+    in zip(config["Geometry"]["blocksize"], config["Geometry"]["blockcount"])
+]
+total_volume = reduce(mul, dims, 1)
+target_volume = total_volume * percent_filled / 100
+n_cells = int(target_volume // initial_cell_size)
+# If n_cells is odd, second type gets one more cell
+n_cells_first_type = n_cells // 2
+n_cells_second_type = n_cells - n_cells_first_type
+edge_length = int(target_volume ** (1 / 3))
+offsets = [
+    (dims[0] - edge_length) // 2,
+    (dims[1] - edge_length) // 2,
+    (dims[2] - edge_length) // 2
+]
+
+print(f"Target volume: {target_volume} ({percent_filled}%, edge length: {edge_length}), # of cells: {n_cells}", file=sys.stderr)
+
+if target_volume > 0:
+    config["Filling"]["cells"].append({
+        "shape": "cube",
+        "pattern": "voronoi",
+        "box": [
+            offsets,
+            [
+                min(offsets[0] + edge_length, dims[0] - 1),
+                min(offsets[1] + edge_length, dims[1] - 1),
+                min(offsets[2] + edge_length, dims[2] - 1)
+            ]
+        ],
+        "count": n_cells,
+        "celltype": [0, 0, n_cells_first_type, n_cells_second_type]
+    })
+
+json.dump(config, sys.stdout, indent=2)

experiments/scripts/gen/weak.py

@@ -0,0 +1,107 @@
+import copy
+import json
+
+from dataclasses import dataclass
+
+configurations = [
+    (1, 1, 1),
+    (1, 1, 2),
+    (1, 2, 2),
+    (2, 2, 2),
+    (2, 2, 4),
+    (2, 4, 4),
+    (4, 4, 4),
+    (4, 4, 8),
+    (4, 8, 8),
+    (8, 8, 8)
+]
+
+with open("templates/spheroid_weak.json") as template_file:
+    template = json.load(template_file)
+
+SIZE_X = 400
+SIZE_Y = 400
+SIZE_Z = 400
+
+for bx, by, bz in configurations:
+    nastja_config = copy.deepcopy(template)
+    nastja_config["Geometry"]["blockcount"] = [bx, by, bz]
+    nastja_config["Geometry"]["blocksize"] = [SIZE_X, SIZE_Y, SIZE_Z]
+
+    # Fill the whole domain with ECM
+    cells_filling = [
+        {
+            "shape": "cube",
+            "box": [
+              [0, 0, 0],
+              [bx * SIZE_X, by * SIZE_Y, bz * SIZE_Z]
+            ],
+            "value": 0,
+            "celltype": 0
+        }
+    ]
+
+    # Place a bunch of cells in each block to keep each rank busy
+    for z in range(bz):
+        for y in range(by):
+            for x in range(bx):
+                sx = x * SIZE_X
+                sy = y * SIZE_Y
+                sz = z * SIZE_Z
+                cells_filling.append({
+                    "shape": "sphere",
+                    "pattern": "voronoi",
+                    "count": 5500,
+                    "radius": 75,
+                    "center": [sx + 200, sy + 200, sz + 200],
+                    "box": [
+                        [sx + 110, sy + 110, sz + 110],
+                        [sx + 290, sy + 290, sz + 290]
+                    ],
+                    "celltype": 9
+                })
+    nastja_config["Filling"]["cells"] = cells_filling
+
+    ntasks = bx * by * bz
+    if ntasks < 4:
+        nodes = 1
+        gpus_per_node = ntasks
+    else:
+        assert ntasks % 4 == 0
+        nodes = ntasks // 4
+        gpus_per_node = 4
+
+    label = f"weak400-t{ntasks:04}n{nodes:03}g{gpus_per_node}x{bx}y{by}z{bz}"
+
+    with open(f"configs/measurements/weak/spheroid_{label}.json", "w") as config_file:
+        json.dump(nastja_config, config_file, indent=2)
+
+    batch_config = f"""#!/usr/bin/env bash
+
+#SBATCH --job-name={label}
+#SBATCH --account=hkf6
+#SBATCH --partition=booster
+#SBATCH --nodes={nodes}
+#SBATCH --ntasks={ntasks}
+# Counted per node
+#SBATCH --gres=gpu:{gpus_per_node}
+#SBATCH --time=00:15:00
+#SBATCH --output=logs/{label}-%A_%a.log
+#SBATCH --error=logs/{label}-%A_%a.log
+#SBATCH --array=1-5
+
+SOURCE_DIR=/p/project/cellsinsilico/paulslustigebude
+OUTPUT_DIR="/p/scratch/cellsinsilico/paul/nastja-out/{label}-${{SLURM_ARRAY_TASK_ID}}"
+
+echo "outdir is ${{OUTPUT_DIR}}"
+
+mkdir -p "${{OUTPUT_DIR}}"
+source "${{SOURCE_DIR}}/activate-nastja-modules"
+
+srun --unbuffered "${{SOURCE_DIR}}/nastja/build-cuda/nastja" \\
+  -c "${{SOURCE_DIR}}/ma/experiments/configs/measurements/weak/spheroid_{label}.json" \\
+  -o "${{OUTPUT_DIR}}"
+"""
+
+    with open(f"batch/measurements/weak/{label}", "w", encoding="utf8") as batch_config_file:
+        batch_config_file.write(batch_config)

experiments/scripts/timing.py

@@ -0,0 +1,146 @@
+import click
+import csv
+import re
+import sqlite3
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple
+
+@dataclass
+class TimingData:
+    tasks: int
+    nodes: int
+    gpus_per_node: int
+    blockcount: Tuple[int, int, int]
+    array_index: int
+
+    # Given in seconds
+    timings_by_task: [float]
+
+RUN_PATTERN = re.compile(r".*t([0-9]+)n([0-9]+)g([0-9]+)x([0-9]+)y([0-9]+)z([0-9]+)-([0-9]+)")
+TIMING_PATTERN = re.compile(r"timing-([0-9]+)\.dat")
+TIMING_ROW_PATTERN = re.compile(r"([^ ]+) +([^ ]+) +([^ ]+) +([^ ]+) +([^ ]+).*")
+
+def get_timing(timing_path: Path, action: str) -> float:
+    with timing_path.open(encoding="utf8") as timing_file:
+        for line in timing_file:
+            m = TIMING_ROW_PATTERN.match(line)
+            if not m:
+                continue
+
+            if m.group(1) == action:
+                return float(m.group(5))
+
+    raise f"Could not find action '{action}' in {timing_path}"
+
+def get_timings(d: Path, action: str) -> [float]:
+    timings = []
+    for timing_path in d.iterdir():
+        i = int(TIMING_PATTERN.match(timing_path.name).group(1))
+        timings.append((i, get_timing(timing_path, action) / 1_000_000))
+
+    return [timing for i, timing in sorted(timings, key=lambda t: t[0])]
+
+def get_outdir_timing_data(d: Path, action: str) -> TimingData:
+    match_results = RUN_PATTERN.match(d.name)
+    tasks = int(match_results.group(1))
+    nodes = int(match_results.group(2))
+    gpus_per_node = int(match_results.group(3))
+    blockcount = (
+        int(match_results.group(4)),
+        int(match_results.group(5)),
+        int(match_results.group(6))
+    )
+    array_index = int(match_results.group(7))
+    timings_by_task = get_timings(d / "timing", action)
+
+    return TimingData(
+        tasks,
+        nodes,
+        gpus_per_node,
+        blockcount,
+        array_index,
+        timings_by_task
+    )
+
+@click.group()
+def timing():
+    pass
+
+@timing.command()
+@click.argument(
+    "directories",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    nargs=-1
+)
+@click.option("--db", default="timings.db", help="Path of sqlite database file")
+def make_timing_db(directories, db):
+    """
+    Collect NAStJA timing data from all passed directories and save them into a SQLite database.
+
+    Drops the timings table from the given database and creates a new timings table.
+
+    @param db asjdas
+    """
+    db = sqlite3.connect(db)
+    c = db.cursor()
+    c.execute("drop table if exists timings")
+    c.execute("create table timings (tasks, blockcount_x, blockcount_y, blockcount_z, array_index, averagetime)")
+
+    print("Collecting timing info...")
+    for d in directories:
+        print(d)
+        t = get_outdir_timing_data(d, "Sweep:DynamicECM")
+        c.executemany(
+            "insert into timings values (?, ?, ?, ?, ?, ?)",
+            [
+                (t.tasks, t.blockcount[0], t.blockcount[1], t.blockcount[2], t.array_index, sum(t.timings_by_task) / len(t.timings_by_task))
+            ]
+        )
+    print("Done, committing into DB...")
+    
+    db.commit()
+
+    print("Done!")
+
+@timing.command()
+@click.option("--db", default="timings.db", help="Path of sqlite database file")
+@click.option("--time/--no-time", default=False, help="Print average time of best run instead of speedup")
+def strong_dat(db, time):
+    db = sqlite3.connect(db)
+    c = db.cursor()
+    res = c.execute("""
+    select tasks, min(avg)
+    from (
+        select tasks, blockcount_x, blockcount_y, blockcount_z, sum(averagetime) / count(*) as avg
+        from timings group by tasks, blockcount_x, blockcount_y, blockcount_z
+    ) group by tasks order by tasks asc;
+    """)
+    values = res.fetchall()
+
+    if not time:
+        print("gpus\tspeedup")
+        for tasks, time in values:
+            print(f"{tasks}\t{values[0][1] / time}")
+    else:
+        print("gpus\ttime")
+        for tasks, time in values:
+            print(f"{tasks}\t{time}")
+
+@timing.command()
+@click.option("--db", default="timings.db", help="Path of sqlite database file")
+def weak_dat(db):
+    db = sqlite3.connect(db)
+    c = db.cursor()
+    res = c.execute("""
+    select tasks, avg(averagetime) as mean from timings group by tasks order by tasks asc
+    """)
+    values = res.fetchall()
+
+    print("gpus\tefficiency")
+    for tasks, mean in values:
+        print(f"{tasks}\t{values[0][1] / mean}")
+
+if __name__ == "__main__":
+    timing()

experiments/shell.nix

@@ -0,0 +1,15 @@
+let
+  pkgs = import <nixpkgs> {};
+in
+  pkgs.stdenv.mkDerivation {
+    name = "jupyter-shell";
+    buildInputs = [
+      (pkgs.python3.withPackages (p: [p.virtualenv]))
+    ];
+    # In order to run jupyter-lab from pypi, we need to provide it
+    # with libdstc++.so.6.
+    shellHook = ''
+      export LD_LIBRARY_PATH="${pkgs.stdenv.cc.cc.lib}/lib"
+      source venv/bin/activate
+    '';
+  }

experiments/templates/spheroid.json

@@ -0,0 +1,117 @@
+{
+    "Comments": ["Celltype         Usage", "0                Dynamic ECM", "1-5             Not Used", "6               Liquid  ", "7               Apoptotic cell Type ", "8               Basic Non Dividing Cell type (surrounding)", "9               Cancer"],
+    "Application": "Cells",
+    "CellsInSilico": {
+        "ecmdegradation": {
+            "enabled": "false",
+            "steps": 99999,
+            "stochastic": "true",
+            "probability": 0.5
+        },
+        "energyfunctions": ["Volume00", "Surface01", "Motility00", "Adhesion01", "DynamicECM00"],
+        "liquid": 6,
+        "volume": {
+            "default": {
+                "storage": "const",
+                "value": 500
+            },
+            "lambda": [0, 0, 0, 0, 0, 0, 0, 7.5, 7.5, 7.5],
+            "sizechange": [0, 0, 0, 0, 0, 0, 0, -0.05, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "surface": {
+            "default": {
+                "storage": "const",
+                "value": 400
+            },
+            "lambda": [0, 0, 0, 0, 0, 0, 0, 5.625, 5.625, 1],
+            "sizechange": [0, 0, 0, 0, 0, 0, 0, -0.05, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "adhesion": {
+            "matrix": [
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 450],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 450, 0, 0, 0, 0, 0, 0, 0, 50]
+            ]
+        },
+        "temperature": 50,
+        "division": {
+            "enabled": "true",
+            "condition": ["", "", "", "", "", "", "", "", "", "( volume >= 0.9 * volume0 )  & ( rnd() <= 0.00001 ) & generation < 1"]
+        },
+        "centerofmass": {
+            "steps": 1
+        },
+        "signaling": {
+            "enabled": false
+        },
+        "orientation": {
+            "enabled": true,
+            "motility": "persistentRandomWalk",
+            "persistenceMagnitude": 0.0,
+            "recalculationtime": 200,
+            "motilityamount": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "visitor": {
+            "stepwidth": 10,
+            "checkerboard": "01"
+        },
+        "cleaner": {
+            "killDistance": 20
+        },
+        "dynamicecm": {
+            "enabled": true,
+            "stepsPerMcs": 100,
+            "pushSteps": 10,
+            "pushWeight": 2,
+            "ecmCellID": 0,
+            "deltat": 0.1,
+            "eta": 0.25,
+            "k0": 0.1,
+            "k1": 0.1,
+            "c": 4,
+            "alpha": 2,
+            "d": 0.3,
+            "phi": 1
+        }
+    },
+    "Geometry": {
+        "blockcount": null,
+        "blocksize": null
+    },
+    "Settings": {
+        "randomseed": 0,
+        "timesteps": 20,
+        "statusoutput": 1
+    },
+    "WriteActions": [],
+    "Writers": {
+        "CellInfo": {
+            "field": "",
+            "groupsize": 0,
+            "steps": 1,
+            "writer": "CellInfo"
+        },
+        "ParallelVTK_Cells": {
+            "field": "cells",
+            "outputtype": "UInt32",
+            "printhints": false,
+            "steps": 100,
+            "writer": "ParallelVtkImage"
+        },
+        "ParallelVTK_Displacement": {
+            "writer": "ParallelVtkImage",
+            "outputtype": "Float32",
+            "field": "dynamicecm",
+            "components": [0, 1, 2],
+            "steps": 100
+        }
+    },
+    "Include": "config_filling_1.json"
+}

experiments/templates/spheroid_weak.json

@@ -0,0 +1,100 @@
+{
+    "Comments": ["Celltype         Usage", "0                Dynamic ECM", "1-5             Not Used", "6               Liquid  ", "7               Apoptotic cell Type ", "8               Basic Non Dividing Cell type (surrounding)", "9               Cancer"],
+    "Application": "Cells",
+    "CellsInSilico": {
+        "ecmdegradation": {
+            "enabled": "false",
+            "steps": 99999,
+            "stochastic": "true",
+            "probability": 0.5
+        },
+        "energyfunctions": ["Volume00", "Surface01", "Motility00", "Adhesion01", "DynamicECM00"],
+        "liquid": 6,
+        "volume": {
+            "default": {
+                "storage": "const",
+                "value": 500
+            },
+            "lambda": [0, 0, 0, 0, 0, 0, 0, 7.5, 7.5, 7.5],
+            "sizechange": [0, 0, 0, 0, 0, 0, 0, -0.05, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "surface": {
+            "default": {
+                "storage": "const",
+                "value": 400
+            },
+            "lambda": [0, 0, 0, 0, 0, 0, 0, 5.625, 5.625, 1],
+            "sizechange": [0, 0, 0, 0, 0, 0, 0, -0.05, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "adhesion": {
+            "matrix": [
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 450],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 450, 0, 0, 0, 0, 0, 0, 0, 50]
+            ]
+        },
+        "temperature": 50,
+        "division": {
+            "enabled": "true",
+            "condition": ["", "", "", "", "", "", "", "", "", "( volume >= 0.9 * volume0 )  & ( rnd() <= 0.00001 ) & generation < 1"]
+        },
+        "centerofmass": {
+            "steps": 1
+        },
+        "signaling": {
+            "enabled": false
+        },
+        "orientation": {
+            "enabled": true,
+            "motility": "persistentRandomWalk",
+            "persistenceMagnitude": 0.0,
+            "recalculationtime": 200,
+            "motilityamount": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "visitor": {
+            "stepwidth": 10,
+            "checkerboard": "01"
+        },
+        "cleaner": {
+            "killDistance": 20
+        },
+        "dynamicecm": {
+            "enabled": true,
+            "stepsPerMcs": 100,
+            "pushSteps": 10,
+            "pushWeight": 2,
+            "ecmCellID": 0,
+            "deltat": 0.1,
+            "eta": 0.25,
+            "k0": 0.1,
+            "k1": 0.1,
+            "c": 4,
+            "alpha": 2,
+            "d": 0.3,
+            "phi": 1
+        }
+    },
+    "Geometry": {
+        "blockcount": null,
+        "blocksize": null
+    },
+    "Settings": {
+        "randomseed": 0,
+        "timesteps": 20,
+        "statusoutput": 1
+    },
+    "DefineFunctions": [
+        "r_angle()=360*rnd()",
+        "r_size()=400*rnd()"
+    ],
+    "Filling": {
+        "cells": null
+    }
+}

experiments/templates/varied-fillings.json

@@ -0,0 +1,103 @@
+{
+  "#Testing": {
+    "description": "Cellular Potts Model with dynamic ECM"
+  },
+  "Application": "Cells",
+  "Geometry": {
+    "blocksize": [30, 30, 40],
+    "blockcount": [4, 4, 3]
+  },
+  "Settings": {
+    "timesteps": 750,
+    "randomseed": 42
+  },
+  "Filling": {
+    "cells": [
+      {
+        "_comment": "This is for the dynamic ECM",
+        "shape": "cube",
+        "box": [
+          [0, 0, 0],
+          [119, 119, 119]
+        ],
+        "value": 0,
+        "celltype": 0
+      }
+    ]
+  },
+  "CellsInSilico": {
+    "liquid": 1,
+    "adhesion": {
+      "matrix": [
+        [ 0, 0,  10, 10],
+        [ 0, 0,  0,  0],
+        [10, 0, 40,  5],
+        [10, 0,  5, 40]
+      ]
+    },
+    "temperature": 15,
+    "volume": {
+      "default": {
+        "storage": "const",
+        "value": 6000
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "surface": {
+      "default": {
+        "storage": "const",
+        "value": 1000
+      },
+      "lambda": {
+        "storage": "const",
+        "value": 10
+      }
+    },
+    "cleaner": {
+      "killdistance": 100
+    },
+    "checkerboard": "00",
+    "energyfunctions": ["Volume00", "Surface00", "Adhesion00", "DynamicECM00"],
+    "centerofmass": {
+      "steps": 10
+    },
+    "dynamicecm": {
+      "enabled": true,
+      "stepsPerMcs": 200,
+      "pushSteps": 10,
+      "pushWeight": 2,
+      "ecmCellID": 0,
+      "deltat": 0.1,
+      "eta": 0.25,
+      "k0": 0.1,
+      "k1": 0.1,
+      "c": 4,
+      "alpha": 2,
+      "d": 0.3,
+      "phi": 1
+    }
+  },
+  "Writers": {
+    "ParallelVTK_Cells": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "UInt32",
+      "field": "cells",
+      "steps": 10
+    },
+    "ParallelVTK_Displacement": {
+      "writer": "ParallelVtkImage",
+      "outputtype": "Float32",
+      "field": "dynamicecm",
+      "components": [0, 1, 2],
+      "steps": 10
+    },
+    "CellInfo": {
+      "writer": "CellInfo",
+      "steps": 10
+    }
+  },
+  "WriteActions": ["ParallelVTK_Cells", "ParallelVTK_Displacement", "CellInfo"]
+}