dataesr/scientific-paragraphs-categorization huggingface dataset:
Gene content comparison of Neff and C3 strains Custom Python scripts were used to retrieve genes unique to each A. castellanii strain, as well as orthogroups that were shared between the two strains. Genes were only determined to be strain specific or shared if both Broccoli and OrthoFinder assigned them as such; genes were excluded from the analysis if both tools did not agree. For both strains, functional assignments for each gene ID were extracted from funannotate output and tabulated. The tabulated assignments and strain-specific gene IDs were fed into the R package topGO (https:///bioconductor. org/packages/ topGO/  [accessed July 12, 2022] ) to analyze GO term enrichment in the strain-specific genes. A Fisher's exact test with the weight algorithm was implemented in topGO for the Neff-and C3-specific genes for each of the three ontologies (biological process, cellular component, and molecular function).
MBP comparison MBP amino acid sequences from three strains of A. castellanii  (Neff, C3, and MEEI 0184)  and one strain of A. polyphaga were retrieved, aligned using    (Katoh and Standley 2013), and visualized in Jalview (v2. 11. 1. 3) (Waterhouse et al. 2009 ). The MEEI 0184 strain sequence was retrieved from the NCBI Protein database (accession number AAT37865. 1), and the Neff and C3 sequences were retrieved from the predicted proteomes generated in this study with the MEEI 0184 sequence as a BLASTP  (Altschul et al. 1990 ) query. The A. polyphaga genome does not have a publicly available predicted proteome, so its MBP protein sequence was manually extracted from several contigs in the genome sequence (NCBI accession GCA_000826 345. 1) using TBLASTN with the MEEI 0184 sequence as a query (the sequence encoding the first eight amino acids of the protein could not be found in the genome owing to a truncated contig).
Hi-C analyses Reads were aligned with Bowtie 2 v2. 4. 1, and Hi-C matrices were generated using hicstuff v3. 0. 1 (https://zenodo. org/record/ 4066363  [accessed July 12, 2022] ). For all comparative analyses, matrices were down-sampled to the same number of contacts using cooltools (https://www. github. com/mirnylab/cooltools), and balancing normalization was performed  (Cournac et al. 2012; Imakaev et al. 2012). Loops and domain borders were detected using Chromosight v1. 6. 1 (Matthey-Doret et al. 2020) using the merged replicates at a resolution of 2 kb. We measured the intensity changes in Chromosight scores during infection using pareidolia (v0. 6. 1) (https://zenodo. org/record/5362241/export/json [accessed July 12, 2022]) on three pseudoreplicates generated by sampling the merged contact maps, as described previously  (Yang et al.
Acknowledgments We thank  Axel Cournac ,  Laura Gomez Valero ,  Christophe Rusniok , and  Lyam Baudry  for their comments on the bioinformatics analysis,  Charlotte Cockram  for her help with  Oxford Nanopore sequencing ,  Olivier Espeli , and all members of the  Koszul laboratory and Buchrieser laboratory  for stimulating discussions. C. M. -D. is supported by the  Pasteur-Paris University (PPU)   International PhD Program. This research was supported by the  European Research Council (ERC)  under the European Union's  Horizon 2020  to  R. K. ( ERC grant  agreement  771813 ). The C. B. laboratory is financed by the  Fondation pour la Recherche Médicale (FRM)  grant no. EQU201903007847  and the  Agence Nationale de la Recherche (ANR)  grant no. ANR-10-LABX-62-IBEID. Research  in the Archibald laboratory was supported by a grant from the  Gordon and Betty Moore Foundation  ( GBMF5782 ).
Data access The sequencing data generated in this study have been submitted to the NCBI BioProject database (https://www. ncbi. nlm. nih. gov/ bioproject/) under accession numbers PRJNA599339 and PRJNA487265. All processed data generated in this study, as well as the assemblies and annotations used in this work, have been submitted to Zenodo repository under accession number https ://zenodo. org/record/5507417. Strains supporting the findings of this study are available from the corresponding authors. The code used to perform the analysis is packaged into the following Snakemake pipelines available as Supplemental Code and at GitHub: hybrid genome assembly, https://github. com/cmdoret/Acastell anii_hybrid_assembly; functional annotation of A. castellanii, https://github. com/cmdoret/Acastellanii_genome_annotation; analyses of genomic features in A.
The increasing use of mini-invasive and endovascular surgical techniques is at the origin of the pressing need for computational models to support planning and training. Several implantable devices have a wire-like structure, which can be modelled using beam elements. Our objective is to create an efficient Finite Element (FE) modelling framework for such devices. For that, we developed the EndoBeams. jl package, written exclusively in Julia, for the numerical simulation of contact interactions between wire-like structures and rigid surfaces. The package is based on a 3D FE corotational formulation for frictional contact dynamics of beams. The rigid target surface is described implicitly using a signed distance field, predefined in a volumetric grid. Since the main objective behind this package is to find the best compromise between computational speed and code readability, the algorithm, originally in Matlab, was translated and optimised in Julia, a programming language designed to combine the performance of low-level languages with the productivity of high-level ones.
To evaluate the robustness, a set of tests were conducted to compare the simulation results and computational time of Endo-Beams. jl against literature data, the original Matlab code and the commercial software Abaqus. The tests proved the accuracy of the underlying beam-to-surface formulation and showed the drastic performance improvement of the Julia code with respect to the original one. EndoBeams. jl is also slightly faster than Abaqus. Finally, as a proof of concept in cardiovascular medicine, a further example is shown where the deployment of a braided stent is simulated within an idealised artery.
The algorithm proposed by Aguirre and Avril was implemented in Matlab (MathWorks, Natick, MA, USA). Matlab, as well as Python and Java, is an easy-to-write programming language with a user-friendly interface, but it is usually slow and less efficient for intensive problems than lower-level languages, i. e. C/C++ and Fortran. The issue with the latter is that they require high programming skills and may produce code that cannot be read and edited by non-expert users preventing its wide use. In this perspective, the Julia programming language is designed to be a good compromise between machine performance and human convenience: it shows similar computational speed as compiled programming language while providing interactive dynamic behaviour similar to Matlab and Python  [26, 27]. In addition, Julia allows differentiable programming, whose notable advantages include easy automatic gradient computation of user-defined functions (essential for sensitivity analysis), but also easier training of neural networks with customised loss functions  [28].
In the literature, there are some contributions that compare the performance of Julia for computational mechanics against other programming languages or commercial solvers: in  [29] , the material point method was implemented in Julia showing better performance than a similar Matlab code; in  [30] , a Julia-based package for the smoothed Finite Element Method (FEM) was proposed and verified against the commercial software Abaqus (Simulia, Dassault Systems, Providence, RI, USA). The first contribution of the current paper is the open-source Juliabased package EndoBeams. jl: the algorithm proposed by Aguirre and Avril was translated into a more-efficient programming language, Julia, and the code was optimised by introducing vectorization and sparse matrices. Performance in terms of accuracy of the corotational beam formulation was verified with literature data, while the accuracy of the beam-to-surface contact formulation was analysed with respect to Abaqus.
Computational speed was compared to both the original Matlab code and Abaqus. Finally, as a proof of concept in cardiovascular medicine, the deployment of braided stents within idealised geometries was simulated. Braided stents are self-expanding devices used for the endovascular treatment of unruptured intracranial aneurysms  [31]  and stenotic peripheral arteries  [32]. Their structure made of interlaced wires provides high flexibility and kinking resistance that are essential in tortuous vessels. The challenge in numerical simulations of braided stents is to describe the contacts occurring between wires. To avoid rendering all these contacts, one could exploit a simplified approach where the relative displacement of the nodes pairs at the interconnections between wires is constrained by some type of connector.
We apply this concept in the current paper by introducing additional mechanical terms, not present in  [25] , that model the presence of damping and constraints through a penalty method. The remainder of the paper is organized as follows. Section 2 overviews the corotational beam formulation and its FE formulation. Two subsections (2. 3. 2 and 2. 3. 3) are dedicated to the constraints and viscous damping formulations. Section 3 discusses the implementation of the FE formulation in the Julia programming language, where the structure of the EndoBeams. jl package is described in subsection 3. 2. In Section 4, a series of tests are presented: in particular, subsection 4. 4 is dedicated to the simulation of braided stent deployment. Finally, Section 5 presents the concluding remarks.
Julia implementation of the corotational beam formulation In this section, the implementation of the FE formulation in the Julia programming language is explained. The goal of this work was not only to write a fast FE solver but to obtain a FE framework with a structure that can be easily understood and can be further developed by third parties. Therefore, the implementation was carried out with the idea of optimising both the code speed and readability. As a consequence, the Julia programming language was deemed a good candidate  [26, 27]. To keep track of the different names used for matrices and vectors and their dimensions, two summary tables are provided 1 (Table  1  and Table  2 ).
Implementation aspects Following the performance tips section of the Julia manual  [37] , a series of measures were considered in the implementation process. The most important ones are: • Preallocation of large matrices and vectors; • Use of typed data struct to ensure type stability; • Prefer for-loops to vectorized operators; • Substitute dense matrices with sparse matrices; • Use statically sized arrays for small vectors and matrices. In the next sections, the main Julia packages employed to optimise the code are presented. Examples of their use can be found in Appendix A.
StaticArrays. jl The dimension of the variables used during the computation of the elemental contributions never overcomes the size of a 12x12 matrix (see sections 2. 3 and 2. 4). The StaticArrays. jl package is an optimal tool for dealing with these small arrays of fixed size  [38]. This package provides a framework to create statically sized arrays in Julia, meaning that its compiler can deduce their size by their type. As can be easily demonstrated with the benchmark available on the package website, for small matrices and vectors, the computational speed of operations between SVectors and SMatrices is often more than 10 times faster than using the general Base. Array type. Besides, they are stored on the stack, not the heap, which is typically much more performant due to the simpler    38 ), (  41 ), (  40 ), (  46 ),  (50)  [nBeamDOFs] SVector Assembled matrices: The free tangent matrix and the free residual vector are obtained by reducing the total amount of unknowns to the free DOFs as typically performed in FEM to prescribe boundary conditions  [36].
Composite types and StructArrays. jl The use of composite types, struct, in the code makes it possible to preallocate large matrices as fields of structures at the beginning and to reuse them during the simulation by modifying their content. It also facilitates the writing of type-stable code: in fact, functions are always able to infer the type of variables if these are typed fields of structures. Finally, it helps with code readability. In a transient FE code, it is necessary to collect all past and current information about the mesh nodes and update it during the simulation. In order to accomplish this, a struct Node is created that contains the information about a specific node of the mesh (displacement, velocity, acceleration, rotation, angular velocity and acceleration). To gather objects of type Node related to the whole mesh, the data layout offered by the StructArrays.
Interpolations. jl and SignedDistanceField. jl For simple objects (sphere, plane, cylinder), the computation of the SDF is trivial: appropriate functions are made available in our Julia code to model them using an analytical signed distance function. For more complex objects, a discrete SDF is computed using the package Sign-edDistanceField. jl  [40] , which only requires as an input the triangular mesh in the form of an. obj file and computes its SDF over a regular grid based on the point-to-triangle signed distance algorithm described in  [41]. In contrast to  [25] , the interpolation of the discrete SDF is carry out exploiting the Interpolations. jl package  [42] , which is faster than the algorithm proposed in  [25]. In this package, a set of interpolations schemes for regular grids are implemented in the Julia programming language.
Post-processing The EndoBeams. jl package enables visualisation of simulation results employing the open-source, VTK-based software Paraview  [43]. The output of the code consists of different sets of. vtk and. txt files, each of which allows to visualise the time evolution of the following numerically-computed results: • Nodal positions; • Beam centreline positions: they are obtained by interpolation, following  (23) , using nInterpolationPoints points per element where nInterpolationPoints is chosen by the user; • Contact information at Gauss points: the Gauss point positions are stored together with the associated contact gap and the normal and tangential components of the contact force. • Energy: internal, kinetic and contact energies evolution.
README. Simulations are carried out using the Julia package EndoBeams. jl and the Matlab code of  [25] , which has already been benchmarked in the related article. Here a further evaluation of the non-linear dynamic formulation (no contact) is proposed against literature data. Additionally, since no benchmark results were found for complex 3D beam-to-surface contact problems in the literature, some tests are replicated also in Abaqus Standard to verify the frictional contact formulation. Before proceeding with the analysis of these results, it is worth pointing out the differences present between the contact formulation in EndoBeams. jl and Abaqus. In both, a penalty method is used to impose the contact normal contribution. However, it is not possible to use the same pressure-normal gap relation in Abaqus Standard as implemented in Julia (see Fig.
3  in  [25] ). The closest way found is to use in Abaqus a hard-contact pressure-overclosure relationship and select a penalty enforcement method  [44, 45]. In this case, it is possible to choose the value of the penalty stiffness and the clearance at which the contact pressure is 0, which have a correspondence in the EndoBeams. jl code, respectively in ε C and g N in equation (  111 ) in  [25]. Regarding the contact tangential contribution, a regularised friction model is implemented in EndoBeams. jl and, thus, the stick behaviour is not captured. In Abaqus, a stick-slip friction model is selected. Because of this difference in the formulation used, only the value of parameters that have different meanings in Julia and Abaqus can be defined. In EndoBeams. jl, the transition between sticking and sliding is defined by a square-root regularization (equation (112) in  [25] ), where the value of the regularisation parameter ε T is chosen at the beginning and remains fixed during the simulation.
Abaqus can enforce friction with a penalty method allowing some relative motion between the surfaces during the sticking phase  [46]. However, unlike Julia, it continually adjusts the magnitude of the penalty stiffness to enforce the stick-slip condition. Abaqus Standard calculates the value of the allowable elastic slip, γ crit , as a small fraction of l char , the characteristic contact surface length. The value of l char can be selected in the contact properties. When performing the simulations, it has been noticed that the contact tangential contribution in Abaqus is highly dependent on this parameter and, therefore, its results are shown for different l char values for the sake of completeness. To further investigate the capabilities of the developed Julia package, its computational speed for each example is also compared against the original Matlab code and Abaqus.
The comparison between Julia and Matlab computational speed should be viewed as a comparison of two versions of the same code, one raw and one optimised, and should not be considered as a comparison of the performance of the two programming languages since the improvements in the Julia package, such as the use of sparse matrices, are not implemented in the Matlab one. Computational time refers to the time required to successfully complete the simulation using a single thread on an Intel(R) Core(TM) i7-10850H CPU with a RAM of 16GB. The elapsed time is measured in Julia using the @btime macro of the Benchmark. jl package  [47] , in Matlab using the time function and in Abaqus considering the CPU time in the. dat output file.
The structure is discretised with 20 beam elements (10 per side). The time step is taken as Δt = 0. 25 s. Fig. 4b  shows the evolution of the tip out-of-plane displacement, i. e. u z : since the solution fits very well with that of  [19] , it can be stated that the accuracy of the non-linear dynamic formulation is verified. Moreover, the EndoBeams. jl computational time is compared with the one required by the Matlab code: as shown in Table 3, for this specific example, the Julia environment is more than 15× faster than the Matlab one.
Impact of a ring against a rigid surface To check the performance of the contact algorithm in a 2D  environment, the ring-against-surface example proposed in  [48]  is replicated. The same test is implemented in Abaqus to compare both the results and the computation time. The initial setup is shown in Fig. 5. A flexible ring with a centreline radius R = 10 m and a circular cross-section of radius r = 0. 5 m is located in the origin [0, 0, 0] T m. The ring has an initial uniform velocity equal to v 0 = [ ̅̅̅ 2 √ , - ̅̅̅ 2 √ , 0] T m/s. A rigid surface is placed at z = -12 m. The ring material properties are: E = 100 Pa, ν = 10 -4 and ρ = 10 -2 kg/ m 3. The ring is discretised with 64 beam elements. In Julia, the rigid surface is modelled using an analytical SDF; similarly in Abaqus, an analytical 2D rigid part is created.
The time step is taken as Δt = 0. 0125 s: this value is sufficiently low such that no time step refinement is required and, thus, the computational time of the Julia package and Abaqus can be confronted. To analyse both the normal and tangential contact contributions, the simulation is run using three different friction coefficients, μ ∈ {0. 00,0. 15,0. 30}. The penalty parameter is taken as ε C = 10 6 and the friction regularisation parameter as ε T = 0. 5. To understand the influence of the characteristic contact surface length in the Abaqus results, three different values are consider for this parameter, l crit ∈ {0. 01, 0. 1, 1. 00}. In Fig. 6 , the difference between the results provided by the Endo-Beams. jl package and by Abaqus are shown for t = 4. 375 s, when the ring is in full contact with the surface.
The normalised nodal displacement error is computed as: err i = ‖ u i,Abaqus -u i,Julia ‖ ‖ u i,Abaqus ‖ ∀i = 1,. , nnodes, (69) and displayed as a colourmap. The same scale is used to compare the results with different friction coefficients. The results of the EndoBeams. jl package agree overall well with those of Abaqus with the error increasing with the friction coefficient and reaching a maximum value of 1. 3⋅10 -2 in the last case. To track the difference of the solutions in time, the history of the normal and tangential displacements of the reference point x p is also plotted for each value of the friction coefficient Fig. 7  and, only for Abaqus, for each value of the characteristic contact surface length. It can be seen that the results in Abaqus vary considerably with respect to the last parameter: with l crit = 0.
Dropping a net on a rigid sphere This example is designed to test the robustness of the non-linear beam formulation and contact algorithm in 3D. Secondly, by comparing three different voxel discretisations for the discrete SDF in Julia against an analytical SDF in Julia, an analytical and a discrete surface in Abaqus, the computational efficiency of the interpolation algorithm is assessed. The initial setup is depicted in Fig. 8. A net of 11x13 threads of length L 1 and L 2 is placed immediately above a sphere with R = 0. 05 m. The threads have a circular cross-section r = 10 -4 m and their material properties are: E = 10 Pa, ν = 0. 0, ρ = 1500 kg/m 3. The net nodes are subjected to an initial uniform velocity equal to [0, -0. 001, 0] m/s. The net is discretised using 786 beam elements. The sphere is treated, on one hand, in Abaqus as both an analytical and discrete (i.
e. triangulated mesh) 3D rigid part and, on the other hand, in Julia as both an analytical and discrete SDF. Three element sizes are considered for the discrete model in Abaqus: h Abaqus,1 = 0. 005 m and 2528 elements, h Abaqus,2 = 0. 0025 m and 10217 elements, h Abaqus,3 = 0. 00125 m and 40429 elements. The discrete SDF in Julia is characterised by the following three voxel dimensions: h Julia,1 = 0. 0075 m and  (20, 20, 20)  voxels, h Julia,2 = 0. 00375 m and  (40, 40, 40)  voxels, h Julia,3 = 0. 001875 m and (80,80,80) voxels. The friction coefficient is μ = 0. 01. The penalty parameter is taken as ε C = 0. 01 and the friction regularisation parameter as ε T = 0. 5. Following the tuning performed in the last example, the characteristic surface dimension is set equal to 0. 1 in Abaqus. The initial time step is Δt = 0.
5 s. The simulation is run from t = 0. 0 s to t = 100. 0 s, when the net largely covers the surface of the sphere and before any self-contact occurs in the net. First, a comparison between the results using an analytical SDF in Julia against an analytical surface in Abaqus is carried out at t = 0, 25, 50, 100 s. In Fig. 9 , the difference between the results provided by the EndoBeams. jl package and by Abaqus is depicted. This relative error is evaluated using (69). The results of the EndoBeams. jl package are  overall very close to the Abaqus ones. The main differences are observable in the part of the net in direct contact with the sphere but the normalised error does not overcome the value of 5. 2⋅10 -2. The computational times are compared in Table  5. The EndoBeams. jl package is more than 33x faster than the original Matlab code and shows a slightly lower speed than Abaqus (between 1.