dataesr/scientific-paragraphs-categorization huggingface dataset:
Quantitative 3D image analysis Quantitative 3D image analysis was performed using the Pore3D software library  (Brun, et al. , 2010)  on Representative Volume of Interest (RVI) of the respective data sets, following an RVI-test, as further described in the Supplementary Material section 'Representative Volume of Interest (RVI) test'. The following image parameters were quantified: 1) Volume percentage (Vol. Perc. ) of the air part, also referred to as 'porosity', 2) Specific Surface Area, computed as the quotient between the surface area of the object divided with the total volume of the VOI as further described by  (Parfitt, et al. , 1987) , 3) Structure Thickness (St. Th. ) of the extruded foams, hereinafter referred to as 'cell wall thickness' and 4) Conn. D, as well as 5) pore and 6) throat sizes, based on skeletonization, as further described in  (Furlan, et al.
, 2018) , hereinafter referred to as Method 1. For objective comparison, the pore size was also estimated on the individually separated macro pores, by applying a 'Distance Transform Watershed 3D' algorithm in the MorphLibJ package  (Legland, Arganda-Carreras, & Andrey, 2016)  in ImageJ, using the following parameters: Borgefors(3,4,5) and 'normalization dynamic': 6. 0, followed by quantification using Pore3D, hereinafter referred to as Method 2. However, only Method 1 is capable of estimating both the pore and the throat size.
3D Visualization The 3D volume renderings were performed using the Drishti package for visualization of volumetric datasets  (Limaye, 2012)  and using 'Volume viewer' in ImageJ  (Rueden, et al. , 2017)  for visualization of the 'local thickness'  (Hildebrand & Rüegsegger, 1997) , as well as the individually separated macro pores, as separated by 'Wathershedding'.
Acknowledgements Synchrotron experiments were performed at  NCD beamline at ALBA Synchrotron with the collaboration of ALBA  staff (2016021658 project). Part of this work was supported by the  COST Action ES1408 European network  for algal-bioproducts (EUALGAE). Roland Kádár ,  Chalmers University of Technology, Sweden , is gratefully acknowledged for access to the extruder. We acknowledge,  LLB, Saclay, France  for offering beamtime at the IMAGINE beamline. Ana Miljkovic  is acknowledged for resistant starch and compression test measurements.
Phage Production and Purification Phage p2 and its host L. lactis MG1363 were obtained from the Félix d'Hérelle Reference Center for Bacterial Viruses (www. phage. ulaval. ca). L. lactis MG1363. For phage amplification, CaCl2 was added to the medium at a final concentration of 10 mM. Phage p2 was amplified and purified as   [6] ). The map is contoured at 2. 5σ. (B) CryoEM 3D reconstruction phage p2 purified and cross-linked baseplate (EMD-1706  [6] ). The map is contoured at 2. 5σ. (C) Crystal structure of phage p2 purified baseplate in complex with VHH5 (PDB ID 2WZP,  [6] ). VHH5 molecules are not shown for clarity. (D,E) Central section of the 3D reconstructions shown in panels A and B with the baseplate crystal structure (shown in panel C) fitted in the maps. The green/black dots indicate unassigned EM densities/EM density rings.
(F) The crystal structure of phage p2 purified baseplate in activated conformation, with the receptor-binding domains pointing in the opposite direction to the capsid, is shown for comparison (PDB ID 2X53  [6] ). Here, we present further structural analyzes of the phage p2 baseplate, proposing a topological model of the baseplate resting state, and interpreting a new nsEM structure of the virion, in its active conformation. These novel views on the activation mechanism of phage p2 may be applicable to other members of the Siphoviridae family exhibiting an activation mechanism  [7, 12].
Negative-Staining Electron Microscopy Data Collection and Image Processing The sample was imaged on a T12 Spirit transmission electron microscope operating at 120 kV. A total of 261 images were collected with a pixel size of 3. 46 Å/pixel at the specimen level. Images were acquired using a Veleta CCD camera (Olympus, München, Germany) with an electron dose of -20 e -/Å 2. Micrographs were imported in RELION-3. 0 for all subsequent image-processing tasks  [13]. Estimation of the Contrast Transfer Function was performed with CTFFIND4  [14]  and particles were manually picked. A total of 293 particles were extracted, normalized, and subjected to rounds of reference-free 2D classification in RELION-3. 0 (to remove bad particles). An initial 3D reference was generated using a Stochastic Gradient Descent algorithm in RELION-3.
Data Availability The negative-staining EM maps and the molecular models have been deposited in the Electron Microscopy Data Bank and RCSB Protein Data Bank under the accession codes EMD-11226 and PDB ID 6ZIH (p2 virion baseplate bound to VHH5), EMD-11225 and PDB ID 6ZIG (p2 virion baseplate bound to VHH5, 3D class with closed Tal trimer), EMD-11224 ((p2 virion baseplate bound to VHH5, 3D class with open Tal trimer), and PDB ID 6ZJJ (topological model of p2 virion baseplate in resting conformation, related to EMD-1699). Viruses 2020, 12, 878 5 of 12.
Topological Model of the p2 Virion Baseplate in Its Resting State As indicated above, the baseplate architectures in phage p2 virion, in the recombinantly produced cross-linked complex and in the crystal structure with bound VHH5s, are similar: they all exhibit the receptor-binding domains pointing towards the capsid, and the Tal trimer is closed (Figure  1A-C ). With the aim of getting a complete topological model of the p2 baseplate in its resting state, we have rigid-body fitted the baseplate crystal structure (PDB ID 2WZP)  [6]  into the distal tail end of the p2 virion nsEM structure (Figure  1D ). Although the overall fit was of good quality, we noticed that the RBPs leaned towards the baseplate central axis, an effect probably due to the VHH5s in the crystal structure (Figure  1D ).
Therefore, we have rigid-body fitted individually each RBP trimer into the map. The resulting Dit-Tal-RBP assembly gave an excellent fit (Table  S1 ) (Figure  2A ). Then, we positioned a second Dit ring back to back with the first one, using the Dit-Dit back to back assembly observed between symmetry-related molecules in the crystal packing of the activated baseplates (PDB ID 2X53)  [6]. This resulted in a nice fit of the Dit-2 N-terminal ring, while the galectin domains were out of the map. Therefore, we fitted the Dit-2 galectin domains, as a single rigid body, into the second map ring that contacts the Major Tail Protein (MTP) hexamer, and we modeled the backbone of the linkers connecting the Dit-2 N-terminal and galectin domains using the coot software  [15, 16]. In this new position of the Dit-2 galectin domains, the tips of the arm-hand extensions were out of the map.
In such conformation, the Dit-2 arm-hand extension (residues 145-186) contacts one receptor-binding domain in a crest of the β-barrel (residues 195-198 and 204-206), a position that is close, but distinct, to the saccharidic receptor-binding site located at the interface between two β-barrels of the trimeric RBP (Figure  2C ). Then, we positioned a second Dit ring back to back with the first one, using the Dit-Dit back to back assembly observed between symmetry-related molecules in the crystal packing of the activated baseplates (PDB ID 2X53)  [6]. This resulted in a nice fit of the Dit-2 N-terminal ring, while the galectin domains were out of the map. Therefore, we fitted the Dit-2 galectin domains, as a single rigid body, into the second map ring that contacts the Major Tail Protein (MTP) hexamer, and we modeled the backbone of the linkers connecting the Dit-2 N-terminal and galectin domains using the coot software  [15, 16].
The Dit-1/Tal/RBP assembly from the activated baseplate crystal structure fitted well in the map (Table  S1 ). In order to gain insight into the molecular determinants mediating the baseplate-baseplate interface, we fitted the structure of one RBP trimer bound to three VHH5 (RBP 3 -VHH5 3 ) (PDB ID 2BSE;  [11] ) and generated D6 symmetry-related VHH5 copies to fill in the whole baseplate-baseplate interface (Table  S1 ). The resulting structural model indicates that the baseplate-baseplate interface mainly relies on contacts between opposite (RBP 3 -VHH5 3 ) tripods (Figure  4E ). Lastly, we fitted our model of Dit-2, obtained from the baseplate resting state, in the map and above Dit-1 (Table  S1 ) (Figure  5A ). To note, the map volume of the arm-hand extension appears larger than that of the experimental map.
We postulate that the mobility of this domain is increased once the contact with the receptor-binding domain has been released (Figure  5B ), leading to a smaller map volume (Figure  5A ). We produced a topological model of the activated baseplate within the virions by rigid-body fitting structural models within the nsEM map. The Dit-1/Tal/RBP assembly from the activated baseplate crystal structure fitted well in the map (Table  S1 ). In order to gain insight into the molecular determinants mediating the baseplate-baseplate interface, we fitted the structure of one RBP trimer bound to three VHH5 (RBP3-VHH53) (PDB ID 2BSE;  [11] ) and generated D6 symmetry-related VHH5 copies to fill in the whole baseplate-baseplate interface (Table  S1 ). The resulting structural model indicates that the baseplate-baseplate interface mainly relies on contacts between opposite (RBP3-VHH53) tripods (Figure  4E ).
The main variations between both 3D reconstructions are located in the Tal density, as confirmed by Viruses 2020, 12, 878 9 of 12 the difference map (Figure  6A-C ). Our topological model of the activated baseplate with an opened Tal trimer (Figure  5B ) fits well in the 3D reconstruction with an opened Tal (Figure  6E ), while it leaves an empty density in the 3D reconstruction with the closed Tal (Figure  S2B, D ). Therefore, we also produced a topological model of the activated baseplate with a closed Tal trimer including the Dit-1, Dit-2, and RBPs from the activated baseplate and the Tal trimer form the baseplate resting state (PDB ID 2WZP). This model fits well in the 3D reconstruction with a closed Tal (Figure  6D ), while it is out of density in the 3D reconstruction with an opened Tal (Figure  S2A, C ).
The above results indicate that the RBP conformational changes from their resting to activated state is not correlated to the opening of the Tal trimer (Figure  6F ). Viruses 2020, 12, x FOR PEER REVIEW 9 of 12 resolution, respectively. The main variations between both 3D reconstructions are located in the Tal density, as confirmed by the difference map (Figure  6A-C ). Our topological model of the activated baseplate with an opened Tal trimer (Figure  5B ) fits well in the 3D reconstruction with an opened Tal (Figure  6E ), while it leaves an empty density in the 3D reconstruction with the closed Tal (Figure  S2B, D ). Therefore, we also produced a topological model of the activated baseplate with a closed Tal trimer including the Dit-1, Dit-2, and RBPs from the activated baseplate and the Tal trimer form the baseplate resting state (PDB ID 2WZP).
12,  x FOR PEER REVIEW 8 of 12 opposite to the capsid) (PDB ID 2X53, blue), fitted in the map. Surfaces of VHH5 (PDB ID 2BSE [11] ) in contact with the upper RBPs (yellow) and lower RBPs (orange) are also shown. (E) Surface representation of the VHH5-bound RBPs from the upper and lower baseplates as shown in D. Note that VHH5 in the upper baseplate (yellow) interact with VHH5 in the lower baseplate (orange).
Funding: This research was funded in part by  A. N. R French Infrastructure for Integrated Structural Biology (FRISBI) , grant number. ANR-10-INSB-05-01. SM acknowledges funding from the  Natural Sciences and Engineering Research Council of Canada (NSERC)  as well as the PROTEO and Op+Lait strategic networks from the  Fonds de Recherche du Québec-Nature et Technologies (FRQNT). SM holds a Tier 1  Canada Research Chair in Bacteriophages.
Viruses 2020 , 2020 12,  x FOR PEER REVIEW 8 of 12 opposite to the capsid) (PDB ID 2X53, blue), fitted in the map. Surfaces of VHH5 (PDB ID 2BSE [11] ) in contact with the upper RBPs (yellow) and lower RBPs (orange) are also shown. (E) Surface representation of the VHH5-bound RBPs from the upper and lower baseplates as shown in D. Note that VHH5 in the upper baseplate (yellow) interact with VHH5 in the lower baseplate (orange).
No Pareto front, as used in  [11] , is obtained since the second indicator is mandatory. In this work, a system approach is needed for the battery model, in order to enable implementation in standard electrical engineering software (Saber, Matlab/Simulink, etc. ) for analysis, identification, sizing, and on-line diagnosis. In our case, the battery model is intended to be implemented in the GE Power real-time simulator. The objective of this simulator is to create, modify, and optimize the control of the whole hybrid power plant. Therefore, the requirement for the storage system is a quite reduced-order model, configurable with supplier datasheet, with good accuracy on battery voltage and state of charge (>95%) and a fast-computational time. In electrical engineering, battery models are often based on equivalent electrical circuits.
On a system that exposes disjoint memory spaces to the software, a program has to address memory consistency issues and perform data transfers so that it always accesses valid data. Several approaches exist to ensure the consistency of the memory accessed. Here we are interested in the verification of a declarative approach where each component of a computation is annotated with an access mode declaring which part of the memory is read or written by the component. The programming framework uses the component annotations to guarantee the validity of the memory accesses. This is the mechanism used in VectorPU, a C++ library for programming CPU-GPU heterogeneous systems. This article proves the correctness of the software cache-coherence mechanism used in VectorPU. Beyond the scope of VectorPU, this article provides a simple and effective formalisation of memory consistency mechanisms based on the explicit declaration of the effect of each component on each memory space.
VectorPU In heterogeneous systems with separate address spaces, for example in many GPU-based systems, a general-purpose processor (CPU) with direct access to main memory is connected by some network (e. g. , PCIe bus) to one or several accelerators (e. g. , GPUs) each having its own device memory, see Figure  1. Native programming models for such systems such as CUDA typically expose the distributed address spaces to the programmer, who has to write explicit code for data transfers and device memory management. Often, programs for such systems must be organized in multiple source files as different programming models and different toolchains are to be used for different types of execution unit. This enforces a low-level programming style. Accordingly, a number of single-source programming approaches have been proposed that abstract away the distribution by providing a virtual shared address space.
Examples include directive-based language extensions such as OpenACC and OpenMP4. 5, and C++-only approaches such as the library-based skeleton programming framework SkePU  [1]  and the recent macro-based framework VectorPU. VectorPU  [4]  is an open-source 2  lightweight C++-only high-level programming layer for writing single-source heterogeneous programs for Nvidia CUDA GPU-based systems. Aggregate operand data structures passed into or out of function calls are to be wrapped by special data containers known to VectorPU. VectorPU currently provides one generic data container, called vector<. >, with multiple variants that eliminate the overhead of managing heterogeneity and distribution when not required (e. g. , when no GPU is available). vector<. > inherits functionality from STL vector and from Nvidia Thrust vector, and wraps a C++ array allocated in main memory.
For example, in contrast, SkePU  [3]  overloads element access and iterator operations so that monitored accesses are also possible on demand in non-componentized (i. e. , ordinary C++) CPU code. VectorPU only relies on access mode annotations to perform lazy data transfer, not knowing when data is going to be accessed inside a component. Table  1  summarizes the access mode annotations currently defined for Vec-torPU. The access mode specifiers, such as R (read on CPU), W (write on CPU), RW (update, i. e. , both read and write, on CPU), GR (read on GPU) and so forth, are available both as annotations of function signatures and as C++ preprocessor macros that expand at compilation into (possibly, device-specific) C++ pointer expressions and side effects that allow to generate device specific access code and use device-specific pointer types for the chosen execution unit.
Implementation Notes Coherence protocol. In the source code of VectorPU, the code relevant for our work is the part of vectorpu. h 4 that handles coherence. Its implementation for the various variants of vector (see the code excerpt in Fig. 3  for simple vectors) follows a simple valid-invalid protocol. Expansion of macro annotations to device-specific pointers. For function parameters, the macro annotations expand into appropriate C code to fit their function call context. For illustration, we show the simplified code after a function parameter's expansion (-→) for four typical annotations, where vx refers to a VectorPU vector instance: Hence, each annotated parameter is expanded to some code snippet  5. In all scenarios the expanded macros first update the coherence state according to the annotation's semantics.
Efficiency Using only available C++(11) language features, VectorPU provides a flexible unified memory view where all data transfer and device memory management is abstracted away from the programmer. Nevertheless, its efficiency is on par with that of handwritten CUDA code containing explicit data movement and memory management code  [4]. In particular, the VectorPU prototype was shown to achieve 1. 4x to 13. 29x speedup over good quality code using Nvidia's Unified Memory API on several machines ranging from laptops to supercomputer nodes, with Kepler and Maxwell GPUs. For a further discussion of VectorPU features, such as specialized versions of vector, for descriptions of how to use VectorPU together with lambda expressions e. g. to express skeleton computations, and for further experimental results we refer to  [4].
A Formalization for Reasoning on Consistency in VectorPU In this section we provide a minimal calculus to reason on the memory operations that can exist in a framework that deals with memory consistency like VectorPU. We first define a set of effects that operations can have on the consistency of the memory. Then we define a small calculus expressing different memory accesses and their composition into complex procedures. Finally, we express VectorPU operations as higher-level statements that can be translated into the core calculus, and show that if all memory accesses are annotated correctly through VectorPU annotations the program cannot try to access an invalid data and the memory spaces are put in coherence when needed. We also show that VectorPU tracks the validity status of the memory adequately.
A language for modelling consistency and effects We now create a core calculus to reason on programs involving sequences of effects on different memory locations. x, y range over variables and we introduce statements manipulating variables. We use sequence and simple loops and conditionals. Operations with effects now apply to a variable: E x denotes some operation E on variable x; rem(E x) is a remote operation on the remote memory. We also have a Noop operation that has no effect and can be considered as a neutral element for the sequence. Statements S are defined as: S ::= E x | rem(E x) | S; S | While(cond)S | if (cond) S else S | Noop Example: A GPU procedure writing x and reading y would correspond to the pseudo-code: rem(w x); rem(r y). We are interested in conditionals dealing with the validity status of the variables.
Abstract variables are not part of the applicative code but can be used in the access mode declarations. Consider for example an array x. As it is not desirable to store the information of the validity status of all the elements of the array, we will create for this array and abstract variable x # that will represent all the elements of the array -x[i] -from the validity status point of view. If the representation was precise, a value (V, I) for x # would mean that all the elements of the array are valid locally and invalid remotely. In practice we need to authorize some approximation of the validity status, at least because most operations only act on some of the elements of the array. Consequently, some information is lost in the abstract representation: if σ(x # ) = (V, I) then each element of the array x must be locally valid, the remote elements may be valid or invalid.
The validity conditions are checked on the abstract value, which corresponds to the fact that VectorPU only check the status of the coherency flag stored with the vector structure; push/pull operations are performed twice: once for representing the data-transfer, and once for representing the validity status update. Finally, status is updated when writing operations are declared. When evaluating a program we create a store where the validity status of real and abstract variables are (V, I), corresponding to the fact that data is initially placed in one memory location; typically, in VectorPU, in the CPU memory space.
Note that a well-declared program does not perform synchronisation operations (Push or Pull ) manually, these operations are only performed when evaluating the access mode declarations. Also each variable accessed by a welldeclared function has an abstract representative in the corresponding declaration block. A direct consequence of the definition above is that a well-declared program cannot access, in the same function, the same variable in both address spaces. This is in accordance with VectorPU where each function is entirely executed either on a CPU or on a GPU, the formalisation is a bit more generic on this aspect. This is expressed by the following property. Property 3 (Localised access). Consider a well-declared program containing M{S}, for any x, we cannot have rem(E x) ∈ S and E x ∈ S.
Proof. This is a consequence of the uniqueness of abstract variables in access mode declarations. Indeed, if E x ∈ S and the program is well-declared, then there must be R x # or W x # or RW x # in M. Similarly, as rem(E x) ∈ S, if the program is well-declared rem(R x # ) or rem(W x # ) or rem(RW x # ) in M, it is impossible to have two different entries for the same variable and thus we cannot have rem(E x) ∈ S and E x ∈ S. We now state and prove the two major properties ensured by our formalisation. The first property ensures that the abstraction is correct relatively to the execution. This corresponds to the fact that VectorPU tracks adequately the validity status of the memory. This is expressed as a theorem that is similar to subject-reduction in type systems, it states that if the status of the abstract variables represent correctly the validity status of the real variables, then the abstraction is also correct after the execution of a well-declared function.
Proof. Notice that dom(σ ) = dom(σ), and if σ(x) = (V, I) or σ(x) = (I, V ) then σ(x) = σ(x # ), else σ(x) = (V, V ). We reason on the read and write access that occur in the considered reduction. Each variable x is either read or written or not accessed (or read and written). For each case we compare the status of abstract and local variable, and in particular we consider the status of the reduction after executing the synchronisation code M{S} and call σ s the corresponding store (note that σ s (x # ) = σ (x # )). We detail operations on the local address space, cases for remote operations are similar: • If x is written, we have: ( M{S} , σ) → * (w x; S , σ ) → * (Noop, σ ). Whatever the initial value of σ(x), we have σ (x) = (V, I). Two cases are possible: (1) W x # ∈ M then the value cannot be read and we have σ s (x # ) = (V, I).