dataesr/scientific-paragraphs-categorization huggingface dataset:
OPC UA, on the other hand, is based on the open technologies such as XML and Web services SOA  [18]. The UA also comes with a generic information model  [47] , using object-oriented techniques, which is a basis for domain specific information model. The communication of OPC UA relies on nodes, described by their attributes, connected by references and grouped into classes  [48]. The data of a UA server can be published in either binary or XML format. Several Web service security standards can be used in OPC UA communication: WS-Security, WS-Trust or WS-Secure Conversion. In the context of OPC standards, the UA can be considered as a top level standard providing platform-independent and service based communication, in contrary to platformdependent and component-based approach of the others  [48].
CIM to OPC UA To use CIM model over OPC UA communication, it is necessary to fill the UA address space with CIM information and semantics. Using the fact that CIM model and UA abstract data model are both based on UML, in  [46, 49] , Rohjans introduced a two-step approach of how CIM semantics can be used to generate OPC UA address space. First step concerns the modification of the UML model of CIM to develop a platform specific model, which is the input for external generator creating an UA address space. In second step, Rohnjans introduced CIMbaT, an Enterprise Architect (EA) Addin, to semi-automatically generate an UA Address space. The procedure to implement CIM semantic to OPC UA server is represented on Fig. 5. The CIM-OPC UA mapping rules depend on the coordination with the IEC. The mapped elements will be written into a XML file.
The hybrid cloud SCADA concept and the PaaS delivery model were used to propose a suitable architecture to resolve the problem of interoperability of micro-grid platforms. The architecture offers the benefit of a cloud-based SCADA and PaaS delivery model while taking efficient measures against security and reliability issues. CIM/XML/RDF was recognized as the suitable information model to ensure that the exchanged data is mutually and correctly understood by all the partners of the project. This combination allows the provision of OPC-based applications (EMS, HMI and SCADA) in the PaaS delivery model and brings CIM semantic to the OPC UA communication, which completes the proposed architecture. The contribution of this paper resides in the proposition of the novel SCADA as a service approach, which provides an infrastructure for interoperability among micro-grid platforms.
The ubiquity of next generation sequencing has transformed the size and nature of many databases, pushing the boundaries of current indexing and searching methods. One particular example is a database of 2,652 human RNA-seq experiments uploaded to the Sequence Read Archive. Recently, Solomon and Kingsford proposed the Sequence Bloom Tree data structure and demonstrated how it can be used to accurately identify SRA samples that have a transcript of interest potentially expressed. In this paper, we propose an improvement called the AllSome Sequence Bloom Tree. Results show that our new data structure significantly improves performance, reducing the tree construction time by 52. 7% and query time by 39 -85%, with a price of up to 3x memory consumption during queries. Notably, it can query a batch of 198,074 queries in under 8 hours (compared to around two days previously) and a whole set of k-mers from a sequencing experiment (about 27 mil k-mers) in under 11 minutes.
Introduction Data structures for indexing and searching of databases have always been a core contribution of algorithmic bioinformatics to the analysis of biological data and are the building blocks of many popular tools  [21]. Traditional databases may include reference genome assemblies, collections of known gene sequences, or reads from a single sequencing experiment. However, the ubiquity of next generation sequencing has transformed the size and nature of many databases. Each sequencing experiment results in a collection of reads (gigabytes in size), typically deposited into a database such as the Sequence Read Archive (SRA)  [17]. There are thousands of experiments deposited into the SRA, creating a database of unprecedented size in genomics (4 petabases, as of 2016). The SRA enables public access of the database via meta-data queries on the experiments' name, type, organism, etc.
However, efficiently querying the raw read sequences of the database has remained out of reach for today's indexing and searching methods, until earlier this year  [34]. Given a transcript of interest, an important problem is to identify all publicly available sequenced samples which express it. The SRA contains thousands of human RNA-seq experiments, providing a powerful database to answer this question. One approach is to use tools such as  [37, 30, 4]  to first identify transcripts present in each of the experiments; however, running these tools on a massive scale is time prohibitive (though cloud-enabled tools like Rail-RNA  [29]  are making inroads). Moreover, they introduce biases and can easily miss a transcript that is supported by the reads. Another approach is to align the SRA reads to the transcript of interest; however, this approach is infeasible for such large datasets  [34].
Recently, Solomon and Kingsford proposed the Sequence Bloom Tree (SBT) data structure and demonstrated how it can accurately identify samples that may have the transcript of interest expressed in the read data  [34]. SBT was a breakthrough, allowing to query a set of 214,293 transcripts against a database of 2,652 human RNA-seq experiments in just under 4 days. The SBT is not intended to replace more thorough methods, like alignment, but is intended to be complementary, narrowing down the set of experiments for which a more rigorous investigation is needed. In this paper, we present the AllSome Sequence Bloom Tree (SBT-ALSO), a time and space improvement on the original SBT (denoted by SBT-SK). It combines three new ideas. The first one is a better construction algorithm based on clustering.
The second one is a different representation of the internal nodes of the tree so as to allow earlier pruning and faster exploration of the search space. The final one is building a Bloom filter on the query itself. This allows quick execution of queries that are not just transcripts but are themselves large sequencing experiments. We evaluate SBT-ALSO on the database of 2,652 human RNA-seq sequencing runs used in  [34]. SBT-ALSO reduces tree construction time by 52. 7%, when given the Bloom filters of the datasets. It reduces query time by 39 -85%, with a price of up to 3x memory consumption. Notably, it can query a batch of 198,074 queries in under 8 hours, compared to over two days for SBT-SK. It can also query a whole set of k-mers from a sequencing experiment (about 27 mil k-mers) in under 11 minutes, compared to more than 23 hours by SBT-SK.
Our software is open source and freely available via GitHub 1. 1 SBT-ALSO GitHub repository: https://github. com/medvedevgroup/bloomtree-allsome 2 This work falls into the general category of string pattern matching, where we are asked to locate all occurrences of a short pattern in a large text. In many cases, it is useful to pre-process the text to construct an index that will speed up future queries. The k-mer-index, trie, suffix tree, suffix array, BWT, and FM-index are examples of such indices  [21]. These form the basis of many read alignment tools such as BWA-mem  [18]  and Bowtie 2  [16]. While many of these approaches are space and time efficient in their intended setting, they can nevertheless be infeasible on terabyte or petabyte scale data. Other approaches based on word-based indices  [28, 39]  and compressive genomics  [20, 38]  do not help for the type of data and queries we consider in this paper.
A Bloom filter (BF) is widely used to improve scalability by determining whether the pattern occurs in the text, without giving its location. It is a space efficient data structure for representing sets that occasionally provides false-positive answers to membership queries  [3]. For pattern matching, a BF can be constructed for all the constituent k-mers (strings of length of k) of the text. Then, if a high percentage of a pattern's constituent k-mers match, the text is a potential match and a full search can be performed. BFs are used in several bioinformatics contexts such as assembly  [25, 6, 33, 12] , to index and compress whole genome datasets  [32] , and to compare sequencing experiments against whole genomes  [35]. When pattern matching against a database of read collections from sequencing experiments, additional factors need to be considered.
Each leaf contains a bitvector describing the texts in which that k-mer appears, and BFs are cleverly used inside the trie to "jump down" positions at a time, thus speeding up the trie traversal process. The BFT complexity scales up with the number of k-mers in the query, while SBT complexity scales up with the number of datasets. Thus the two approaches suggest orthogonal use cases. In particular, the BFT is very efficient for queries that are single k-mers, significantly outperforming the SBT. An approach that uses BFT to query longer patterns like the ones we consider in this paper is promising but is not yet available. There is also a body of work about storing and indexing assembled genomes  [19, 26, 2, 24, 10] , which is part of the growing field of pangenomics  [7]. However, our work relates to the indexing of unassembled data (i.
In this paper, we assume that the number of hash functions is 1 (see Section 6 for a discussion). Next, consider a rooted binary tree. The parent of a non-root node u is denoted as parent(u), and the set of all the leaves of the subtree rooted at a node v is denoted by leaves(v). Let lchild(u) and rchild(u) refer to the left and right children of a non-leaf node u, respectively. SBT: Let Q be a non-empty set of k-mers, and let B be a k-mer BF. Given 0 ≤ θ ≤ 1, we say that Q θ-matches B if |{x ∈ Q : x exists in B}|/|Q| ≥ θ. That is, the percentage of k-mers in Q that are also in B (including false positive hits) is at least θ. Solomon and Kingsford consider the following problem. We are given a database D = {D 1 ,. , D n }, where each D i is a BF of size b. The query is a k-mer set Q, and the result of the query should be the set {i : Q θ-matches D i }.
The goal is to build a data structure that can construct an index on D to support multiple future queries. We make a distinction between the abstract data type that Solomon and Kingsford propose for the problem and their implementation of it. We call the first SBT, and the second SBT-SK (note that in  [34]  no distinction is made and SBT refers to both). A rooted binary tree is called a Sequence Bloom Tree (SBT) of a database D if there is a bijection between the leaf nodes and the elements of D. Define B ∪ (u) for a leaf node u as its associated database element and B ∪ (u) for an internal node as i∈leaves(u) B ∪ (i). Note that B ∪ (u) of an internal node u can be equivalently defined as B ∪ (lchild(u)) ∪ B ∪ (rchild(u)). Each node u then represents the set of database entries corresponding to the descendant leaves of u.
The running time of an insertion is proportional to the depth of the SBT. To construct the SBT for a database, SBT-SK starts with an empty tree and inserts each element of the database one-by-one. Construction can take time proportional to nd, where d is the depth of the constructed SBT. The left panel of Figure  1  provides an example of the construction algorithm. To query the database for a k-mer set Q, SBT-SK first checks if Q θ-matches the root. If yes, then it recursively queries the children of the root. When the query hits a leaf node, it returns the leaf if Q θ-matches it. In this example, the dataset can be partitioned into two types: 000xxx and 111xxx, based on the first 3 bits. In the SBT-SK construction, after the first two experiments are inserted (both of type 111xxx), they are destined to be in the two different sides of the tree (regardless of future insertions).
Any future 111xxx type query will have to examine all the nodes. The SBT-ALSO construction, on the other hand, groups together the experiments so that future 000xxx type or 111xxx type queries will have to examine only about half the nodes of the tree. Since SBT is designed to work on very large databases, its implementation should avoid loading the database into memory. In SBT-SK, each B ∪ (u) is stored on disk and only loaded into memory when u is being θ-matched by a query. When there are multiple queries to be performed, SBT-SK will batch them together so that the θ-matching of multiple queries to the same node will be performed simultaneously. Hence, each node needs to be loaded into memory only once per batch. We implement the same strategy in SBT-ALSO.
If the present counter is at least θ|Q|, we add leaves(u) to the list of θ-matches and terminate the search of u's subtree. If the absent counter exceeds (1 -θ)|Q|, we realize that Q will not θ-match any of the leaves in the subtree rooted at u and terminate the search of u's subtree. If neither of these holds, we recursively pass the two counters and the list of unresolved bits down to its children. When we reach a leaf, the unresolved list will become empty because B some is empty at a leaf, and the algorithm will necessarily terminate. The idea behind the AllSome representation is that in a database of biologically associated samples, there are many k-mers that are shared between many datasets. In the SBT-SK representation, a query must continue checking for the presence of these k-mers at every node that it encounters.
By storing at u all the bits that are present in all the leaves of its subtree, we can count those bits as resolved much earlier in the query process -limiting the amount of bit lookups performed. Moreover, we will often prune the search space earlier and decrease the number of bitvectors that need to be loaded from disk. A query that matches all the leaves of a subtree can often be resolved after just examining the root of that subtree. In the extreme case, the number of nodes examined in a search may be less than the number of database entries that are matched.
The new SBT has a root node r with the left and right subtrees corresponding to the two SBTs being joined. B ∪ (r) is computed as B ∪ (lchild(r)) ∪ B ∪ (rchild(r)). To choose the pair of SBTs to be joined, we choose the two SBTs that have the smallest Hamming distance between the B ∪ of their roots. The right panel of Figure  1  shows how our construction algorithm works. Since each B ∪ is a large bitvector, computing and maintaining the pairwise distances between all pairs is computationally expensive. Instead, we use the following heuristic. We fix a number b b (e. g. b = 10 5 10 9 = b) and then extract b bits from each D i , starting from a fixed but arbitrary offset. We then run the above clustering algorithm on this smaller database of extracted bitvectors. The resulting topology is then extracted and used for constructing the B all and B some bitvectors for all the nodes.
Large query algorithm The "regular query" algorithm (Section 4. 1) is designed with relatively small queries in mind (e. g. thousands of k-mers from a transcript). However, after performing a new sequencing experiment, it might be desirable to query the database for other similar samples. In such cases, the query would itself be a whole sequencing experiment, containing millions of k-mers. Our experimental results show that neither SBT-SK nor our own regular query algorithm is efficient for these large queries. While for small queries, the running time is dominated by the of loading bitvectors into memory, for large queries, the time taken to look up the query k-mers in the B all and B some of a node becomes the bottleneck. Let B Q be the Bloom filter of size b for the k-mers in the query Q.
Solomon and Kingsford already explored the advantages, disadvantages and accuracy of the SBT approach as a way of finding experiments where the queried transcripts are expressed  [34]. Since SBT-ALSO gives identical query results as SBT-SK, we therefore focus our evaluation on its resource utilization. We used the same dataset for evaluation as in  [34]. This is the set of 2,652 runs representing the entirety (at the time of  [34] ) of human RNA-seq runs from blood, brain, and breast tissues at the SRA, excluding those sequenced with SOLID. In  [34] , each sequencing run was converted to a k-mer Bloom filter (b = 2 • 10 9 , k = 20) by the Jellyfish k-mer-counting software (containing k-mers that occur greater than a file-dependent threshold, typically at least 3 occurrences). We downloaded these BFs from  [1]  and used them as our database.
Per the results of  [34] , this Bloom filter size leads to a false positive rate of 0. 5 for an individual Bloom filter. We performed experiments on an OpenStack instance with 12 vCPUs (Intel Xeon E312xx), 128 GB memory, and 4 TB network-mounted disk storage. To choose the appropriate number of bits to use for clustering (b ), we randomly sampled 5,000 bitvector pairs from the dataset and computed their pairwise distances. We then computed distances for the same pairs using only b bits, for various values of b. The two distance metrics showed a high correlation (r 2 = 0. 9999874) for b = 500, 000. We then constructed SBT-SK and SBT-ALSO, as well as two other trees to help us separate out the contributions of the clustering algorithm from the AllSome representation. These two trees are SBT-SK+CLUST, which uses the B ∪ node representation of SBT-SK but the SBT-ALSO clustering construction, and SBT-SK+AS, which uses the greedy construction of SBT-SK but the AllSome node representation of SBT-SK.
First, we compared the space and time used to construct SBT-SK and SBT-ALSO (Table  1 ). SBT-ALSO reduces the tree construction time by 52. 7% and resulting disk space by 11. 4%. It requires twice as much intermediate space, due to maintaining two uncompressed bitvectors for each node instead of just one. To study the regular query performance, we downloaded all known transcripts at least k bases long (198,074 of them) from Gencode (ver. 25). We then queried several subsets of transcripts against both trees, and measured the number of nodes examined for each query (Figure  3 ) as well as the running time (Table  2 ). The results of all query experiments in this paper were verified to be equivalent between the tested data structures. SBT-ALSO reduces the runtime by 39 -85%, depending on the size of the batch, likely due to the fact that the number of nodes examined per query is reduced by 52.
7%, on average. Notably, SBT-ALSO was able to query a very large batch (198,074 queries) in under 8 hours, while SBT-SK took over 2 days. SBT-ALSO uses more memory than SBT-SK on larger batches. To study the performance of the large query algorithm, we selected an arbitrary run from our database (SRR806782) and used Jellyfish  [22]  to extract all 20-mers that appear at least three times. These 27,546,676 k-mers formed one query. In heuristic mode, the large query algorithm was 22 times faster than the regular one, but only detected 47 hits, which is a subset of the 50 hits by regular algorithm(Table  3 ). In the exact mode, the large query algorithm recovered all the hits (as expected) and was 18 times faster. Compared to SBT-SK, it was 155 times faster. The clustering construction, even without the AllSome representation, significantly reduces the number of nodes that need to be examined per query (36.
5% on average when comparing SBT-SK to SBT-SK+CLUST in Figure  3 ). The improvement seems to be uniform regardless of the Fig. 3. Number of nodes examined per query for SBT-SK, SBT-ALSO, as well two intermediate SBTs. A set of 1,000 transcripts were chosen at random from Gencode set, and each one queried against the four different trees. A dot represents a query and shows the number of matches in the database (x-axis) compared to the number of nodes that had to be loaded from disk and examined during the search (y-axis). For each tree (color), we interpolated a curve to show the pattern. The dashed horizontal line represents the hypothetical algorithm of simply checking if the query θ-matches against each of the database entries, one-by-one. For θ, we used the default value in the SBT software (θ = 0.
A. 3 Formal derivation of update formulas for construction In Section 4. 2, we presented the update rules for constructing B all and B some for the internal nodes of a SBT. Here, we give a formal derivation of the rules' correctness. First, let DB(u) denote the database entries corresponding to the descendant leaves of a node u. Note that the subtree rooted at u is, by definition, an SBT of DB(u). At any point of the construction, we will have the invariant that if node v was processed then the subtree rooted at v is a correct SBT-ALSO for DB(v). For the base case, for all leaves u we set B all (u) = B ∪ (u) and B some (u) = ∅. For the general case, consider an internal node u whose children have already been processed. We will use the superscript new to denote the values of the bitvectors for the new subtree rooted at u, to distinguish it from those values passed up inductively from the trees of the children.
In total, about 1000 sensors have to be powered and read out with one to three fast serial data links each. Studies of the serial data transmitted from the current pixel sensor prototype MUPIX7 at 1. 25 Gb/s have been performed. Flex-print cables produced in-house have been tested regarding impedance, quality of service, and bandwidth. An outlook on the flex-print design to connect the next generation of MUPIX sensors and build first detector modules is given.
Being the main supply voltage, the low voltage has to be distributed without significant voltage drop up to a power dissipation of the sensors of 400 mW/cm 2. From the sensors, the serial data is transmitted over the flex-prints towards the frontend board. For the final experiment, of the order of 1000 MUPIX sensors have to be powered and read out with up to three data links, each. Sensors, flex-print and a 25 µm thin Kapton R support structure form a detector module as illustrated in Figure  2.
Data Transmission Study of the MUPIX 7 For a proper operation of the MUPIX 7 a stable serial data transmission from the sensor is important. We studied the serial data transmission of the MUPIX 7 as this feature was integrated into this prototype for the first time. An eye diagram of the serial data output at 1. 25 Gb/s is shown in Figure  3. The serial signal transferred over coaxial cables is sampled using an oscilloscope. We measured an eye width of 525 ps, which corresponds to 65 % of a bit time interval, and an eye height of 132 mV for a total signal amplitude of 172 mV. Both eye parameters indicate a good quality of data transmission. This can be confirmed by a bit error rate (BER) measurement, where we did not observe any bit errors in the data stream running over several hours, setting an upper limit on the bit error rate to BER < 10 -13 at a 95 % confidence level.
PoS(CORFU2015)071 Readout via Flex-Prints for the Mu3e Experiment Sebastian Dittmeier is deserialized in the receivers and checked for bit errors that occurred during transmission. The flex-print is connected to the FPGA development board using custom designed PCBs. The bit error rate test setup is depicted in Figure  6. Bit error rates for a 20 cm and a 1 m long flex-print prototype are measured at various data rates. Up to 2. 5 Gb/s no bit errors over the 20 cm long prototype are observed. At 3. 2 Gb/s first bit errors are observed at a bit error rate of 1. 6 × 10 -16. The BER can be further reduced by tuning the analogue settings of the transmitter like pre-emphasis. For the 1 m long prototype, first tests show a reliable data transmission at data rates up to 1. 6 Gb/s. Results are summarized in Tables  1  and 2.