dataesr/scientific-paragraphs-categorization huggingface dataset:
Data availability The MERRA2 data used in this study come from https://gmao. gsfc. nasa. gov/reanalysis/MERRA-2/. The CESM2 data are available from the Cornell eCommons repository (https://doi. org/10. 7298/xqqj-qk90). The PM 10 concentrations measured at three stations in West Africa (M'Bour, Senegal; Cinzana, Mali; Banizoumbou, Niger) come from INDAAF. The PM 10 concentrations measured at Finokalia (southern Greece) come from Finokalia Atmospheric Observatory (https:// finokalia. chemistry. uoc. gr/). The station AOD at the aforementioned four stations comes from AERONET. The baseline mortality used in this study is obtained from the Global Burden of Disease (GBD) study (http://ghdx. healthdata. org/gbd-results-tool), the exposed population is obtained from the Center for International Earth Science Information Network (https://sedac.
Sequencing Comparison of the results generated from Kraken 2 run against the non-redundant protein database (nr) to the DIAMOND run against the non-redundant protein database (nr) revealed in general similar results. However, the Kraken 2 run against the nucleotide non-redundant (nt) NCBI database was the only run that generated APPV hits in the piglets where the virus previously was demonstrated by PCR  (Stenberg et al. , 2020a). Hence, the Kraken 2 runs against the nucleotide non-redundant (nt) NCBI database were deemed to produce the most reliable results for this dataset and were therefore chosen for the taxonomic classification. An additional file shows the specific details for each sample (see additional file 1).
Specific alignment against the APPV-genome identified APPV-sequences in all the four PCR-positive samples but not in the two PCR-negative samples. In the APPV-PCR positive piglets, the most abundant viral reads were reads classified as APPV. The sample with the highest number of viral reads had 140 reads classified as APPV or Pestivirus K. The reads classified by Kraken as APPV were extracted and blasted using BLASTn and generated only APPV hits. Considerably fewer reads classified as other viruses were detected. The second most common viral taxon detected was also identified in all samples. These were reads classified by Kraken as Human respovirus 1 with 16 reads, at the most, in one sample. The reads were blasted against the non-redundant database nt, using BLASTn and generated Human respovirus hits.
The majority of the classified reads, approximately 45%, were of microbial origin but less than 0. 1% were classified as viral. Alignment against the APPV-genome did not generate any hits. In this dataset, there was no detection of true viral reads. There were reads classified as viral by Kraken, but once the reads were extracted and submitted for a BLAST search only reads classified as Equine infectious anemia virus generated hits in BLAST. Virus classified as Equine infectious anemia virus is assumed to be a reagent contaminant commonly detected in metagenomic datasets  [33]. The other reads classified as viral reads by Kraken did not generate viral hits when blasted but mainly hits from the pig genome. At the contig level, more than 90% of the de novo assembled contigs were classified. The majority of the contigs were of chordate origin and less than 0.
In all samples, a few reads were classified as viral by Kraken but after blast validation, all of them turned out to be from the Sus scrofa genome. This could stem from misclassification, due to how Kraken's algorithm works, or from the fact that some sequences in the databases are wrongly annotated. At the contig level, more than 30% of the de novo assembled contigs were classified. A majority of the contigs were of microbial origin and less the 1% of the contigs were classified as viral. A few viral contigs were detected in all samples, but after blast validation almost all of them turned out to be from the Sus scrofa genome. One contig classified as Equine infectious anemia virus was detected in all samples and could be blast validated as Equine infectious anemia viru and thus most likely a reagent contaminant  [33].
The APPV associated upregulation of STING in the present study is further supported by the metagenomic sequencing results that ensure the absence of non-APPV viral co-infections. Overall, the metagenomic sequencing resulted in a low number of viral reads, both in the brain and spinal cord. The most obvious finding that emerged from the metagenomic analysis is that APPV could be detected in the brain tissue of APPV PCR-positive piglets with signs of congenital tremor. In these NovaSeq sequenced samples, reads classified as human respovirus-1 were also detected. Human respovirus causes a seasonal upper respiratory tract infection, common in humans  [48]  and the finding is probably caused by human contamination during library or sequencing preparation. Another probable contaminant was detected in the Miseq generated datasets, i.
e. , in the datasets of the healthy piglets and the piglets with signs of splay leg; reads and contigs classified as Equine infectious anemia. The common discovery of reads and contigs classified as Equine infectious anemia virus in datasets produced by metagenomic next-generation sequencing has recently been attributed to a reagent contaminant, a novel reagent-associated lenti-like virus  [33]. Phylogenetic analysis of this novel reagent-associated lenti-like virus shows that it is closely related to and clusters with several known sequences of Equine infectious anemia virus, making it a recurrent classification and alignment error in datasets  [33]. No true viral hits could be detected in the APPV-PCR negative piglets with signs of congenital tremor, the piglets with signs of splay leg, or the healthy piglets.
It can therefore be assumed that the sequencing depth was enough to detect a clinical infection as well as obvious contamination. However, it may be speculated that part of the full CNS-virome, such as phages or endogenous retroviruses, was lost during pre-preparation and library preparation. Almost all pigs carry porcine endogenous retroviruses incorporated in their chromosomes  [49, 50]  but these viruses will not be detected in datasets if precautions are taken to remove the host genome i. e. , pig genome, as done in the present study. To date, there are no published studies on the porcine CNS-virome available for comparisons with the results from the sequencing in the present study, since publications describing the porcine virome, with a few exceptions, mainly focus on organs relevant for xenotransplantation  [49].
MiSeq sequencing In the MiSeq sequencing, the eight healthy piglets and six piglets with signs of splay leg were included. Sequencing libraries for the MiSeq run were prepared using the Trio RNA-Seq Library Preparation Kit (NuGEN Technologies, San Carlos, CA, USA). The library concentration was measured using a Qubit ® 2. 0 Fluorometer (Thermo Fisher Scientific, Paisley, UK) and an Agilent High Sensitivity DNA Kit (2100 Bioanalyzer, Agilent Technologies, Palo Alto, CA, USA). Based on the concentration, pooling and normalization to 2 nM were performed. The library pools were diluted in RNase-free water. Paired-end sequencing was performed with a MiSeq Reagent Kit v3 600 cycles on the MiSeq instrument (Illumina, San Diego, CA, USA) at the National Veterinary Institute, Uppsala, Sweden. The quality of the dataset was assessed using the FastQC software  [53].
Assembly of sequence reads To analyse the produced datasets a NextFlow pipeline was implemented. The pipeline included the following steps: quality control and trimming of the reads using FASTP version 0. 19. 5  [54] , removal of the host reads by mapping on Sus scrofa genome using bowtie2 version 2. 3. 5. 1  [55] , and de novo assembly of the remaining reads using MEGAHIT version 1. 2. 9  [56]. Taxonomic classification of the reads was performed using Kraken 2 version 2. 0. 8-beta [57]  against the nucleotide non-redundant (nt) NCBI database. For the taxonomic classification of the assembled contigs, two methods were used and compared: Kraken2 and DIAMOND version 0. 9. 24. 125  [58]. Kraken2 was run against both the non-redundant protein database (nr) and the nucleotide non-redundant (nt) NCBI database, and DIAMOND was run against the nr protein database.
The pipeline is fully available online at GitHub (https:// github. com/ jhayer/ nf-metav ir). The resulting reports were visualised using Pavian  [59]. Additionally, specific alignments against the APPV genome (NC_030653. 1 Atypical porcine pestivirus 1 isolate Bavaria S5/9 polyprotein gene, complete cds) were performed using Bowtie2 version 2. 3. 5. 1  [55].
Statistical analysis Statistical analysis was performed using the software Prism 7. 0 (Graph-Pad). Differences in the expression of cytokine genes between the APPV negative healthy piglets and APPV positive piglets were calculated using an unpaired t-test on ΔΔCq values. To test for correlation in the expression of STING and IFN-α, a bivariate fit analysis was performed using the JMP ® Pro 15. 2. 0. The model included the observations of the expression of STING and IFN-α from the thirteen APPV-genome positive piglets with signs of congenital tremor. For all tests, p-values below 0. 05 were regarded as significant. When indicated, variability of gene expression data is reported as mean FC ± SD.
Acknowledgements The authors would like to acknowledge funding from  The Royal Swedish Agricultural Academy  (Grant number  GFS2020-0064 ) and 'The  Swedish Research Council for Environment, Agricultural Sciences and Spatial Planning ,  Formas ' under the project " Neurotropic viruses in pigs: the role in congenital disease " (Grant number  2016-00979 ). We would also like tothank the farmers and  Gård och Djurhälsan in Uppsala. The authors would like to thank thesequencing facilities. NovaSeq sequencing was performed by the  SNP&SEQ Technology Platform inUppsala. The facility is part of the  National Genomics Infrastructure (NGI)Sweden and Science for Life Laboratory. The SNP&SEQ Platform is alsosupported by the  Swedish Research Council  and the  Knut and Alice WallenbergFoundation. Robert Söderlund  and KarinUllman at the  National Veterinary Institute in Sweden  provided valuableassistance with the MiSeq sequencing.
Shelf mask To define the boundary of the Shackleton Ice Shelf, we make two small modifications to the shelf mask from the MEa-SURES dataset  (Rignot et al. , 2013; Mouginot et al. , 2017). Firstly, we exclude the front ∼ 25 km of the Denman Glacier tongue, where the pixels become progressively more icecovered each summer owing to the glacier's high flow velocity  (Miles et al. , 2021). Secondly, we exclude the westernmost edge of the shelf, which is often bordered by a polynya  (Nihashi and Ohshima, 2015). Manual inspection of the underlying T B data indicates that the pixels along the western https://doi. org/10. 5194/tc-16-4553-2022 The Cryosphere, 16, 4553-4569, 2022 edge may have been contaminated by the inclusion of sea ice and open ocean in the sensor footprint and are therefore not suitable for use with our algorithm, which is only designed to differentiate between wet and dry snow.
Acknowledgements. We would like to thank the editor and reviewers for their time and insightful comments, which have helped make the manuscript stronger. We also thank  Christiaan van Dalum  for providing the RACMO2. 3p3wind vectors used in Fig. 7e. support. Dominic Saunderson  was supported by the  Monash Graduate Scholarship (MGS) and Monash International Tuition Scholarship (MITS). This research was carried out as part of the  Australian Research Council (ARC) SRIEAS  grant  SR200100005 ,  Securing Antarctica's Environmental Future. Felicity McCormack  and  Richard Selwyn Jones  were also respectively supported by  ARC Discovery Early Career Research  awards  DE210101433  and  DE210101923. Ghislain Picard  was supported by  ESA/AO/1-9570/18/I-DT -4DAntarctica. Review statement. This paper was edited by  Alexandre Langlois  and reviewed by  Jennifer Arthur  and  Ian Willis.
Code and data availability. The AMSR-E, AMSR-2, and SSMIS binary melt data can be accessed online at https://doi. org/10. 18709/perscido. 2022. 09. ds376  (Picard, 2022). The R code used in this analysis can be accessed online at https://doi. org/10. 26180/21132934. v1 (Saunderson, 2022). RACMO2. 3p3 model output  (van Dalum et al. , 2021)  is publicly available online at https://doi. org/10. 5281/zenodo. 5512077. LIMA  (Bindschadler et al. , 2008)  and MEaSURES  (Mouginot et al. , 2017)  are publicly available online and also accessible within Quantarctica  (Matsuoka et al. , 2021). REMA (Howat et al. , 2019)   is available online at https://www. pgc. umn. edu/data/rema (Polar  Geospatial Center, 2022). Supplement. The supplement related to this article is available online at: https://doi.
Coordination languages for tuple spaces can offer significant advantages in the specification and implementation of distributed systems, but often do require manual programming effort to ensure consistency. We propose an experimental technique for automated replication of tuple spaces in distributed systems. The system of interest is modelled as a concurrent Go program where different threads represent the behaviour of the separate components, each owning its own local tuple repository. We automatically transform the initial program by combining program transformation and static analysis, so that tuples are replicated depending on the components' read-write access patterns. In this way, we turn the initial system into a replicated one where the replication of tuples is automatically achieved, while avoiding unnecessary replication overhead.
2 o attain automated replication, we first work at the programming interface level, by implementing extended primitives for replica-aware manipulation of tuples. Taking inspiration from the way Klaim's operational semantics was extended in RepliKlaim, we extend goSpace's programming interface to obtain what we call RepligoSpaces. The extended primitives make it possible to target multiple tuple spaces for a single store operation. In addition, an embedded tracking mechanism allows to consistently remove/update the replicated data at need. At this point one could immediately obtain full consistency by using the extended primitives to replicate every tuple to every shared space in the system. This could be automatically obtained via program transformation, by replacing the tuple manipulation operations with their replica-aware versions, but would likely result in unnecessary overhead.
For this reason, between the replica-aware data-handling layer and the program transformation part, we introduce a static analysis pass to refine the target spaces for each store operation. This simple workflow is easily extensible, given the modularity between the data-handling layer, the program transformation schema, and the static analysis procedure. Different static analysis techniques may be plugged in relatively effortlessly. At the same time, alternative replication policies and consistency models can be quickly prototyped by altering the existing replica-aware primitives. We see this as a first step towards developing an integrated framework to experiment with data replication in distributed systems with tuple spaces. We would like to emphasise that our goals do not yet include an efficient implementation of RepligoSpaces.
We expand the experimental evaluation of the case study considered in  [8]  to include the alternative replication mechanisms. We also sketch another case study, a network of work-stealing cooperating service providers, and discuss how to use our experimental methodology to assess the effects of the different replacement policies; in particular, we show how to use our technique to evaluate the tradeoff between local memory size and quality of service. The rest of the paper is organised as follows. Section 2 provides a preliminary introduction to Klaim RepliKlaim, and pSpaces. Section 3 presents our RepligoSpaces prototype that implements the replica-aware tuple manipulation routines. Section 4 presents our automated replication procedure based on static analysis and program transformation.
Extended operations The MPut operation in Listing 1 adds a tuple to a set of spaces. It takes as input a tuple t and a set S of space identifiers, in the form of strings that encode their URIs. The idea is then to simply perform a normal goSpace Put operation for every space in S (lines 10-13). To do so, we need a reference to the space object identified by the URI at any given position of the set S. For this, we use a global map Sp from URIs to references to space objects. Note that this is not a limiting factor as our source transformation procedure will automatically populate Sp for us (Sect. 4). Note that the actual tuple being stored is not exactly t, but an extended tuple obtained by appending S to t (lines 4-7). This avoids centralised tracking of the storage locations  [5]  and simplifies the implementation.
Static analysis and program transformation We now discuss our approach to automatically transform an initial Go program that uses goSpace for data manipulation into an equivalent program that uses RepligoSpaces (Sect. 3). Intuitively, a fully-consistent but inefficient replicated system may be easily obtained by atomically re-applying every output operation to every shared space (regardless of the originally intended target) using the extended programming interface of Sect. 3. We aim at reducing unnecessary overhead by automatically inspecting the program to refine the set of target spaces. To that end, we rely on static analysis to extract from the initial program the data access patterns, and then use this information during a program transformation phase. Input structure Our initial program (Listing 7) is composed of a set P of n parallel processes performing concurrent computations over a set S of n shared tuple spaces.
This assumption does not affect the generality of our approach. Fields that match the result of an arbitrary expression may be handled by first storing the result in a dedicated variable and then using a reference to that variable in the tuple. What matters here is the type of the expression (and therefore of the dedicated variable), which may be statically determined in languages with strong, static typing such as Go. The matching mechanism initially compares the number of fields of t and p: if they are different, then certainly there is no match; otherwise, there is still the possibility for t and p to match. The matching is then refined based on the actual fields of the tuple and the pattern, ignoring any formal fields or placeholders. A difference of any actual field at the same position of t and p indicates a mismatch.
Program transformation We can now transform the initial program to automatically achieve replication, by converting all the operations to goSpace into calls to the new RepligoSpaces routines introduced in Section 3, and using as target locations for write operations the sets computed by the matching technique above. The program transformation procedure takes as input the initial program and the data-access tables built via the static analysis pass described above, and generates a program where each tuple is replicated as indicated by the corresponding access lists. This can be done by parsing the input program into an abstract syntax tree, and then performing a series of pattern-based transformations on (parts of) this tree. To see how pattern-based syntax tree transformations work, let us now consider the function call at line 21 of Listing 7, where process1 performs a Put operation of the tuple ("A",10) into the local tuple space s1.
This fragment of code will trigger transformation because the referenced object (s1) is a tuple space (which is detected via a symbol table lookup) and the Put method is among the relevant ones. In the syntax tree, the corresponding subtree for the whole expression is therefore changed into a call to MPut (see Listing 1 from Section 3); new child nodes are appended to the function call node in the syntax tree for the extra parameters as shown in Listing 8. Un-parsing the syntax tree modified in this way will produce the transformed program. Example We now show how the procedure described above leads from the program of Listing  Let us first consider the tuple ("A",10) stored by process1 at line 21. The GetP operation at line 31 process2 uses as the pattern a string constant and a formal field of integer type.
We finally obtain the modified program P by un-parsing the modified syntax tree. The code of our open-source prototype is available at https://github. com /lou1306 /Replication /releases /tag /v2. 0. The prototype is written in Go, partly because of the availability of the actively maintained goSpace library, and partly because the standard libraries for Go provide built-in facilities for static analysis and transformation of abstract syntax trees, which has greatly reduced our overall implementation effort.
We model the system described above as a concurrent Go program where n is the number of peers, T b is the busy threshold, T L is the upper load threshold, and p a is a peer's probability of accepting (vs. handling) a request. In addition to the n peers, the system contains one request generator. The request generator randomly creates 100n service requests and stores them in the tuple space of their receiving peers. We model a service request as a triple (i, j, τ ) where i is the id of the peer receiving the request, j the service id, and τ a timestamp recording the creation time of the request. 3 ach peer i repeatedly tries to either accept a new request, or handle an already-accepted request. The request accepting behaviour works as follows. First, i tries to withdraw a request tuple from its own space with a GetP operation.
Related work In addition to the pSpaces family of implementations, tuple space systems have been embedded in a number of different programming languages. Java implementations include Klava  [12]  for Klaim, and jRESP 4  for SCEL  [13]. jSpace, the implementation of pSpaces in Java, was initially based on a fork of jRESP. We chose to work on top of pSpaces because it is actively maintained. Besides RepliKlaim  [5] , tuple replication has also been implemented in X10  [14] , a general-purpose language for largescale distributed systems  [3]. An extension of Lime, a distributed tuple space for mobile ad-hoc networks, relies on replication to increase availability  [15]. While not explicitly aimed at replication, LogOp  [16]  also extends Linda operators with scopes, which dynamically resolve to one or more tuple spaces upon which the operation will be performed.
Dynamic replication has been considered in  [22, 23]. Several program transformation frameworks for different languages are available. A popular framework for C and C++ is ROSE  [24] , where the syntax tree can be directly modified and then un-parsed to obtain the modified program. Another transformation framework for C and C++, widely adopted in software verification, is the Clang compiler framework  [25]. As Clang does not allow to modify the abstract syntax tree, program transformation is obtained by directly altering the relevant fragments of the initial source code. In our approach the model of the system to be replicated is expressed as a Go program, and standard Go packages support either of the above techniques. This was another reason for choosing the Go implementation among the available ones of pSpaces.