dataesr/scientific-paragraphs-categorization huggingface dataset:
Unfortunately, several of our epochs were affected by bad atmospheric conditions; a combination of poor seeing, spikes in humidity, and/or wind gusts made for unstable fringes on 2012 April 28, 2021 March 6, 2021 May 20, and, to a lesser extent, 2021 December 18. While the CP precision turned out to be sufficient even on these nights, VIS2 and T3AMP had to be completely discarded for the three most affected ones. For 2021 December 18, VIS2 and T3AMP had to be discarded from the MIRC-X part of the data set, while the MYSTIC part could be used in full. The calibrated OIFITS files corresponding to all MIRC(-X) and MYSTIC observations analyzed in this work will be available in the Optical Interferometry Database 22   (Haubois et al. 2014 ) and the CHARA Data Archive. 23.
Optical Spectroscopy We assembled over 500 individual spectra from the archives of various spectrographs, as well as from the database of Be star spectra mostly taken by amateur astronomers, BeSS 24   (Neiner et al. 2011). Heliocentric correction was applied to the wavelength scale of all spectra, and all dates were converted to heliocentric Julian dates (HJD). A significant number of the spectra were originally obtained for spectropolarimetric purposes and to study short-term line profile variations. Therefore, these data sets cluster in a few nights each and have a high S/N. A subset of 15 HEROS blue and 15 HEROS red spectra was previously analyzed by  Saad et al. (2004 Saad et al. ( , 2005 Saad et al. ( , 2021)). The basic properties of the spectra, including the resolving power, S/N, and spectral coverage, are summarized in Table  3 , and the spectrographs are briefly introduced in the following.
Measurement of the Astrometric Positions of the Companion from Interferometry We fitted geometric models to the interferometric data with the open-source Python code Parametric Modeling of Optical InteRferomEtric Data (PMOIRED 29  ; Mérand 2022). This is an analysis tool for interferometry, which relies on semianalytical expressions for complex visibilities to construct geometrical models made from building blocks such as UDs and Gaussians. For the companion detection, we used the dedicated opensource Python code Companion Analysis and Non-Detection in Interferometric Data (CANDID 30  ;  Gallenne et al. 2015) , which includes corrections for the effect of bandwidth smearing on the derived flux ratios. The uncertainties of the fitted parameters were determined using a data resampling (bootstrapping) algorithm and include the instrumental wavelength calibration uncertainty of 0.
The 168 spectra from ESPaDOnS and Narval have the highest quality, resolution, and S/N and yield the most precise RV measurements. The ELODIE data set is the second best in terms of spectra quality, but only two spectra are available. The 25 observations with MUSICOS and the 91 amateur spectra from the BeSS database have comparable resolution to those mentioned above; however, the spectral calibration may be less reliable, as MUSICOS was not optimized for this purpose, and the quality control of the BeSS data reduction procedures may be less stringent. The advantage of the BeSS spectra is that they are more uniformly distributed with orbital phase than the other data sets. The FLASH/HEROS/ FLASH2 spectra are only partly usable for RV measurements due to a much lower resolution. Following an exploration of the influence of discarding lower-quality spectra on the resulting scatter, we conservatively discarded all RV measurements from spectral segments with S/N < 200 per resolution element.
This  resulted in a significant reduction of useful spectra for the lowerquality data sets from BeSS and FLASH/HEROS/FLASH2. For each instrument of origin, the scatter of individual RV measurements at similar epochs was used to estimate their 1σ uncertainties. As expected from the data quality, the scatter is the lowest for ESPaDOnS and Narval and increases by a factor of 2-3 for the other data sources. The following values were finally adopted: 3 km s -1 for ESPaDOnS/Narval, 6 km s -1 for ELODIE, and 9 km s -1 for the remaining instruments.
Adding e and ω as free parameters did not result in an elliptic orbit, so the data are compatible with an infinitesimally low eccentricity and undefined ω. The binary parameters obtained are listed in the first column of Table  6 , where they are also compared to the results from older spectroscopic studies, showing very good agreement in the period (P) and good agreement in the RV semiamplitude of the Be star (K Be ). The rms of the (O -C) residuals of the ESPaDOnS and Narval RV measurements is 2. 6 km s -1. In the next step, we included the full set of 1850 individual RV measurements. As expected, the combined RV curve shows considerable scatter for the lower-quality data sets. More specifically, the MUSICOS measurements in the He I λ4713 line are systematically offset to positive values by about 15 km s -1.
Because of the large brightness difference, RV determinations of subdwarfs orbiting Be stars are difficult  (Wang et al. 2021). The case of κ Dra (in which statistical errors of ∼13% and ∼9% have been obtained for the masses of the primary and secondary, respectively) has illustrated how precise parallaxes can be used as a substitute for missing RVs of one of the two stars. For low-mass companions, the large flux ratio at the operating wavelengths of Hipparcos and Gaia becomes an advantage because the effect of the orbital motions on the astrometric solution is less detrimental. But very high fluxes saturate the detectors and, contrary to first intuition, do not automatically promise larger parallaxes. According to the BeSS database, the two dozen Be stars that are visually brighter than κ Dra are mostly of earlier spectral type, and their higher intrinsic brightness implies distances that can actually be larger.
This work is based upon observations obtained with the  Georgia State University Center for High Angular Resolution Astronomy Array at Mount Wilson Observatory. The  CHARA Array  is supported by the  National Science Foundation  under grant Nos. AST-1636624  and  AST-2034336. Institutional support has been provided from the  GSU College of Arts and Sciences  and the  GSU Office of the Vice President for Research and Economic Development. MIRC-X  received funding from the  European Research Council (ERC)  under the European Union's  Horizon 2020 research and innovation program  (grant No. 639889 ), and N. A. , C. L. D. , and S. K. acknowledge funding from the same grant. Based on INES data from the IUE satellite. This research has made use of the SIMBAD database, operated at  CDS, Strasbourg, France.
This work has made use of the BeSS database, operated at  LESIA, Observatoire de Meudon, France : http://basebe. obspm. fr. This research has made use of NASAʼs Astrophysics Data System. This work has made use of data from the  European Space Agency (ESA) mission Gaia  (https://www. cosmos. esa. int/gaia), processed by the Gaia Data Processing and Analysis Consortium (DPAC; https://www. cosmos. esa. int/web/gaia/dpac/consortium). Funding for the DPAC has been provided by national institutions, in particular the institutions participating in the Gaia Multilateral Agreement. R. K. is grateful for a postdoctoral associateship funded by the  Provostʼs Office of Georgia State University. The research of R. K. is also supported by the  National Science Foundation  under grant No. AST-1908026. This research has made use of the  Jean-Marie Mariotti Center Aspro ,  OIFits Explorer , and SearchCal services (available at http://www.
Software testing plays an important role in building quality software and improving maintainability. However, there are no research studies to analyze its impact on energy efficiency. In this paper, we conduct a preliminary study on the impact of unit tests and code coverage on the energy consumption of software. Our empirical study analyzes the energy consumption of multiple JSON libraries and the relation of their energy efficiency to test metrics. Although our study has limitations in the size of the data set, we found that there are hints for a positive correlation between line coverage and energy consumption.
Introduction Software energy consumption is a major concern for software developers, practitioners  [8]  and architects  [2]. An important issue is the lack of tools to monitor software energy, and limited knowledge in understanding the factors impacting the energy consumption of software  [10]. In particular, the authors of  [10]  note the lack of knowledge on how to write, maintain, and evolve energy-efficient software. The authors also discussed the state of the art of energy-aware software testing, and found that few studies propose energy-aware software testing techniques. These techniques offer new approaches to reduce the energy consumption of test suites  [7] , including in Android  [6] , or detecting energy bugs through software tests  [1]. Current approaches allow software developers to monitor the energy consumption of their devices' architectures  [3] , their applications  [4] , and within the source code  [9] , thus allowing to detect energy hotspots.
The advantages of software testing are well known in terms of improving software quality and maintainability, and reducing bugs. However, the impact of tests quality on the energy efficiency of software is not well understood or studied. In this experiment, we analyze if software written with unit tests and having good code coverage (along with other test metrics) is more energy-efficient than software with no unit tests or low code coverage. In this paper, we focus on the energy consumption of applications from the same domain, all capable of doing a same functionality: parsing JSON files. We measure the energy consumption and capture test metrics from 14 Java JSON libraries studied by  [5] , giving as input a set of well-formed JSON files. We execute the file parsing functionality from all of them given as input the same data set of well-formed JSON files collected by  [5].
This allows us to fairly compare the measurement of the energy consumption for executing that functionality. We focus on JSON libraries because JSON is one of the most used data representation format. For instance, GSON, one of the lib analyzed, is used by more than 331K projects hosted on Github. In the context of Android, energy consumption of applications is an important problem (as mobile users care about energy consumption and the battery life of their devices). Many applications use JSON format for storage of data, and can also receive the result on API call in that format. Our initial results show that applications having a good test suite, expressed in popular metrics such as coverage, does not equate in having optimal power consumption. The remainder of the paper is as follows: we detail our empirical methodology in Section 2, then outline our experimental results in Section 3.
Measuring Energy Consumption We call test workload to the execution of F from an application A given I as input. We measure the energy consumption of the workloads using the power tool called Power-Joular 2  , which uses Linux kernel's Intel RAPL through the powercap interface  3. In order to minimize the impact of any noise during the measurement of energy of F, (caused by e. g. , system states or background services), we run each test workload in a loop for 200 times and measure its energy consumption. We report the energy consumption per loop by dividing the total energy by the number of loops.
Evaluation Dataset In this paper, we focus on a single functionality F: parsing a JSON file for disk for creating a representation of it in RAM. We focus on applications written in Java as it is one of the most used languages in open-source development  7. For our experiments, we use a set of 14 Java JSON libraries that implement this functionality. Those libraries, listed in Table  1 , were previously studied by  [5]. That work considers 20 libraries, however, we could not analyze 6 of them for different reasons, including: a) Unavailable source code, which is required by our experiment to compute the metrics from the tests (  [5]  only uses their binary JARs). b) Build failing due to unavailable dependencies. c) Failure on the computation of test metrics using JaCoCo tool. As input data I, we use the publicly available dataset of JSON files provided by  [5] , conformed by 152 well-formed JSON files.
Analysis and Discussions We first plot the distribution of values of each test metric in Figure  1. We observe that a few libraries have a higher variation of values and are beyond the average range of other libraries. Instead of removing those outliers (as our dataset is limited in this preliminary study), we decide to analyze our data using logarithmic values. This logarithmic transformation allows to decrease the difference between the different values and limiting the impact of outliers while still maintaining the order of values, and it often produces a normal distribution of the studied metrics. Using the logarithmic approach, we calculate, in Table  3 , the Pearson's correlation coefficient between different metrics extracted from the test execution (e. g. , coverage) and the average power consumed by parsing functionality.
A detailed plot of both correlations (in Figure  2  and 3 ), shows that we might have better correlations if not for 2 or 3 out-of-range values. We finally plot a principal component analysis (PCA) graph in Figure  4 , which allows us to synthesize and understand the importance of each metric and to explain the   to each other, then we conclude that a strong correlation exists, while opposite arrows means a negative correlation, and orthogonal means no correlations. We observe that the average power is drawn closer to line coverage, i. e. , a possible correlation exists, while the average power is in near-perfect opposite of uncovered lines, i. e. , a possible strong negative correlation exists. Our statistical analysis, although on a small dataset, sheds the light on potential positive correlation between line coverage and power consumption, and potential negative correlation between uncovered lines and power consumption.
Limitations and Threats to Validity As our paper presents a preliminary study, our experiment and analysis exhibit a few limitations and threats to its validity: • All our analyzed libraries are part of a single application domain: JSON processing libraries. This task involves the CPU and memory access and is not representative of the entire scope of desktop and server applications. • Our study is limited by the number of studied libraries (14 JSON libraries using 152 files, collected by  [5] ), and therefore a limited number of data points to perform statistical analysis and correlations. We also focus on a single functionality (parse JSON files) from 14 libraries. However, the energy consumption from other functionalities also from those libraries (e. g. , store a JSON file on disk) could follow other trends than those we present.
Conclusion In this paper, we performed a preliminary study of the impact of code coverage and test metrics on software energy. We compared the energy impact of the same workload on 14 Java JSON libraries, and analyzed the statistical correlation with testing metrics. Our initial results show that a positive correlation between line coverage and power consumption exists, and a negative one between uncovered lines and power consumption. However, the limitations of our study do not allow us to provide a definitive conclusion. In future work, we aim to further expand the application domains and the tested software in order to collect additional data to confirm or dispute our hypothesis and research questions.
A key practical limitation of MDAs is the fact that the images are only analyzed at the end of the experiment, which sequentially separates the workflows of image acquisition and image analysis. The ability to employ real-time image analysis to inform and optimize or adjust the settings of ongoing image acquisition would be a game changer for studying complex, dynamic cellular processes. Although this strategy requires a deep dive into the software programming and automation of microscopy devices, transformation of a conventional timelapse automated microscope into a powerful unsupervised automaton that is able to acquire data from a live biological sample at the right place and at the right timing could empower researchers in the biomedical sciences. Building on existing automation microscopy software, several groups have started to explore how smart microscopy automate can benefit the life sciences  [1] [2] [3] [4] [5].
In 2011, MicroPilot 5 used LabVIEW© (a proprietary systems engineering automation software) to interface µManager (and other commercial vendor automation software) with a machine learning algorithm to identify and only focus on cells in a specific phase of mitosis. This strategy increased the throughput and decreased the time required to screen the desired cells. Since then, the rise of machine learning and the popularization of simple automation strategies-using Arduino, Raspberry and Python programming-have made it easier to build simple open-source solutions to achieve the same goals. For example, µMagellan  4  and NanoJFluidics 1 were built directly on µManager to achieve some level of feedback loop control and automation of image acquisition. µMagellan focuses on creating content-aware maps to adapt imaging modalities to a 3D biological sample.
NanoJFluidics 1 homemade array of Arduino-controlled syringe pumps combined with µManager can perform automated fixation, labeling and imaging of cells; notably, this system could be triggered by real-time detection of the rounding of mitotic cells through a basic image analysis algorithm. More recently, Pinkard et al. 3  established a Python library that can interact with µManager to program a microscope in a very flexible way, though at the expense of a prerequisite for expert-level python coding skills. Overall, these examples harness the capability of µManager to pilot microscopy instruments and home-made image-analysis tool suites to trigger preprogrammed actions, and thus facilitate the development of complex or time-consuming microscopy experiments. In addition, recent advances in the application of control theory to biology led to the development of external feedback loops, in which cells are analyzed and stimulated in real-time to force the cell state (e.
g. , expression of a gene  [6] [7] [8] [9] [10] [11] [12] [13]  , activity of a signaling pathway  14  ) to follow a user-defined (time varying) profile. Such feedback loops require the ability to perform real-time image analysis, in order to extract cellular features to feed an algorithm that decides how to stimulate the cells in live mode via microfluidics  10, 11  and/or optogenetics  [6] [7] [8] [9] 15. Thi  novel and active field of research, called cybergenetics, harnesses the possibility of creating interactions between cells and a numerical model in real-time, and thus opens novel areas of both applied and fundamental research. To demonstrate the power of cybergenetics, we and others have developed various software to implement feedback loop-controlled microscopy systems. These solutions combine µManager and/or MATLAB with dedicated image analysis and control algorithms to close the feedback loop  10, 11.
However, in practice, these solutions are difficult for non-experts to implement and cannot be easily transposed to a broad range of biological problems. More recently, several groups proposed Python and µManager-based software to develop cybergenetic experiments  16, 17  , though these approaches remain specific to the control of gene expression in cells over time and do not meet all of the varied needs of cell biologists. Here, we present CyberSco. Py software, which is a follow-up to our contributions to piloting gene expression in real-time in yeast and bacteria  10, 11. CyberSco. Py is written in Python, has been designed with automated, real-time feedback loops in mind, and includes deep learning image analysis methods as an integral part of image acquisition. We focused on achieving a proof-ofconcept software with a simple, robust, user-friendly interface that can be deployed as a web application.
CyberSco. py is an open-source web application for timelapse microscopy and microfluidics automation written in Python (Figure  1 ). The software employs real-time image analysis and decision-making algorithms to trigger changes in the imaging parameters in real-time during the experiment. At present, this proof-of-concept is operational on a fully automated Olympus microscope (IX81) equipped with brightfield and epifluorescence illumination and linked to an Arduino-based homemade microfluidic control device (Supplementary Figure  S1  and S2 ). A web interface allows the user to easily setup an experimental plan and/or to select pre-configured conditional experimental scenarios, together with the corresponding image analysis solutions. A local server receives these parameters and launches the experiment.
During the experiment, the acquired images are constantly analyzed and used to trigger events according to the chosen scenario. In particular, the detected events can feedback on the microscopy settings and the microfluidic settings to adapt the experimental plan during the experiment (Figure  1 ). Thus, CyberSco. Py transforms microscopes and their related devices into an advanced imaging automaton capable of performing unsupervised time-dependent tasks with the capacity to handle various user-defined triggers. More details of the CyberSco. Py source code and its documentation are available on the GitHub page of the project (Supplementary Information). Although the software has been developed for a given microscopy setup, it can be extended to any equipment providing there is a driver and/or a documented communication protocol (see Supplementary Information and the GitHub page of the project on how to proceed).
From classic MDA to advanced MDA (aMDA) CyberSco. Py can obviously be used to build classic MDA experiments. A web interface enables the imaging acquisition settings to be easily defined through a drag and drop interface (Figure  1  and Supplementary Information). The user can define X-Y positions and the corresponding focal planes and set the illumination parameters, as in conventional microscopy software. CyberSco. Py makes it easy to perform a classic MDA experiment that follows, for example, the proliferation of a population of yeast cells in a microfluidic device (Figure  2A ). Crucially, the user can define specific imaging settings for each position (Figure  2B ). This modification of how MDA is defined through the user interface is simple but powerful: by design, the user has full control over the acquisition settings without having to follow the classic MDA patterns of nested loops, which by default impose the same imaging acquisition parameters on all time points and positions.
Live cell segmentation enables the use of conditional events to dynamically change the modalities of image acquisition CyberSco. py also offers the possibility of operating the microscope and the attached devices in real-time based on events detected during unsupervised analysis of the cell sample. The central idea is to let the microscope focus on "interesting" events through adjustment of the imaging acquisition parameters without supervision. This task requires efficient image analysis to segment cells, measure their properties and detect cellular events of interest. Image analysis is conveniently achieved in Python using the U-NET convolutional neural network  20  (Materials and Methods and Supplementary Information), which is trained on a set of images. Once the training is complete, CyberSco.