dataesr/scientific-paragraphs-categorization huggingface dataset:
Phase 3: Data Sharing When a data researcher, such as a physician, insurance provider, or some other third party, uses a certain keyword search and the private key of the patient to create a trapdoor then the smart contract performs the test algorithm for data retrieval. After the authentic EHR ciphertext search is completed by the system manager, the EHR delivers to third-party users and acts as an aid to proxy re-encryption of the original ciphertext by running the ReKeyGen algorithms to generate the proxy re-encryption key and re-encrypt the ciphertext using patient's public key. In this phase, firstly, the third party (data user) send sends the request to the Ethereum smart contract to display the patient's EHRs using the trapdoor (patient's private key + keyword set). Secondly, the EHRs' index will decrypt and re-encrypt using the ECC algorithm's public key of the patient.
The comparison shows that our proposed protocol has more security features than related schemes  [9, 10, 42, 49]. It emphasizes the fact that our protocol achieves the maximum desired security properties and is more resistant to KGA than related protocols. The cryptography primitives are implemented in JavaScript on a PC with an Intel CPU Intel(R) Core (TM) i7-7500U and RAM 8 GB running Windows 10. On Windows 10, Ganache framework is used to create a private test blockchain. Using the Solidity programming language, the data are written into smart contracts and embedded in Ethereum. The smart contracts' test framework is truffle 5. 0. 5 and the compiler of solidity is solc 0. 5. 16. The Nodejs Web3js package is applied to connect with blockchain smart contracts and evaluate the execution time (time cost) of the transactions.
This is due to the inability of solidity to compute the required time to publish smart contracts to the blockchain. Nodejs is a server-side development platform that allows JavaScript to execute. Table  3  shows the specific configurations. Figure  4  shows the front-end of the webpage including the patient's address and adding an EHR button to save data by a doctor. In Figure  5 , we show the encryption algorithms' computational time in milliseconds with a different record size similar to the results of  [31]. We varied the record size from 16 bits, 64 bits, 128 bits, 256 bits, to 512 bits and we measured the time of encrypting and uploading the record to the blockchain. For each record size, we conducted the experiment five times and next took the average of them. We can see that the greater the record size length the more computational time needed.
Molecular dynamics simulations play an increasingly important role in the rational design of (nano)-materials and in the study of biomacromolecules. However, generating input files and realistic starting coordinates for these simulations is a major bottleneck, especially for high throughput protocols and for complex multi-component systems. To eliminate this bottleneck, we present the polyply software suite that leverages 1) a multiscale graph matching algorithm designed to generate parameters quickly and for arbitrarily complex polymeric topologies, and 2) a generic multi-scale random walk protocol capable of setting up complex systems efficiently and independent of the target force-field or model resolution. We benchmark quality and performance of the approach by creating melt simulations of six different polymers using two force-fields with different resolution.
8] [29] [30]  Some of those are in principle capable of generating parameters and coordinates. 29, 30 However, available programs typically support only one force-field and are limited to specific (mostly linear) polymers implemented by the developers. Website implementations  28, 30  have the added problem that performance relies on server-load and it involves human-time having to interface with the website. In addition, coordinates for more complex systems such as micro phase separated polymers and hybrid nanoparticle blends are frequently generated by (multi-scale) self-assembly  [31] [32] [33]  or custom inhouse building scripts  34, 35. The general lack of programs supporting all-atom and CG polymer simulations limits the use of MD simulations for both large versatile systems and high throughput research of (bio-) macromolecular systems.
3) The program needs to be able to combine input parameters and coordinates of polymeric systems with a variety of biomolecular structures, like proteins, lipid bilayers and nucleotides. For example, manipulation of proteins and other biomolecules by polymer grafting is an integral part of enhancement strategies. 36 4) It needs to be capable of setting up complex systems without the need of extensive relaxation. Polymer melts, blends with nano-particles and phase separated systems are highly important in material science and when studying bio-synthetic hybrid molecules, and closely capturing their heterogeneity in the starting structures saves valuable computer resources. 5) Generation of both the coordinate and parameter files needs to be fast enough to enable HT research. Here we present the open-source polyply software suite which addresses the five major challenges presented above.
It facilitates the generation of input parameters and coordinates for MD simulations of (bio-)macromolecules and nanomaterials. Using a graph-based algorithm, polyply allows users to generate parameter files of arbitrarily composed and branched polymers for any force-field from simple library files and the residue graph. A residue graph contains the sequence of residues of the polymer, but in addition it also records which residues are connected. Using a multiscale random walk, polyply can also be utilized to generate starting coordinates for any force-field and at any target resolution. This includes complex arrangements like micro phase separated polymeric systems or multicomponent polymer solutions enclosed in lipid vesicles. To maximize accessibility of the models and code, polyply is distributed as via the python package index.
Furthermore, polyply is developed using modern software development practices (such as code review, continuous integration testing, and semantic versioning) as outlined in the recent whitepaper by the BioExcel consortium. 37 These practices ensure both the integrity of the code and the library data files. The remainder of this paper is organized as follows. First, we present the algorithms behind he input parameter generation and the coordinate generation. Subsequently we show the capabilities of our program based on three examples from pure materials science to biomolecular science, some at the atomistic level based on the GROMOS  38  force-field, others at the CG level using the Martini  39, 40  force-field. They exemplify the capabilities of polyply to be compatible with HT approaches, generate parameters force-field independently, and set up complex systems.
-Algorithms and code The general code design accounts for the fact that generation of input parameter files and coordinate generation are in principle separate problems. However, both problems can make use of the same infrastructure, which is centered around exploiting graph representations of molecules. Thus, the polyply software suite consist of separate lone standing programs, which utilize the same libraries. At the moment two programs,'gen_params' and 'gen_coords', are available for input parameter generation and coordinate generation, respectively. In addition, an auxiliary program for sequence generation is provided, which is further discussed in the supporting information. In the following two sections we explain the algorithm and ideas behind parameter file generation and system coordinate generation.
g. , bonds or angles) introduced when two residues are connected. To this end, polyply internally uses the Networkx  41  and vermouth  42  python libraries for handling graph related computations. Figure  1. Schematic illustration of the workflow behind the parameter file generation exemplified for polyethylene oxide (PEO) grafted methyl acrylate (MA). The user input is the residue graph, while the building blocks are taken from the library (presented in dashed boxes). However, users can modify the library as they need. In step one the parameters for the blocks are applied based on the residue graph to form a disconnected graph at target resolution. In step two the links are matched at residue graph level to the input residue graph. Subsequently links are applied to the disconnected graph at target resolution in the third step producing the complete parameter file.
The general input to polyply for parameter file generation is a residue graph of the target molecule. In addition, the blocks and links corresponding to the residues in the target molecule are needed (cf. Fig. 1 , dashed boxes). Currently, polyply is shipped with libraries containing these parameters for some force-fields and polymers, a database that will be expanded over time. From the definition of the residue graph, blocks, and links polyply generates a parameter file in three steps (cf. Fig. 1 ): Step 1: Generate a disconnected graph of residues After reading the input files, polyply iterates over all residues of the input residue graph. For each residue, the matching block is added to an empty graph thereby generating a disconnected graph of residues at target resolution. This graph already contains all atoms of the target molecule and interactions within the residues.
e. , branching); 4) be able to generate complex morphologies; 5) and finally be reasonably fast to permit HT research. In this paper, we have presented polyply, a software suit that is aimed at facilitating simulations involving polymers at any target resolution and force-field desired. Parameter file generation and coordinate generation are split into two independent programspolyply gen_params and polyply gen_coords. The gen_params program implements the graph transformation used within polyply to generate parameter files. The algorithm takes a residue graph and maps it into a higher resolution graph, which is agnostic to the target resolution thereby meeting the first of the challenges outlined above. It further matches fragments, which describe the bonded interactions between residues, by finding all subgraph isomorphisms between these fragments and the residue graph provided.
Overall, we showed that the polymer parameter generation meets all requirements outlined in the challenges. Currently, the main limitation of the parameter generation is that it is limited to GROMACS input files. However, extension to other MD software is possible and would only require additional input file-parsers as the core of the code makes no calls to the GROMACS software itself. As further outlined in the challenges, structure generation is a key step for any program. It needs to be fast and generate complex structures that are good enough to start the simulation without extensive relaxation. To this end, polyply gen_coords implements a multiscale approach to generation of condensed phase systems at near to target density. The multiscale approach is based upon using a generic one-bead per residue CG model, performing a self-excluding random walk, and backmapping it to target resolution.
Systems. Polyply was run for all test-systems within python3 (v3. 6. 9 on local machines, and v3. 8. 2 on the Dutch National Supercomputer, Cartesius). For acceleration the numba package  64  was installed in all environments. All test systems were either run on a local desktop machine running Linux OS or on the national HPC cluster. The performance for parameter file generation and input coordinate generation were recorded on the HPC cluster for the CG systems, running 24 processes in parallel on a single node. On the other hand, atomistic benchmark times were recorded on a desktop machine running 10 processes in parallel. Models. The all-atom polymer models were implemented following the rules for creating polymers within the GROMOS 2016H66 force-field and charges adopted from similar functional groups as is custom within GROMOS.
38 The current library does not only support homopolymers but all combinations of monomers. Martini CG models were parametrized newly following the Martini 3 guidelines for making molecules or were adopted from existing Martini 2 models. Each new model was based on the GROMOS model, for which a system was generated with poyply and run with the settings stated above. We note that these models are subject to future improvement and that currently only homo-polymers are supported with the exception of PS and PEO block-copolymers. A detailed validation of these models will be provided in a separate publication. The current (beta) versions are available from the polyply library see code availability.
In addition to these basic functionalities the program also allows to attach tags to each residue in the sequence with the -label option. In this way, for example, nodes can be labeled with their chirality/tacticity. There is also the possibility to modify end-groups. Both options are described in more detail in the help menu of the program. As polyply parses networkx style json-file. Thus users can write their own protocols for making residue graphs or edit them manually as well.
Integrons are flexible gene-exchanging platforms that contain multiple cassettes encoding accessory genes whose order is shuffled by a specific integrase. Integrons embedded within mobile genetic elements often contain multiple antibiotic resistance genes that they spread among nosocomial pathogens and contribute to the current antibiotic resistance crisis. However, most integrons are presumably sedentary and encode a much broader diversity of functions. IntegronFinder is a widely used software to identify novel integrons in bacterial genomes, but has aged and lacks some useful functionalities to handle very large datasets of draft genomes or metagenomes. Here, we present IntegronFinder version 2. We have updated the code, improved its efficiency and usability, adapted the output to incomplete genome data, and added a few novel functions.
We describe these changes and illustrate the relevance of the program by analyzing the distribution of integrons across more than 20,000 fully sequenced genomes. We also take full advantage of its novel capabilities to analyze close to 4000 Klebsiella pneumoniae genomes for the presence of integrons and antibiotic resistance genes within them. Our data show that K. pneumoniae has a large diversity of integrons and the largest mobile integron in our database of plasmids. The pangenome of these integrons contains a total of 165 different gene families with most of the largest families being related with resistance to numerous types of antibiotics. IntegronFinder is a free and open-source software available on multiple public platforms.
For this, we developed a software called IntegronFinder that has become popular to identify integrons in bacterial genomes. The program searches for the integrase using hidden Markov models protein profiles with the software HMMer  [20] , and for the attC sites using covariance models with the software Infernal  [21]. These and other genetic components, e. g. , promoters, are then clustered if they are co-localized in the DNA sequence. Inte-gronFinder is thus able to identify integrons with novel cassettes and is complementary to the use of databases such as Integrall  [22]  that store known integrons and allow to search for homology of the cassettes by sequence similarity. The program is particularly useful to study the wealth of integrons found in environmental bacteria and which often encode unknown functions  [23].
Another software to identify attC sites, HattCI, was made available at approximately the same time  [24]. More recently I-VIP was published to identify class 1 integrons using sequence similarity to a database of integrases and our own covariance model  [16]. However, no software seems to be currently maintained and developed. This is a problem because IntegronFinder version 1 has some limitations. Notably, it was designed to analyze complete genomes. The analysis of draft genomes and metagenomes was possible but required scripting skills and managing an output that was not designed for such data. This is a limitation since recent studies have uncovered novel integrons in metagenomes and in metagenome-assembled genomes  [25, 26]. IntegronFinder version 1 has also aged poorly in that it was written in Python 2 (now deprecated) and lacks modern tools to facilitate its maintenance.
Refactoring of IntegronFinder The first version of IntegronFinder was coded in Python v2. 7, which is now deprecated. The program was ported to Python 3. 7 (but currently works with versions up to Python 3. 10) and the code was refactored to improve efficiency and correct minor bugs. Promoters and attI1 sites are no longer detected by default to increase speed, especially as attI sites are poorly described (and hence not detected by IntegronFinder) outside class I integrons. We have added unit (or non-regression) tests, which make the software more robust and more attractive for future contributors. IntegronFinder can now be easily run in parallel with a Nextflow script  [27]  that we provide ready to use. We have also diversified the installation methods, so it can be easily deployed on a variety of machines.
Novel Functionalities IntegronFinder v2 has some novel functions in relation to the previous version. A key novel functionality is the systematic use of the gathering thresholds (-cut_ga option in hmmer) that allows to identify hits to the protein profiles with better accuracy than arbitrary e-values. For this, we introduced a gathering threshold in the protein profile specific to the IntI delivered in IntegronFinder that was calculated using the hits of our previous analysis  [10]. The reference database for annotating antibiotic resistance genes in the first version of IntegronFinder was RESFAMS (http://www. dantaslab. org/resfams, accessed on 11 November 2018)  [28]. However, this database has not been updated recently and while it fits the needs of researchers in metagenomics aiming at identifying distant homologs of antibiotic resistance genes, it is less appropriate to identify antibiotic resistance genes identified in clinical samples.
Input IntegronFinder now accepts multifasta files as input. This is a major change since it allows the analysis of genome drafts or metagenome data without the need for scripting an analysis (i. e. , calling IntegronFinder recurrently and managing the output). Draft genomes should be used with the linear replicon type (corresponding to the fact that they are contigs). By default, IntegronFinder uses the linear replicon type if there are multiple contigs in the input file. If there are multiple replicons in the input file with different topologies, this can be specified by providing a topology file. IntegronFinder also accepts an option -gembase that corresponds to a particular gene identifier that allows to put multiple replicons in the same file and inform the program that they should be regarded as different replicons.
This format can be created by PanACoTA, a pipeline to automatically build the basic bricks of comparative genomics automatically, including download, annotation, and formatting of genome data  [31]. The sequence files are initially annotated using Prodigal  [32]  to provide accurate and uniform annotations of all the sequences. As described above the input can also include files for annotation of the integron, e. g. , for antibiotic resistance genes, using any kind of database compatible with hmmer (http://hmmer. org/documentation. html, accessed on 5 February 2022). Interestingly, a recent study has produced diverse attC covariance models for different clades  [33]. These can be used in IntegronFinder by invoking the option -attc-model to use another covariance model instead of the one used by default.
Availability The code of IntegronFinder is available under the free and open-source license GPLv3 at https://github. com/gem-pasteur/Integron_Finder (accessed on 5 February 2022). The code has been packaged and is available on pypi https://pypi. org/project/integron-finder/ (accessed on 5 February 2022) to make it easy to install with the python packager installer pip. We also provide a bioconda package and a container solution https://hub. docker. com/r/gempasteur/integron_finder (accessed on 5 February 2022). A user-friendly Galaxy implementation can be found at https://galaxy. pasteur. fr/tool_runner?tool_id=toolshed. pasteur. fr%2Frepos%2Fkhillion%2Fintegron_finder%2Fintegron_finder%2F2. 0%2Bgalaxy0 (accessed on 5 February 2022)  [34]. The documentation is available at https://integronfinder.
RefSeq Complete Genomes The first dataset used in this study consists of 21,105 complete genomes retrieved from NCBI RefSeq database of high quality complete non-redundant prokaryotic genomes (ftp://ftp. ncbi. nlm. nih. gov/genomes/refseq/, last accessed on 30 March 2021)  [35]. The complete list of genomes can be found in Table  S1.
Klebsiella Data The Klebsiella genomes were downloaded and annotated with PanACoTA  [31]  as explained in  [36]. Briefly, we downloaded all the 5805 genome assemblies labeled as Klebsiella pneumoniae sensu stricto (Kpn) from NCBI RefSeq (accessed on 10 October 2018). We removed lower quality assemblies (L90 >100 and number of contigs >990) and strains that were too divergent from the reference strain (Mash distance > 0. 06,  [37] ) or too similar (Mash distance < 0. 0001) to other strains. The resulting set of 3980 sequences were consistently re-annotated with Prokka (v1. 13. 3)  [38] , and species assignments corrected with Kleborate (https://github. com/katholt/Kleborate, accessed on 5 February 2022)  [39]. The accession numbers for the genomes are in Table  S2 , along with all the annotations identified in this study.
We built Klebsiella integron pangenomes using PanACoTA v1. 3. 1 pangenome module with default parameters (-i 0. 8, -c 1). The latter clustered integron proteins (defined as the proteins encoded by genes lying between two attC or less than 200 bp away from the last attC) using MMSeqs2 13-45111  [40]  with single-linkage and a threshold of 80% of identity and bidirectional coverage. We computed the species phylogenetic tree with IQ-TREE, as explained in  [36]. Briefly, the 1431 protein families present in more than 99% of the strains in a single copy were aligned with Mafft (v7. 407)  [41] , back-translated to DNA, and concatenated. We used this alignment containing 220,912 parsimony-informative sites over a total of 1,455,396 bp to infer a phylogenetic tree with IQ-TREE (v1. 6. 7. 2) using ModelFinder (-m TEST)  [42, 43].
We used the best-fit model (GTR+F+I) without gamma correction, because of branch length scaling issues with our large dataset, and assessed the robustness of the phylogenetic inference by calculating 1000 ultra-fast bootstraps (-bb 1000)  [44]. The mean support value was 97. 6%. We placed the Kpn species root according to the outgroup formed by 22 misannotated Klebsiella quasipneumoniae subspecies similipneumoniae identified by Kleborate.
Analysis of Antibiotic Resistance Genes (ARGs) To annotate ARGs we used four databases: ARG-ANNOT (v5)  [45] , CARD [46], AMRFinderPlus  [28]  (v3. 0. 5) (v2019-09-07), and ResFinder (v2019-07-17)  [47]. The annotations were made by searching for homology with Abricate (v0. 9. 8) (https://github. com/ tseemann/abricate, accessed on 5 February 2022). While these databases are largely concordant, they do not all include the same types of functions. Hence, we compared them by looking at the number of databases reporting at least one hit (coverage > 80%, identity > 90%) for all the proteins identified in Klebsiella pneumoniae integrons. A large majority of proteins reported either 0 or 4 matches, but many had hits in only 1 to 3 databases. Noticeably, the second most abundant family in the pangenome, later labeled as effluxpump multidrug transporters, hit only the AMRFinderPlus database.