dataesr/scientific-paragraphs-categorization huggingface dataset:
Extraction of Jupiter's signal To obtain both the Jupiter signal (I J1 ) and the sky background in the Jupiter observation I S 1 we first need a RFI mask. Since Jupiter is as bright as the RFI, we used a modified version of the RFI mitigation pipeline presented in  Turner et al. (2017). The following steps are performed: (1) find RFI on the ON-beam above 30 MHz (where no Jupiter emission is present) using the algorithm PATROL  (Zakharenko et al. 2013 , Vasylieva 2015)  to flag entire time steps, (2) find RFI in the OFF-beam (beam 2) using only PATROL to flag entire time steps and frequency channels, and (3) combine the RFI masks from step (1) and (  2 ) together to obtain a final RFI mask. This mask is then applied to Obs #1 and this dataset is used as the Jupiter signal (I J1 ). Next, we find I S 1 for Obs #1 using the least Jupitercontaminated OFF-beam (beam 2) and during a time interval (3740 -3830 seconds after the start of the observation) where Jupiter's emission was minimal.
We subtract by the mean < (xx s ) > to center y around 0. Finally, the time-series is normalized by its standard deviation in order to unify the thresholds. An example of y can be found in Fig. 4a. We further examine Q2 by creating a scatter plot of the ON-beam values versus the corresponding OFF-beam values (Fig. 4b ). In this plot, peaks that appear only in the ON-beam would be visible on the right edge of the cloud of points. An example for Q2 of simulated data is given in Fig. 5a. Due to residual low-level RFI or ionospheric fluctuations, high values of Q2 frequently occur simultaneously in the ON-and OFF-beam (points close to the main diagonal in Fig. 5a ). For this reason, we implemented an elliptical correction, as described in Appendix B. After the elliptical correction is applied, the Q2 distribution of the sky noise data points is much closer to circular, which makes the signal data points more easily detectable.
Therefore, assuming that radio emission from an exoplanet is similar to Jupiter's, searching over a variety of timescales with Q1a and Q4f will be helpful for a detection. This result also indicates that our method of analysis for beam-formed data can be applied to various setups of beam-formed observations and dynamic spectra extracted from rephased calibrated visibilities of imaging pipelines  (Loh et al. in prep). Furthermore, we tested whether the date of observation or the position on the sky has a noticeable effect in our detection limits. For Obs #3, we find detection limits for Stokes-I that are half an order of magnitude less sensitive from those found using Obs #2. However, for Stokes-V we obtain similar detection limits to Obs #2. Next, performing the analysis on Obs #4 we find detection limits that are similar to Obs #2.
Acknowledgements J. Turner  was funded by the  National Science Foundation Graduate Research Fellowship  under Grant No. DGE-1315231. We also thank  PNP  and  PNST  for their support. This research has made use of the Exoplanet Orbit Database (Wright et al. 2011), Exoplanet Data Explorer at exoplanets. org (Han et al. 2014),  Extrasolar Planet Encyclopaedia  (exoplanet. eu)maintained by  J. Schneider  (Schneider et al. 2011), and  NASA 's Astrophysics Data System Bibliographic Services. This paper is based (mostly) on data obtained with the  International LOFAR Telescope (ILT)  under project codes  LC2_018 ,  LC5_DDT_002 ,  LC6_010 , and  LC7_013. LOFAR (van Haarlem et al. 2013) is the  Low Frequency Array designed  and constructed by  ASTRON. It has observing, data processing, and data storage facilities in several countries, that are owned by various parties (each with their own funding sources), and that are collectively operated by the ILT foundation under a joint scientific policy.
Acknowledgements. Experiments were performed on the NanoIR 2-s microscope installed on the SMIS3 beamline, and using the chemistry support lab at SOLEIL Synchrotron, France. This work was supported by the  French Agence Nationale de la Recherche  ( COMETOR ,  ANR-18-CE31-0011 ) as well as  INSU (PNP, PCMI) ,  IN2P3 ,  CNES, DIM-ACAV (Région Île de France) ,  CNRS , the " Défi Origines " from the  MITI (CNRS)  and  Université Paris-Sud. This work is part of the  JWST  emblematic project from the  LABEX-P2IO. We are grateful to the  French and Italian polar institutes IPEV  and PNRA, for their financial and logistic support of the micrometeorites collection at the vicinity of the CONCORDIA station (Dome C).
A common conclusion from these comparisons is that the commutative clause provided by most task parallel run-time systems is quite important for performance, and that this would be a useful upgrade of OpenMP tasks for the future. An alternative track is to develop special purpose software components for the class of FMM-like algorithms, see, e. g. , PetFMM  [12]  and Tapas  [21]. An open source implementation of MLFMA is available through the Puma-EM software  [47] , parallelized with MPI. An example of a commercial MLFMA software is Efield  [16]  provided by ESI Group, parallelized for shared memory.
Furthermore, the run-time guarantees correctness in the sense that if the sequential task flow of the application code is described correctly, the parallel execution guarantees to respect the order up to admissible interleavings. As a proof of concept, we have implemented the NESA algorithm for the electrostatic potential problem using the SuperGlue  [54]  framework. A detailed description of the implementation details and the results can be found in  [63]. A benefit of using the NESA algorithm is that the tasks are more similar both in size and type than for the MLFMA algorithm. The main arguments for choosing the SuperGlue framework are (i) that it has very low scheduling overhead, and can therefore handle small task sizes well, and (ii) that commutative data accesses are naturally included in the dependency management based on dataversioning.
A Task-Parallel Programming Overview One of the key features of task parallel programming is that it makes it relatively easy for the programmer to produce a parallel application code that performs well. However, it is still important for the programmer to understand how to write a task parallel program and how various aspects of the algorithm are likely to impact performance. The granularity of the tasks determines the number of tasks, which has a direct effect on the potential parallelism. As an application programmer, it is beneficial to be aware of how tasks interact with each other and with the data. That is, to understand the character of the data dependencies. There may be different ways of splitting the work that lead to different degrees of parallelism. In the NESA and MLFMA cases, a basic task size is given by the algorithm through the division of the domain into groups.
The discussion to have is whether some groups need splitting (the coarse levels in MLFMA) or merging (the leaf groups). The granularity of tasks also has an effect on how the tasks interact with the memory hierarchy. If the tasks are small enough, data may fit into the cache. If the run-time system is locality-aware such that tasks are scheduled at the cores where the data they need is cached, significant performance gains may be secured. As was discussed in Sects. 2. 3 and 2. 4, the computational intensity provided by the tasks of the NESA and MLFMA algorithms is not enough to scale well if all of the data is read from the main memory. In  [55]  resource-aware task-scheduling is investigated. It is shown that the effect of, e. g, bandwidth contention between tasks can be reduced by coscheduling a mix of diverse tasks.
However, in the NESA case, all of the tasks have a similar computational intensity, so that approach is not applicable. From the user perspective, it would be ideal if there were only one framework for task parallelism, or at least one common standard for task parallel programming implemented by different frameworks. Steps are being taken in this direction, see also the implementation in  [62] , but it will take some time until it is in place. Meanwhile, we provide an overview of some of the more relevant initiatives. The StarPU framework  [5, 52]  was initially developed to manage scheduling between the CPU and GPU resources in one computational node. It has over time been developed in different ways and has become one of the most widely adopted general purpose run-time systems. In StarPU, an important component is the management of data transfers and data prefetching.
Advanced performance prediction based on performance measurements is used in the different scheduling algorithms. StarPU has very good performance for large scale problems with relatively large task sizes. When task sizes become too small, the overhead of the advanced scheduling is too large, and performance goes down. Another important run-time system is OmpSs  [15] , which is the current representative of the StarSs family  [46]. In OmpSs, the tasks are defined through compiler directives in the same way as in OpenMP. In fact, the development of the OpenMP standard in terms of tasks and task dependencies is driven by the development of OmpSs. In this way, the constructs and implementations are well tested before being adopted by the standard. The use of directives can be seen as less intrusive when transforming legacy code into task parallel code compared with the use of specific APIs for task submission.
It is very lightweight, it uses an efficient representation of dependencies through data versions, and has very low overhead, such that comparatively small tasks can be used without loosing performance. Tasks with dependencies were introduced in OpenMP 4. 0. The dependencies are only between sibling tasks submitted in the same parallel region, and there is not yet support for commutative tasks, which are relevant for the NESA and MLFMA types of algorithms. The main reason for using OpenMP is that it is a standard and is likely to remain, making it a relatively secure investment in coding.
The SuperGlue Task Parallel Implementation SuperGlue is implemented in C++ as a headers only library. In order to write a task-based version of the NESA algorithm for SuperGlue, we need to define a SuperGlue task class for the matrix-vector product that is the computational kernel used in all the tasks. In Program 1. 1 we show a slightly simplified code that emphasizes the most relevant parts. The task class contains the data that is touched by the task, a constructor, and a run method. In the constructor, the types of data accesses are registered. In this case, it is a commutative (add) access to the output vector. The read accesses to the input data are not registered as that data is not modified during execution. The access information is used for tracking dependencies, and extra dependencies increase the overhead cost.
The constructor is called at task submission, while the run method is called at task execution time. In the application code all former calls to the matrix-vector product subroutine should be replaced by the corresponding task submission. If we hide the task submission statement in a subroutine, the syntax of the application code does not need to change at all. The new subroutine that replaces the original matrix-vector product by the task submission is provided as Program 1. 2. There are also other small changes such as starting up the SuperGlue runtime, and the SGMatrix data type, which equips the 'ordinary' matrix type with the data handle that is used when registering accesses. A longer description of the implementation can be found in  [63] , and the full implementation is available at GitHub 1.
The OpenMP Task-Parallel Implementation An implementation with a similar functionality as the task-parallel implementation described above can-with some care-be created with OpenMP as well. A simple task construct was introduced in OpenMP 3. 0, and a depend clause was added in OpenMP 4. 0, to allow dependencies between sibling tasks, i. e, tasks created within the same parallel region. This means that if we create several parallel regions for different parts of the algorithm, there will effectively be barriers in between, and the tasks from different regions cannot mix. The proper way to do it is to create one parallel region that covers the whole computation, and then make sure that only one thread generates tasks such that the sequential order is not compromised. An excerpt from the OpenMP main program that illustrates this is shown in Program 1.
Then the threads try to steal work from each other. This results in contention on the work queues as well as a loss of data locality. The final question we ask in this section is whether OpenMP is efficient enough to use for this problem. We already mentioned the fact that OpenMP currently does not support commutative tasks. The performance of the OpenMP run-time implementations has increased over time, and will most likely continue to do so. The experiments were carried out both on a node of the Tintin cluster, described in the previous section, and on a local shared memory system with 4 sockets of Intel Xeon E5-4650 Sandy Bridge processors, yielding a total of 64 cores. On Tintin, the codes were compiled with gcc version 4. 9. 1 and OpenMP 4. 0, while on Sandy Bridge the compiler was gcc 6.
The partitioning of the global tree structure into subtrees would be performed at a level where the number of groups is at least equal to the number of computational nodes. Then the question is how to share the work and the data for the levels above the splitting point. For the NESA algorithm, this is not such a big problem as the amount of work at these lower levels is small. However, for the MLFMA algorithm, the work increases significantly for the lower levels, as can be seen in Table  2. In this case, the work for these levels needs to be divided between the computational nodes, while the data could potentially be shared by all. A drawback of such an approach could be that this kind of splitting becomes more intrusive from the programming perspective, than just making each subroutine call into one task.
For example, OpenACC allows to write kernels by annotating sequential loop-based code in a style similar to OpenMP parallel loop annotations. The OpenMP task model supports code generation for GPU execution of tasks since OpenMP 4. 0/4. 5 with the introduction of the target directive for offloading computations to accelerator devices. SYCL (https://www. khronos. org/sycl) is a high-level programming layer atop OpenCL that provides a singlesource abstraction for OpenCL based accelerator programming. For improved programmability, task-based runtime systems for heterogeneous programming such as StarPU can also be coupled with higher-level programming abstraction layers such as SkePU  [14] , which, from high-level constructs such as skeleton function calls, automatically generate the API calls for the management of tasks, data buffers and their dependencies by the runtime system.
The Raman measurements have been performed on a Renishaw inVia reflex spectrometer, using a 632. 8 nm He-Ne laser as excitation source with two possible configurations for the polarization of the scattered light with respect to the incident one, crossed (HV), and parallel (VV). The absolute values of the measured frequencies were carefully calibrated prior to any measurement on the Si T 2g phonon mode at 520. 5 cm -1. In Fig. 1a  we present polarization dependent Raman spectra taken at 295 K from an undoped V 2 O 3 polished single crystal (c perpendicular to the surface). In the VV geometry the A 1g mode becomes clearly visible and is centered at a frequency of 7. 4 ± 0. 01 THz. In Fig. 1b  we present our ultrafast reflectivity data on the same specimen (800 nm for both pump and probe, crossed polarization) and at the same temperature (295 K).
This is perfectly consistent with what was previously reported by Misochko et al. 4  , who also found that in V 2 O 3 the shift always occurs in opposite direction. This is clearly shown in Fig. 1c  where the results are summarized for one of the samples: the frequency shift of the pump-probe measurement goes in the opposite direction with respect to the thermal shift, well beyond the experimental error bar. Third, the question of the fluence dependence of the frequency blue-shift is of course a crucial one. The data presented by Moreno-Mencia in Fig. 2  of their Correspondence cover a fluence window that is irrelevant in this respect. Raman measurements are performed with cw sources with a power of the order of mW. In order to approach this very low excitation regime, we performed measurements on the same sample with fluences of 20 μJ/cm 2.
Acknowledgements This work was supported by the  German Research Foundation (DFG)  (through grant Nos. GE 602/4-1 ,  KR3831/5-1  and  Fermi-NEst ;  GRK1621  and  SFB1143 ),  Saint-Petersburg State University  under Research Grant  15. 61. 202. 2015 , Spanish Ministry of Science and Innovation  (Grant No. FIS2016-75862-P ), and  Tomsk State University Academic D. I. Mendeleev Fund Program  (Grant No. 8. 1. 01. 2017 ). The SX-ARPES experiment was performed under Proposal Numbers 2016A3810 and 2018B3811 at SPring-8  BL23SU. The present work was financially supported by  JSPS KAKENHI  Grant Numbers  16H01084  ( J-Physics ) and  18K03553.
Numerical calculations of orbits were performed in the works  11, 12, 18, [23] [24] [25]. We now use them to exhibit the above abrupt separation of orbits and its consequences. The numerical integration of Hamilton's equations is performed using the 6th-order symplectic partitioned Runge-Kutta algorithm built into Mathematica software. Equation 2 shows that a particle initially at rest gains some kinetic energy for any finite value of A. This is the ion pick-up mechanism by the wave, well known in literature  32, 33. By itself, this is not a proper heating since the energy flow may be reversed and returned back fully to the wave once the interaction is switched off. In order to make it irreversible, it must be supplemented by collisions or by the chaos due to the pulsating separatrix (see the Frames show snapshots at increasing times (from left to right and from top to bottom) of the phase-space (x, p) position of a bunch of particles (red dots).
Introduction The CERN Large Hadron Collider (LHC) has recently finished its second physics run and it has entered a long shutdown phase, which is devoted to upgrades of the main experiments. Meanwhile, physics analyses employing the full dataset are being carried out, leading to results with astonishing experimental precision. The absence of any clear indications of new particles or interactions necessitates more and more detailed comparisons of experimental measurements with theoretical predictions. Correspondingly, high-accuracy calculations are of crucial importance in order to match the theoretical uncertainty to the ever decreasing experimental one and to gain sensitivity even to tiny deviations from the Standard Model. In this context, the theory community has put huge efforts in improving perturbative calculations in QCD, both at fixed-order and at the resummed level.
1  Fixed-order corrections are computed with the publicly available program EVENT2  [36, 37]. To further validate the resummed calculation, we evaluated the soft-drop thrust observable in the CAESAR formalism  [38] , using an independent implementation in the Sherpa framework  [39]. In addition a separate calculation was performed, with slightly different treatment of the resummation uncertainty. This is further detailed in Appendix E. To match the resummed result to the exact NLO QCD matrix element, i. e. the three-parton process at NLO accuracy, we consider two different matching schemes: multiplicative and LogR match-ing  [40]. In both cases we consider the cumulative distribution Σ(τ SD ) = 1 σ 0 τ SD 0 dτ SD dσ dτ SD. (2. 6) Multiplicative matching is defined by Σ(τ SD ) = C Σ FO Σ exp FO Σ res C , (2.
3. 1  [47]  package. The default hadronisation model in Sherpa is the cluster fragmentation described in  [48]. However, Sherpa also provides the option to invoke the Lund string fragmentation  [49]  as implemented in Pythia 6. 4  [50]. Using the identical perturbative inputs, i. e. shower-evolved events, this provides us with a consistent estimate for the hadronisation related uncertainties. To analyse events we employ the Rivet-2. 7. 2 package  [51]. To this end we have implemented the soft-drop thrust observable using FastJet-3. 3. 2  [32]  for particle clustering. For the generation of our pseudo data, used in the extractions of α s later on, we consider the highest accuracy Monte Carlo sample which is generated using NLO QCD matrix elements for e + e -→ 2, 3, 4, 5 partons. The MEPS@NLO merging parameter is set to y cut = (Q cut /E CMS ) 2 = 10 -2.
We evolve the strong coupling at the two-loop order, assuming α s (m Z ) = 0. 117. 3 While for the cluster fragmentation model all parameters are kept at their default values, we have set the main parameters of the Lund model to a = 0. 3 (PARJ(41)), b = 0. 6 GeV -2 (PARJ(42)), σ = 0. 36 GeV (PARJ(21)). (3. 1) Comparisons of Sherpa MEPS@NLO hadron-level predictions with LEP1 event-shape data have for example been presented in  [52]. To validate our event simulations, we present in Fig. 2  the plain thrust distribution as measured by ALEPH  [53]. Shown there are the MEPS@NLO parton-level prediction, i. e. after parton showering, and hadron-level results for the cluster and Lund fragmentation model. Furthermore, the purely perturbative NLO+NLL resummed prediction with an estimate of the perturbative uncertainty, indicated by the red band, cf.
In Fig. 7  we present this comparison for plain thrust. The left plot shows the result for the fit to the ALEPH data while the right plot shows those for the Monte-Carlo pseudo data instead. Both plots illustrate a very good agreement of analytic predictions and both the actual collider and the pseudo data over the whole fitting range. The red band represents the theoretical uncertainty on the fitted distribution for the analytical model. The differences to the distribution with hadronisation corrections based on the Monte Carlo model are small compared to the overall size of the uncertainty, so we choose not to include a separate error band for this to keep the plot clearer. It can also be seen that the behaviour in the small thrust region would be hard to reproduce using the analytic model.
1. 00 Table  1 : The results for the fits of α s (m Z ) entering Fig. 6  with the associated values of Ω and χ 2 /dof values. In addition the breakdown of the different contributions to the uncertainties are included. All fits employ Monte-Carlo generated pseudo data. For comparison, in the last row, we also report the results of the fit when using ALEPH data instead. small value of the strong coupling (with large uncertainties). We argued that this originates from the proximity of the transition point and the lower bound of the fitting range, causing an instability in the modelling. The top right plot in Fig. 9  fully supports this interpretation and indeed shows that the issue can be resolved by pushing the lower bound of the fitting range to smaller values. Choosing τ min 0. 05, we obtain fitted values of α s that are compatible with all the other combinations of soft-drop parameters.
Acknowledgments We thank  Pier Monni  for the useful discussions. The work leading to this publication was supported by the  German Academic Exchange Service (DAAD)  with funds from the  German Federal Ministry of Education and Research (BMBF)  and the  People Programme  ( Marie Curie Actions ) of the  European Union Seventh Framework Programme  ( FP7/2007-2013)  under  REA  grant agreement n. 605728 (P. R. I. M. E. Postdoctoral Researchers International Mobility Experience). This work is also supported by the curiosity-driven grant " Using jets to challenge the Standard Model of particle physics " from  Università di Genova. SS acknowledges funding from the  European Union 's  Horizon 2020 research and innovation programme  as part of the  Marie Skłodowska-Curie Innovative Training Network MC-netITN3  (grant agreement no.