F Cazals

T Dreyfus

The Structural Bioinformatics Library: modeling in biomolecular science and beyond

Keywords: Structural bioinformatics, Scientific software, Software libraries La Structural Bioinformatics Library: modélisation des systèmes biomolécules et au-delà .inria.fr Bioinformatique structurale, logiciel scientifique, librairie scientifique The Structural Bioinformatics

Motivation: Software in structural bioinformatics has mainly been application driven. To favor practitioners seeking off-the-shelf applications, but also developers seeking advanced building blocks to develop novel applications, we undertook the design of the Structural Bioinformatics Library (SBL, http://sbl.inria.fr), a generic C++/python cross-platform software library targeting complex problems in structural bioinformatics. Its tenet is based on a modular design offering a rich and versatile framework allowing the development of novel applications requiring well specified complex operations, without compromising robustness and performances. Results: The SBL involves four software components (1-4 thereafter). For end-users, the SBL provides ready to use, state-of-the-art (1) applications to handle molecular models defined by unions of balls, to deal with molecular flexibility, to model macro-molecular assemblies. These applications can also be combined to tackle integrated analysis problems. For developers, the SBL provides a broad C++ toolbox with modular design, involving core (2) algorithms, (3) biophysical models, and (4) modules, the latter being especially suited to develop novel applications. The SBL comes with a thorough documentation consisting of user and reference manuals, and a bugzilla platform to handle community feedback.

Computational structural biology is concerned with the investigation of the relationship between the structure and dynamics of biomolecules on the one hand, and their function on the other hand. The questions in this realm are especially challenging due to the dynamic nature of the phenomena studied, the time-scales involved, and the size of systems, which vary from small molecules or peptides to large assemblies involving hundreds of macro-molecules. Another source of complication is the hybrid nature of the relevant data, as insights on complex systems typically mix experiments (X ray crystallography, NMR, electron microscopy, mass spectrometry) and modeling. This state of affairs is such that a very large number of software applications and libraries have been developed in structural bioinformatics, with more than 350 classified at http://www.ks.uiuc.edu/Development/biosoftdb/biosoft.cgi. In this offer, several large software tools stand out. Platforms such as MODELLER ( [START_REF] Webb | Comparative protein structure modeling using modeller[END_REF] and http://salilab.org/modeller), Rosetta ( [START_REF] Leaver-Fay | ROSETTA3: an object-oriented software suite for the simulation and design of macromolecules[END_REF] and https://www.rosettacommons.org/software), or the Integrative Modeling Platform ( [START_REF] Webb | Structural genomics: General applications[END_REF] and https://integrativemodeling.org) enabled notable scientific advances in biophysics and computational biology. Docking algorithms at large are invaluable to predict the structure of complexes ( [START_REF] Halperin | Principles of docking: An overview of search algorithms and a guide to scoring functions[END_REF] and https://en.wikipedia.org/wiki/Docking_(molecular)).

Force fields and the associated simulation platforms, including CHARMM ( [START_REF] Brooks | CHARMM: A program for macromolecular energy, minimization, and dynamics calculations[END_REF] and https://www. charmm.org), AMBER ( [START_REF] Salomon-Ferrer | An overview of the Amber biomolecular simulation package[END_REF] and http://ambermd.org), NAMD ( [START_REF] James C Phillips | Scalable molecular dynamics with namd[END_REF] and http://www.ks.uiuc.edu/ Research/namd), GROMACS ( [START_REF] Van Der | GRO-MACS: fast, flexible, and free[END_REF] and http://www.gromacs.org), or the Cambridge suite software suite for energy landscapes ( [START_REF] Wales | Energy Landscapes[END_REF] and http://www-wales.ch.cam.ac.uk/software.html), proved invaluable to study the dynamics of (bio-)molecules. Likewise, molecular visualization programs such as VMD ( [START_REF] Humphrey | VMD: visual molecular dynamics[END_REF] and http://www.ks.uiuc.edu/Research/vmd), Pymol ( [START_REF] Warren | The pymol molecular graphics system[END_REF] and https://www. pymol.org/), Chimera ( [START_REF] Eric F Pettersen | UCSF chimera-a visualization system for exploratory research and analysis[END_REF] and https://www.cgl.ucsf.edu/chimera/), or SAMSON (http:// www.samson-connect.net) leverage the analysis of simulation results. Finally, BioPython ( [START_REF] Hamelryck | Pdb file parser and structure class implemented in python[END_REF] http://biopython.org/) provides several tools in the realm of computational biology-even if its focus is not on structure.

Software design

The aforementioned software environments are major scientific achievements. However, they usually do not clearly disentangle the end-user applications solving well specified biophysical problems, and the underlying low level algorithmic classes. This in turn hinders the design of software solutions combining complementary building blocks from various sources, as no unified design principle is common to most libraries.

To change the state of affairs, we undertook the design and development of the Structural Bioinformatics Library (http://sbl.inria.fr), a highly modular software library matching the best standards in two directions. On the one hand, similarly to the previously cited environments, the SBL offers end-user applications with state-of-the-art performances. On the other hand, these applications are based on low-level algorithmic classes whose design matches that of comprehensive C++ libraries such as the Computational Geometry Algorithms Library (CGAL, http://www.cgal.org) or the boost C++ libraries (http://www.boost.org/). This unique combination makes it possible to develop novel challenging applications, by reusing highly parameterized software components. In the sequel, we present the main software components geared towards end-users and developers. The SBL for end-users

Rationale

From the structural bioinformatics standpoint, the SBL aims to provide reference methods solving specific problems. The methods are grouped by-so called applications, themselves ascribed to categories depending on the models manipulated (for the Applications page of the web site, see http://sbl.inria.fr/applications/; for the Applications page from the on-line documentation, see http://sbl.inria.fr/doc/group__sbl-applications.html; see also Fig. 1). The groups of applications are:

• Space filling models: applications dealing with molecular models defined by unions of balls, e.g. van der Waals or solvent accessible models [START_REF] Gerstein | Protein geometry: volumes, areas, and distances[END_REF]. Prototypical applications provide interface modeling (Figs. 1(A) and 2, [START_REF] Cazals | Revisiting the Voronoi description of protein-protein interfaces[END_REF][START_REF] Cazals | Revisiting the Voronoi description of protein-protein interfaces: Algorithms[END_REF][START_REF] Loriot | Modeling macro-molecular interfaces with Intervor[END_REF]), the calculation of molecular surfaces and volumes [START_REF] Loriot | A geometric knowledge-based biogeomgrained scoring potential for structure prediction evaluation[END_REF][START_REF] Cazals | Computing the volume of union of balls: a certified algorithm[END_REF], or the design of coarse grain models [START_REF] Cazals | Greedy geometric algorithms for collections of balls, with applications to geometric approximation and molecular coarse-graining[END_REF].

• Conformational analysis: applications dealing with molecular flexibility [START_REF] Wales | Energy Landscapes[END_REF][START_REF] Bowman | An introduction to markov state models and their application to long timescale molecular simulation[END_REF]. Reference methods are provided to sample potential energy landscapes [START_REF] Roth | Hybridizing rapidly growing random trees and basin hopping yields an improved exploration of energy landscapes[END_REF] (Fig. 1(B)), to analyze and compare ensembles of conformations and sampled energy landscapes [START_REF] Cazals | Conformational ensembles and sampled energy landscapes: Analysis and comparison[END_REF][START_REF] Carr | Energy landscapes and persistent minima[END_REF]. Future additions will focus on novel methods to compute thermodynamic and kinetic properties of bio-molecular systems, with a focus on Monte Carlo based methods (in particular Wang-Landau type algorithms to compute densities of states [START_REF] Landau | A guide to Monte Carlo simulations in statistical physics[END_REF]), as well as methods exploiting the formalism of energy landscapes [START_REF] Wales | Energy Landscapes[END_REF].

• Large assemblies: applications dealing with macro-molecular assemblies involving from tens to hundreds of subunits [START_REF] David S Goodsell | The machinery of life[END_REF]. Particularly noticeable is the application inferring contacts between subunits of a large assembly from native mass spectrometry data [START_REF] Benesch | Protein complexes in the gas phase: technology for structural genomics and proteomics[END_REF], as it doubles performances of competing methods [START_REF] Agarwal | Unveiling contacts within macromolecular assemblies by solving minimum weight connectivity inference problems[END_REF] (Fig. 1(C)). Future additions will focus on methods to assess [START_REF] Dreyfus | Assessing the reconstruction of macro-molecular assemblies with toleranced models[END_REF][START_REF] Dreyfus | Probing a continuum of macro-molecular assembly models with graph templates of sub-complexes[END_REF] models stemming from reconstruction by data integration [START_REF] Alber | Integrating diverse data for structure determination of macromolecular assemblies[END_REF][START_REF] Webb | Structural genomics: General applications[END_REF].

• Integrated analysis: Applications combining several ingredients from the previous groups. An application is provided to estimate binding affinities of protein complexes, with state-of-the-art results [START_REF] Marillet | High resolution crystal structures leverage protein binding affinity predictions[END_REF] on the reference structure-affinity benchmark [START_REF] Kastritis | A structure-based benchmark for protein-protein binding affinity[END_REF] (Fig. 1

(D)).

To ease the reproducibility of computer experiments, the SBL also proposes specific data management and analysis methods:

• Data Management: applications easing data management in large scale computer experiments.

• Data Analysis: applications providing novel data analysis -statistical analysis tools.

Using selected of these applications is especially easy, since an auto-installation script (available at http://sbl.inria.fr/applications/) makes them directly available under VMD and Pymol. For example, under VMD, the interface analysis of Fig. 2 are readily reproduced using the applications available from the menu Extensions > SBL > Intervor > { sbl_intervor_ABW_atomic, sbl_intervor_IGAgW_atomic }. More generally, the user manual of each application provides a detailed documentation, with in particular input files, output files, and command lines with full lists of options.

Key features

From the software design standpoint, all applications meet the best practices of modern large scale software libraries:

• Versatility. In the SBL, an application is a set of programs characterized by inputs and outputs obeying the same semantics. We illustrate this on the problem of modeling macro-molecular interfaces (Fig. 2). Intuitively, an interface between two partners separates these partners, and should therefore be oblivious to their nature (proteins, nucleic acids, metabolites, etc) or resolution (at interface may be defined at any resolution). Also, the notion of interface should cover cases where the partners have a specific structure. For example, in modeling an antibody -antigen complex, the antibody fragment antigen binding domain (FAB) may be decomposed hierarchically into domains from the heavy and light chains, or into so-called complementarity determining regions and framework regions. The SBL handles all such cases at once, making it possible to study a given object at different levels of details, or to study objects with the same semantic using the same concepts. The case of interfaces is explained in the documentation at http://sbl.inria.fr/doc/Space_filling_model_interface-user-manual.html. More generally, the derivation of programs within a given application is explained in section 3.

• Documentation. Each application comes with a detailed user manual, stating the main goals, defining the pre-requisites, and specifying the inputs and outputs. Moreover, example runs of the programs are provided, together with the associated input and output files.

• Specifications and workflows. All applications come with a sharp specification of pre-requisites, inputs and outputs. Most importantly, each application comes with a workflow, namely a graph specifying the sequence of operations, each undertaken by a so-called module (Fig. 3 and section 3). The workflow of an application is automatically generated by this application, which guarantees coherence with the source code and the claimed functionalities. It is instrumental to view the application at a glance, and to design data processing pipelines.

• Perennial data formats. Programs from the SBL generate results in perennial data format, in particular XML. The hierarchical structure of XML, in conjunction with the XPath query language, allows automating data storage, parsing and retrieval, so that upon running calculations with applications, statistical analysis and plots are a handful of Python lines away. This also allows a trivial coupling with data analysis modules provided in Scikit-learn (http: //scikit-learn.org/stable/) or R (https://www.r-project.org/).

• Reproducibility. A critical point in bioinformatics is the ability to reproduce results [START_REF] Vihinen | No more hidden solutions in bioinformatics[END_REF]. To this end, the SBL provides tools to configure, execute and repeat large scale computer experiments. Automating computer experiments is of paramount importance in particular when randomness is at play, e.g. in cross validation experiments, Monte Carlo based exploration of conformational spaces, or non convex optimization.

• Visualization. Whenever relevant, applications from the SBL are coupled to visualization plugins for VMD and PyMol. In fact, automatic installation scripts are provided for these two environments (http://sbl.inria.fr/applications/), so that all executables from the SBL are two clicks away from the VMD and PyMol menus.

• Ability to handle complex multi-scale biophysical problems. Broadly speaking, the modeling problems faced in structural bioinformatics may be ascribed to three categories. Atomic resolution models aim at unveiling fine structural and dynamical properties of molecules or (small) complexes. Such models typically require modeling the flexibility of molecules, to obtains thermodynamic and/or kinetic descriptors [START_REF] Wales | Energy Landscapes[END_REF][START_REF] Bowman | An introduction to markov state models and their application to long timescale molecular simulation[END_REF]. Coarse-grain models aim at unveiling the structure of larger systems, by giving access to the overall shape, and possibly to pairwise contacts within an assembly. Such models typically rely on various experimental data such as mass spectrometry, cryo electron microscopy or SAXS data [START_REF] Alber | Integrating diverse data for structure determination of macromolecular assemblies[END_REF][START_REF] Webb | Structural genomics: General applications[END_REF]. Finally, hybrid models aim at approaching atomic resolution models, by combining low resolution models of an assembly with high resolution structures of subunits [START_REF] Amir | Dockstar: a novel ilp-based integrative method for structural modeling of multimolecular protein complexes[END_REF].

Inria

Most of the problems in these three realms can be tackled using two types of representations, based on union of balls on the one hand (van der Walls, solvent accessible models, coarse grain models), and coordinate based representations on the other hand (internal coordinates or Cartesian coordinates). The SBL provides such formats, with easy conversion between them-from a geometric standpoint, so as to foster inter-connections between atomic resolution, low resolution, and hybrid models.

• Robustness and performances. Structural data are geometric in nature, which requires handling possibly degenerate situations so as to guarantee robustness and accuracy of results. To see why, consider the seemingly simple problem of computing the volume of a molecule, so as e.g. to assess the atomic packing properties. This calculation is generally undertaken using floating point numbers, which typically yields errors of 5-10% [START_REF] Loriot | A geometric knowledge-based biogeomgrained scoring potential for structure prediction evaluation[END_REF][START_REF] Cazals | Computing the volume of union of balls: a certified algorithm[END_REF]. The SBL resorts to numerically certified operations instead, which warrants robust programs and accurate results. This entails using appropriate number types (with arbitrary precision, interval number types) when appropriate. Likewise, the algorithms have been optimized, so as to guarantee that their complexity scales ideally as a function of the data size.

• Modularity and extensibility. Addition of new applications is especially easy, due to the coherence between the representations just discussed, and the highly modular structure of the library as detailed below.

• Interoperability. Applications are inter-operable in three respects. First, standard file formats are used as input. The PDB format is generally used for molecular conformations. But all algorithms are templated by so-called loaders, which makes it especially easy to import data from any (custom) format. Second, results are stored in XML files, to ease the integration of applications within bioinformatics pipelines. Third, on the programming side, the source code can be directly embedded into external applications, as detailed below.

3 The SBL for developers

Rationale

In the perspective of software development, the design of the SBL has been guided by two main principles. The first one is to provide a broad C++/python toolbox, fostering code re-usability and the development of complex applications with clear workflows. In a nutshell, C++ is used whenever generic classes are in order-see our description of template based design in section 3.2. The second is to offer a modular design fostering the integration and exchange of core building blocks, be they from computer science or biophysics. These principles aim at accommodating the complexity of software in structural bioinformatics, which inherently mixes two difficulties. The first one relates to the variety of models used in biophysics at large, namely models from physics (e.g., potential and free energy models), chemistry (e.g., force fields), and biology (e.g., sequence -structure information, functional annotations, etc). The second one pertains to the variety of concepts and algorithms essentially covering the whole spectrum of computer science and applied mathematics, including combinatorial algorithms and data structures (e.g., sorting and searching methods, graph algorithms), numerics (e.g, number types, optimization methods), geometric and topological methods (e.g., Delaunay and Voronoi representations, spatial search data structures), data analysis.

Through its modular design, the SBL fosters the integration of software components in these two realms, which also warrants code re-usability and the development of novel applications.

Structure of the SBL

To further describe the structure of the SBL (Fig. 4), some familiarity with generic software in general and C++ in particular is essential [START_REF] Alexandrescu | Modern C++ design: generic programming and design patterns applied[END_REF]. In C++, a template class is a class accommodating different data types providing the same pre-requisites, upon so-called instantiation. For example, a simple list may be a list of integers, floats, proteins, complexes, etc. This mechanism avoids rewriting basic classes for specific types. The requirements of a template class are concepts, a concept being a set of types and methods. A model for a concept is a class implementing these types and methods. Within the SBL, we distinguish two categories of template parameters: (i) the internal types, namely concepts for which default models are provided, and (ii) the external types, namely concepts depending on the software component developed. This classification also simplifies the instantiation of template classes, since external types are grouped within traits classes. (In particular, this is always the case for the so-called modules, see below.)

This said, the structure of the SBL is as follows:

• SBL-APPLICATIONS: applications solving specific applied problems, as described in section 2.

• SBL-CORE: C++ classes providing (advanced) algorithms, ascribed to four tiers: CADS: Combinatorial Algorithms and Data Structures, GT: Computational geometry and computational topology, CSB: Computational Structural Biology, IO: Input / Output. Selected classes are templated by traits classes specifying C++ concepts, namely requirements in terms of functionalities.

• SBL-MODELS: C++ models coding physical and/or chemical and/or biological knowledge. These classes typically match the C++ concepts required to instantiate those classes from SBL-CORE which are templated.

• SBL-MODULES: C++ classes instantiating classes from SBL-CORE with specific biophysical models from SBL-MODELS. A module may be seen as a black box transforming an input into an output. With modules, an application workflow is merely a graph of interconnected modules, whose automatic traversal generates the application workflow.A module is provided for a package in SBL-CORE when the corresponding algorithms are key steps of an application from SBL-APPLICATIONS. There are currently 15 modules scattered over 13 SBL-CORE packages, as listed at http://sbl.inria.fr/doc/group__sbl-core-modules.html.

Development of novel programs and applications

Using the structure just discussed, several types of developments can be undertaken.

Recall that an application is a set of programs characterized by inputs and outputs obeying the same semantics. We handle such invariants using generic software design techniques in C++. More precisely, each application is developed using generic concepts resorting to template parameters. For an existing application, a novel program may be obtained by replacing a template parameter by another one sharing the prescribed specifications. For example, given the C++ skeleton of our application dissecting macro-molecular interfaces (Fig. 2), deriving a novel program taking into account specific features of antibodies merely requires replacing the class labeling the atoms of the two partners by a class which in addition ascribes the atoms of the IG to its heavy and light chains. Phrased differently, deriving the new program requires changing one type specification and recompiling.

Inria

Novel applications may be developed in two ways. The easiest route consists of combining (pooling) existing modules, as exemplified in the supplementary section 6.. A more challenging route, for experienced C++ programmers, consists in instantiating classes from SBL-CORE (existing ones or novel ones) with models from SBL-MODELS (existing ones or novel ones).

Low level developments

Basic algorithms provided in SBL-CORE underlie essentially all complex data processing tasks, which we illustrate with three examples. In the Space Filling Models group of applications, most of the software components rely on Voronoi diagrams and so-called α-shapes [START_REF] Edelsbrunner | Geometry and topology for mesh generation[END_REF], which provide parameter free models of macro-molecules structures and their complexes. Such calculations are notoriously difficult from the combinatorial and numerical standpoint, and our solution relies on a mix of packages from CGAL and developed in the CADS tier of SBL-CORE. For applications dealing with Conformational Analysis, a critical operation to deal with large ensembles of conformations is to perform so-called nearest neighbor queries [START_REF]Nearest-Neighbors Methods in Learning and Vision[END_REF], to report e.g. the conformation in a set most similar to a query conformation. Depending on the metric used, these operations require advanced algorithms in metric spaces, which are provided again within CADS tier of SBL-CORE. Finally, in the Large assemblies group, a key problem is to accommodate uncertainties on models. A fundamental tool to assess stable geometric and topological features of such models is topological persistence [START_REF] Edelsbrunner | Computational topology: an introduction[END_REF], and again, the SBL provides several key algorithms in this realm, e.g. used in the mode seeking based clustering algorithm [START_REF] Chazal | Persistence-based clustering in Riemannian manifolds[END_REF].

It should also be stressed that the modular structure of the SBL makes it simple to replace one building block by another one, provided coherent specifications.

License, releases, distribution

The SBL is released under a proprietary open source license, see http://sbl.inria.fr/license/. In a nutshell, academic users can use and modify the code at their discretion, for research purposes -commercial exploitation of the SBL requires a specific license. Contributions from the outside are also welcome, provided that they comply with the development philosophy. One such example is the Apurva package (http://sbl.inria.fr/doc/group__Apurva-package.html), which provides reference methods to perform structural alignments [START_REF] Wohlers | CSA: Comprehensive comparison of pairwise protein structure alignments[END_REF].

The source code is distributed from http://sbl.inria.fr, using tarballs and a git repository. Full support via a Bugzilla interface is provided for linux and MacOS. For windows, individual executables were compiled and tested, but full support is not provided since scripts and plugins were not thoroughly tested.

Applications can be directly downloaded and installed from http://sbl.inria.fr/applications/, and the whole documentation is available at http://sbl.inria.fr/documentation-and-tutorials/.

Discussion

High quality applications

Having presented the structure of the SBL, we argue that the high quality applications provided rely on the combination of two features, namely a careful specification of the mathematical properties of the algorithms used, and an advanced C++ design which makes it possible to couple elaborate building blocks. We provide one illustration for each group of applications.

Space filling models. Consider the application computing molecular surfaces and volumes, see http://sbl.inria.fr/doc/Space_filling_model_surface_volume-user-manual.html. Classical contenders typically resort to float or double number types to do so, typically yielding errors measured in percents [START_REF] Cazals | Computing the volume of union of balls: a certified algorithm[END_REF], a fact inherent to the rounding of floating point numbers. Our application provides certified results, a property stemming from the instantiation of low-level algorithms from SBL-CORE with number types equipped with guarantees (types with arbitrary precision, interval number types).

Conformational analysis. Consider the application exploring potential energy landscapes (PEL) of biomolecular systems, see http://sbl.inria.fr/doc/Landscape_explorer-user-manual. html. For (models of) biomolecules, PEL typically involve a very large number of local minima [START_REF] Roth | Hybridizing rapidly growing random trees and basin hopping yields an improved exploration of energy landscapes[END_REF][START_REF] Carr | Energy landscapes and persistent minima[END_REF]. The efficient exploration of such landscapes requires efficient algorithmic components (random sampling, exploration of high dimensional space, location of nearest neighbors in metric spaces), coupled with the biophysical models (potential energy) scrutinized. In the SBL, deriving new exploration programs is especially easy, since one merely needs to instantiate the required low-level algorithms from SBL-CORE with biophysical models form SBL-MODELS.

Large assemblies.

A key difficulty in modeling large assemblies is to harness the uncertainties inherent to coarse-grain models. In the SBL, this is done by putting the emphasis on the quality of geometric approximations, and on the enumeration of solutions achieving optimal scores. For example, for coarse grain modeling, see http://sbl.inria.fr/doc/Space_filling_model_ coarse_graining-user-manual.html, the SBL provides the only algorithms producing models with volumetric approximation guarantees, a fact stemming from insights on the NP-complete problems solved. In a different realm, in inferring pairwise contacts for native mass spectrometry data, see http://sbl.inria.fr/doc/Connectivity_inference-user-manual.html, our connectivity inference methods enumerate all optimal solutions, which avoids arbitrariness in the solutions exploited. Integrated analysis. Consider the problem of estimating binding affinities from structural data, see http://sbl.inria.fr/doc/Binding_affinity_prediction-user-manual.html. By combining several constructions provided by programs from the space filling model group, the application provided delivers state-of-the-art affinity predictions, with accuracy typically better than 1.4 kcal/mol [START_REF] Marillet | High resolution crystal structures leverage protein binding affinity predictions[END_REF].

Towards more integration and further applications

The architecture just discussed can be beneficial to design involved applications in molecular science and beyond.

In molecular science, several of our building blocks may be combined to develop novel hybrid and/or integrated models. As an illustrative example, one may consider the computation of absolute binding free energies via accurate thermodynamic calculations [START_REF] Woo | Calculation of absolute protein-ligand binding free energy from computer simulations[END_REF][START_REF] Gilson | Calculation of protein-ligand binding affinities[END_REF]. While such calculations are usually based on ab initio calculations using force fields, they could be hybridized with recently designed knowledge based parameters which were instrumental to obtain estimates of unprecedented accuracy [START_REF] Vangone | Contacts-based prediction of binding affinity in protein-protein complexes[END_REF][START_REF] Marillet | High resolution crystal structures leverage protein binding affinity predictions[END_REF]. The fact that the SBL provides both classes of methods is a significant asset to develop such models. Another example is the design and the assessment of models in the context of reconstruction by data integration [START_REF] Alber | Integrating diverse data for structure determination of macromolecular assemblies[END_REF], where the coupling of improved exploration functions for non convex functionals [START_REF] Roth | Hybridizing rapidly growing random trees and basin hopping yields an improved exploration of energy landscapes[END_REF] and delicate geometric and graph theoretical assessment methods [START_REF] Dreyfus | Assessing the reconstruction of macro-molecular assemblies with toleranced models[END_REF][START_REF] Dreyfus | Probing a continuum of macro-molecular assembly models with graph templates of sub-complexes[END_REF] may yield improved models.

Beyond molecular science, our low-level algorithms can naturally be used in a variety of contexts. A striking illustration is provided by geometric models based on union of balls, as such models are also encountered in material sciences (e.g. to represent materials and study their Inria properties), in geometric modeling (e.g. to represent shapes via the medial axis transform), in biomedicine (e.g. to represent approximations of discretized organs), in computer graphics (e.g. to define hierarchies of bounding volumes used in collision checking), or even in astrophysics (e.g. to study the topology of galaxies using α-shapes). In fact, our previous software Vorlume, computing surfaces and volumes of unions of balls Vorlume [START_REF] Cazals | Computing the volume of union of balls: a certified algorithm[END_REF] was used in all these contexts. With its generic design (section 2.2), the repackaged application Space_filling_model_surface_volume goes even further and makes it trivial to accommodate models based on union of balls whose semantics is arbitrary.

Outlook

Computer programming may be considered as an art, as a science, or both. Following Donald Knuth in his Turing award lecture [START_REF] Donald | Computer programming as an art[END_REF],

Science is knowledge that we understand so well that we can teach it to a computer; and if we don't fully understand something, it is an art to deal with it. . Later in his lecture, Knuth also mentions that a good program should (i) work correctly, (ii) be easy to change, (iii) allow graceful interaction with its users, and (iv) be efficient given the computer resources at hand. The development of software tools for structural bioinformatics in general and within the SBL in particular may be considered in light of these thoughts. The correctness is certainly critical, and calls for a careful specification of the inputs and outputs of a program, a tenet for every single application of the SBL. Correctness issues were actually considered down to the most exquisite levels, as all algorithms are parameterized by number types which may be adapted to match specific requirements. The ability to easily change a program to accommodate a new setting clearly calls for a versatile design. Advanced software design techniques relying on C++ templates offer such a flexibility, allowing a new program to be compiled by merely changing a type definition. Moreover, for end-users not versed into programming, a vast array of ready to use applications are provided. The graceful interaction with users stems from perennial data formats on the one hand, and the coupling with classical visualization systems on the other hand. Finally, the efficacy of applications is ensured by resorting to low level algorithms providing the best complexities, be they from the SBL itself or from external specialized libraries.

Summarizing, the SBL matches the four aforementioned requirements both for end-users and developers. In fact, it is to the best of our knowledge the first library doing so in structural bioinformatics. We anticipate that this unique design will prove invaluable, reducing the development of complex applications to a few days, as opposed to months starting from scratch. Naturally, we also anticipate that in combining insights obtained from complementary advanced modeling techniques such as the ones offered, stimulating views on complex bio-molecular systems will be obtained, and that these will in turn raise novel questions and hypothesis.

Our ambition for the near future is twofold. First, we shall expand the functionalities, both in terms of off-the shelf applications and low level algorithmic classes. Second, we shall welcome and integrate contributions from the community, provided that these comply with the development philosophy. (A) Group Space filling models: Space_filling_model_interface_finder. A package to seek interfaces of molecular assemblies. A graph is reported, with one node per subunit (chain or domain in a chain), and one edge per interface between any two subunits in contact. Each edge is decorated by the number of interface atoms and the number of patches. Each such interface can be studied in much mode detail (Fig. 2). (B) Group Conformational analysis: Landscape_explorer. A package providing Monte Carlo based algorithms (basin hopping, rapidly exploring random trees, hybrid algorithms) to explore potential energy landscapes of molecular systems. Shown here is a rapidly exploring random tree crawling along the valleys of a 2D mathematical landscape. (C) Group Large assemblies: Connectivity_inference. A package to perform connectivity inference between subunits of large assemblies, from native mass spectrometry data. Given a set of oligomers (one oligomer is one list of subunits, three of them are shown as colored polygons in subpanels (A,B,C)), pairwise interfaces between these subunits are inferred (subpanel D). (D) Group Integrated analysis: Binding_affinity_predictions. A package to perform binding affinity predictions from structures of partners and their complex. For high resolution structures, an accuracy on ∆G d circa 1 kcal/mol is achieved. illustration on the problem of modeling interfaces, http://sbl.inria.fr/doc/Space_filling_model_ interface-user-manual.html. An application is a set of programs characterized by inputs and outputs obeying the same semantics -modeling the interface between subunits of a complex in this example. From the applied standpoint, an interface is qualified by pairs of atom in contacts, interfacial solvent molecules, binding patches (i.e. connected components) together with their surface area and curvature, etc. Formally, an interface is parameterized by properties of the partners (defined by atoms or pseudo-atoms), as well as specific properties of these partners (i.e. the decomposition of a partner into groups of atoms). This parameterization allows investigating a variety of systems in a coherent way, by instantiating the same generic C++ code with different biophysical models. In the sequel, we illustrate this possibility by studying an antibody (IG)antigen complex at two levels of detail (PDB: 1vfb): by considering the IG as a whole, and by splitting its fragment antigen binding domain (FAB) into contributions from its heavy and light chains. (A) Interface atoms of the IG -Ag complex: blue (atoms of the IG), read (atoms of the antigen), gray (crystal water molecules sandwiched between the partners). NB: all atoms are displayed in their solvent accessible representation i.e. This workflow indicates that there are two steps in the application considered. The first one (compulsory), reports all pairwise interfaces found in the structure. The second one (optional), may be called to computed surface areas buried on each subunit. Note that these pieces of information are summarized on the graph reported (Fig. 1(A)).

(A) (B) (C) (D) Inria
Inria Figure 4 Overall architecture of the SBL. The SBL is organized in focus areas for end-users, developers, and contributors. For end-users, applications solve well specified biophysical problems (Figs. 1 and2). For developers, the SBL provides software components easing the development of novel applications (Fig. 3). For low level developers and contributors, the SBL proposes core algorithmic packages dedicated to specific processing (CADS: Combinatorial Algorithms and Data Structures, GT: Computational geometry and computational topology, CSB: Computational Structural Biology, IO: Input / Output.). The corresponding packages are interchangeable those from specific libraries, such as the BOOST C++ libraries or CGAL.

Supplemental

In section 6.1, we show how the development of a complex applications stems directly from the connexion of modules. As an example, we provide the code for a simplified version of our application computing surfaces and volumes (details at http://sbl.inria.fr/doc/Space_filling_model_surface_ volume-user-manual.html). While this simplified version computes the volume of a union of geometric balls without any specific meaning, the version from the SBL provides switches to handle this case and also that of atomic models, with complete control of the PDB format and its features (filtering hydrogen atoms, handling duplicates, filtering on occupancy factors, etc). In section 6.2, we show (i) how to use the batch manager to run multiple calculations (details at http://sbl.inria.fr/doc/Batch_manager-user-manual.html), and (ii) how to easily extract statistics using the application Python Analysis L Scale Experiments (PALSE, details at http://sbl.inria.fr/ doc/PALSE-user-manual.html). #i n c l u d e <SBL/ Models / G e o m e t r i c _ p a r t i c l e _ t r a i t s . hpp> #i n c l u d e <SBL/CSB/ Alpha_complex_of_molecular_model . hpp> // Alpha-complex module r e q u i r e m e n t s f o r dumping VMD and PyMOL // v i s u a l i z a t i o n f i l e s . #i n c l u d e <SBL/IO/ Alpha_complex_of_molecular_model_molecular_view . hpp> // T r a i t s c l a s s d e f i n i n g t h e t y p e s used by t h e modules s t r u c t T r a i t s { t y p e d e f SBL : : Models : : T _ G e o m e t r i c _ p a r t i c l e _ t r a i t s <> P a r t i c l e _ t r a i t s ; t y p e d e f s t d : : v e c t o r <P a r t i c l e _ t r a i t s : : P a r t i c l e _ t y p e > P a r t i c l e s _ c o n t a i n e r ; t y p e d e f SBL : : CSB : : T_Alpha_complex_of_molecular_model <P a r t i c l e _ t r a i t Running the executable. Assuming that the SBL library has been installed in a standard location, the following command lines respectively compile and execute the program : > mkdir b u i l d ; cd b u i l d ; > cmake . . ; make ; > . / s b l -vorlume-example . exe Note that if the library is not installed in a standard location, CMake has to know where is located the library, as specified in the documentation http://sbl.inria.fr/doc/sbl-devel-with-sbl-tutorial. html. This can be achieved in several ways, depending on your configuration :

• if the library is not installed at all : > cmake . .

Inria

2

 2

Figure 1

 1 Figure 1 Example end-user applications, see http://sbl.inria.fr/ > Applications.(A) Group Space filling models: Space_filling_model_interface_finder. A package to seek interfaces of molecular assemblies. A graph is reported, with one node per subunit (chain or domain in a chain), and one edge per interface between any two subunits in contact. Each edge is decorated by the number of interface atoms and the number of patches. Each such interface can be studied in much mode detail (Fig.2). (B) Group Conformational analysis: Landscape_explorer. A package providing Monte Carlo based algorithms (basin hopping, rapidly exploring random trees, hybrid algorithms) to explore potential energy landscapes of molecular systems. Shown here is a rapidly exploring random tree crawling along the valleys of a 2D mathematical landscape. (C) Group Large assemblies: Connectivity_inference. A package to perform connectivity inference between subunits of large assemblies, from native mass spectrometry data. Given a set of oligomers (one oligomer is one list of subunits, three of them are shown as colored polygons in subpanels (A,B,C)), pairwise interfaces between these subunits are inferred (subpanel D). (D) Group Integrated analysis: Binding_affinity_predictions. A package to perform binding affinity predictions from structures of partners and their complex. For high resolution structures, an accuracy on ∆G d circa 1 kcal/mol is achieved.

Figure 2

 2 Figure 2 On the versatility of applications from the SBL:illustration on the problem of modeling interfaces, http://sbl.inria.fr/doc/Space_filling_model_ interface-user-manual.html. An application is a set of programs characterized by inputs and outputs obeying the same semantics -modeling the interface between subunits of a complex in this example. From the applied standpoint, an interface is qualified by pairs of atom in contacts, interfacial solvent molecules, binding patches (i.e. connected components) together with their surface area and curvature, etc. Formally, an interface is parameterized by properties of the partners (defined by atoms or pseudo-atoms), as well as specific properties of these partners (i.e. the decomposition of a partner into groups of atoms). This parameterization allows investigating a variety of systems in a coherent way, by instantiating the same generic C++ code with different biophysical models. In the sequel, we illustrate this possibility by studying an antibody (IG)antigen complex at two levels of detail (PDB: 1vfb): by considering the IG as a whole, and by splitting its fragment antigen binding domain (FAB) into contributions from its heavy and light chains. (A) Interface atoms of the IG -Ag complex: blue (atoms of the IG), read (atoms of the antigen), gray (crystal water molecules sandwiched between the partners). NB: all atoms are displayed in their solvent accessible representation i.e. radii have been expanded by 1.4. (B) In green, the Voronoi interface from (A), which separates the partners. (C) Top view of the Voronoi interface from (B), with interfacial water molecules. (D) Interfacial atoms contributed by the heavy (blue) and light chain (cyan) of the IG. (E) Voronoi interface of the heavy chain and interfacial atoms from the light chain. (F) Voronoi interface of the light chain and interfacial atoms from the heavy chain.

Figure 3

 3 Figure 2 On the versatility of applications from the SBL:illustration on the problem of modeling interfaces, http://sbl.inria.fr/doc/Space_filling_model_ interface-user-manual.html. An application is a set of programs characterized by inputs and outputs obeying the same semantics -modeling the interface between subunits of a complex in this example. From the applied standpoint, an interface is qualified by pairs of atom in contacts, interfacial solvent molecules, binding patches (i.e. connected components) together with their surface area and curvature, etc. Formally, an interface is parameterized by properties of the partners (defined by atoms or pseudo-atoms), as well as specific properties of these partners (i.e. the decomposition of a partner into groups of atoms). This parameterization allows investigating a variety of systems in a coherent way, by instantiating the same generic C++ code with different biophysical models. In the sequel, we illustrate this possibility by studying an antibody (IG)antigen complex at two levels of detail (PDB: 1vfb): by considering the IG as a whole, and by splitting its fragment antigen binding domain (FAB) into contributions from its heavy and light chains. (A) Interface atoms of the IG -Ag complex: blue (atoms of the IG), read (atoms of the antigen), gray (crystal water molecules sandwiched between the partners). NB: all atoms are displayed in their solvent accessible representation i.e. radii have been expanded by 1.4. (B) In green, the Voronoi interface from (A), which separates the partners. (C) Top view of the Voronoi interface from (B), with interfacial water molecules. (D) Interfacial atoms contributed by the heavy (blue) and light chain (cyan) of the IG. (E) Voronoi interface of the heavy chain and interfacial atoms from the light chain. (F) Voronoi interface of the light chain and interfacial atoms from the heavy chain.

6. 1

 1 Simplified version of sbl-vorlume-txt.exe sbl-vorlume-example.cpp The following piece of code defines a program taking as input a file listing 3D balls-each line describes one ball by its center and radius, and computes the volume and the surface of their union.// Loading t h e i n p u t f i l e l i s t i n g t h e 3Ds p h e r e s . #i n c l u d e <SBL/ Models / S p h e r e s _ 3 _ f i l e _ l o a d e r . hpp> // Modules r e q u i r e d f o r computing t h e volume o f t h e union o f b a l l s . #i n c l u d e <SBL/ Modules / Alpha_complex_of_molecular_model_module . hpp> #i n c l u d e <SBL/ Modules / Union_of_balls_surface_volume_3_module . hpp> // Workflow #i n c l u d e <SBL/ Modules / Module_based_workflow . hpp> // Models t o be used f o r d e f i n i n g t h e c o n t e x t o f t h e a p p l i c a t i o n .

  -DSBL\_DIR=</path / t o / s b l / d i r >• if the library is installed in a non-standard location : > cmake . . -DCMAKE\_MODULE\_PATH=</path / t o / s b l / d i r >/s h a r e /cmake/ Modules 6.2 Managing batches of executions, and using PALSE to extract statistics example-batch-palse-vorlume.py The following Python script reads an input list of directories containing text files of 3D spheres, run the vorlume example over all the files in each directory, and compute the mean volume for each directory. It uses the package Batch_manager for making and runing batches of calculations, and the package PALSE for running analysis over the batches. #! / u s r / b i n / python from SBL import Batch_manager from Batch_manager import * from SBL import PALSE from PALSE import * f o r i i n r a n g e ( 1 , l e n ( s y s . argv ) ) : batch = BM_Batch ( ) #Load f i l e s o f t h e d a t a s e t . batch . l o a d _ d a t a s e t ( s y s . argv [ i ] ) #Load t h e batch-vorlume-t x t . s p e c s p e c i f i c a t i o n t o compute t h e volume # o f t h e b a l l s i n t h e f i l e . batch . l o a d _ r u n _ s p e c i f i c a t i o n ( " batch-vorlume-t x t . s p e c " ) #Run . batch . run ( ) d a t a b a s e = PALSE_xml_DB( ) d a t a b a s e . l o a d _ f r o m _ d i r e c t o r y ( " s b l -vorlume-example-"+o s . path . basename ( s y s . argv [ i ] ) , " . * volumes . xml " ) volumes = d a t a b a s e . get_all_data_values_from_database ( " r e s t r i c t i o n s / item / total_volume " , f l o a t ) volumes = PALSE_DS_manipulator . c o n v e r t _ l i s t o f l i s t s _ t o _ l i s t ( volumes ) p r i n t ( sum ( volumes ) / f l o a t ( l e n ( volumes ) ) ) batch-vorlume-txt.spec The following is the specification file used by the Batch_manager package from the Python script example-batch-palse-vorlume.py . Please note that the second line of the specification file corresponds to the path to the program to be executed : the program should be in one's $PATH -or the line modified to set the path to the executable. #The e x e c u t a b l e . EXECUTABLE s b l -vorlume-example . exe #Any . t x t f i l e from t h e d a t a s e t i s e l i b i g l e f o r t h e o p t i o n -f , # a s s p e c i f i e d by t h e python r e g e x . #NB: t h e d a t a s e t name i s s p e c i f i e d when c o n s t r u c t i n g t h e batch i n t h e python s c r i p t . IFO f " \ . t x t $ " #There i s a uniq ue IFO , with one e x e c u t i o n p e r v a l u e i . e . f i l e . IFO-ASSOC-RULE unary #These a r e t h e Non F i l e Options f o r t h e e x e c u t a b l e . NFO l o g NFO output-p r e f i x NFO v e r b o s e Running the executable. The following command line executes the Python script : > chmod u+x example-batch-p a l s e -vorlume . py > . / example-batch-p a l s e -vorlume . py <path / t o / i n p u t / d i r e c t o r y > Inria RESEARCH CENTRE SOPHIA ANTIPOLIS -MÉDITERRANÉE 2004 route des Lucioles -BP 93 06902 Sophia Antipolis Cedex Publisher Inria Domaine de Voluceau -Rocquencourt BP 105 -78153 Le Chesnay Cedex inria.fr

  Software for computational structural biology . . . . . . . . . . . . . . . . . . . . 1.2 Software design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 The SBL for end-users 2.1 Rationale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Key features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 The SBL for developers 3.1 Rationale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Structure of the SBL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3 Development of novel programs and applications . . . . . . . . . . . . . . . . . .

	1 Introduction 1.1 1 Introduction 1.1 Software for computational structural biology

3.4 Low level developments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5 License, releases, distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Discussion 4.1 High quality applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Towards more integration and further applications . . . . . . . . . . . . . . . . . 5 Outlook 6 Supplemental 6.1 Simplified version of sbl-vorlume-txt.exe . . . . . . . . . . . . . . . . . . . . . 6.2 Managing batches of executions, and using PALSE to extract statistics . . . . . .

  CMakeLists.txtThe program sbl-vorlume-example.cpp is compiled using CMake. The following code defines the corresponding CMakeLists.txt file.

	// Updating t h e a l p h a complex o f t h e volume module from t h e p r e v i o u s module
	v o i d set_alpha_complex ( Alpha_complex_module * alpha_complex_module ,
	Surface_volume_module * surface_volume_module )
	{ surface_volume_module->get_alpha_complex ( ) =
	&alpha_complex_module->get_alpha_complex ( ) ; }
	i n t main ( i n t argc , c h a r * argv [ ] ) {
	// B u i l d i n g t h e workflow
	SBL : : Modules : : Module_based_workflow workflow ( " s b l -vorlume-example " ) ;
	//--adding t h e l o a d e r
	Loader * l o a d e r = workflow . add_loader<Loader >(" S p h e r e s Loader " ) ;
	//--adding t h e f i r s t module ( alpha-complex )
	SBL : : Modules : : Module_based_workflow : : Vertex
	u = workflow . r e g i s t e r _ m o d u l e <Alpha_complex_module >("Alpha Complex " ) ;
	workflow . set_start_module ( u ) ;
	// Read t h e command l i n e and i n i t i a l i z e t h e module ' s p a r a m e t e r s .
	workflow . parse_command_line ( argc , argv ) ;
	// Load t h e data and i n i t i a l i z e t h e a l p h a complex with t h e i n p u t 3D s p h e r e s
	workflow . l o a d ( ) ;
	( ( Alpha_complex_module&) workflow . get_module ( u ) ) . g e t _ p a r t i c l e s ( ) =
	&l o a d e r ->get_geometric_model ( ) ;
	// S t a r t t h e workflow
	workflow . s t a r t ( ) ;
	r e t u r n 0 ;
	}
	s >	Alpha_complex ;
	} ;
	// D e f i n i t i o n o f t h e l o a d e r s and modules t o be used . cmake_minimum_required (VERSION 2 . 6 )
	t y p e d e f SBL : : Models : : T_Spheres_3_file_loader <T r a i t s : : P a r t i c l e _ t r a i t s : : P a r t i c l e _ t y p e > s e t (SBL_USE_LIBS CGAL MPFR GMP Boost ) fin d_package (SBL) t y p e d e f SBL : : Modules : : T_Alpha_complex_of_molecular_model_module <T r a i t s > i n c l u d e ( $ {SBL_USE_FILE} ) t y p e d e f SBL : : Modules : : T_Union_of_balls_surface_volume_3_module create_sbl_program ( s b l -vorlume-example )	Loader ; Alpha_complex_module ;
	<T r a i t s >		Surface_volume_module ;
			Inria

//--adding t h e s e c o n d and l a s t module ( s u r f a c e / volume ) SBL : : Modules : : Module_based_workflow : : Vertex v = workflow . r e g i s t e r _ m o d u l e <Surface_volume_module >(" S u r f a c e / Volume " ) ; workflow . set_end_module ( v ) ; //--c o n n e c t i n g t h e l a t t e r two modules , s p e c i f y i n g how t o update // t h e i n p u t o f t h e s e c o n d module from t h e output o f t h e f i r s t module . workflow . make_module_flow ( u , v , &set_alpha_complex , " alpha-complex " ) ;

RR n°8957

The SBL is available from http://sbl.inria.fr