dataesr/scientific-paragraphs-categorization huggingface dataset:
Transcriptomics data processing and analysis Galaxy platform was used to analyse the transcriptome data  (Afgan et al, 2016). Quality check was assessed with FastQC v0. 11. 8 (http://www. bioinformatics. babraham. ac. uk/projects/fastqc/). After trimming with Trim Galore! v0. 4. 3 (http://www. bioinformatics. babraham. ac. uk/projects/ trim_galore/), reads were aligned to the genome assembly GRCm38 using RNA STAR2 v2. 5. 2b  (Dobin et al, 2013). Gene counts were calculated with featureCounts v1. 6. 4  (Liao et al, 2014)  and differentially expressed gene (DEG) analysis was performed with DESeq2 v1. 22. 1  (Love et al, 2014). Gene counts were turned into log2 scale and used to perform Principal Components Analysis. Volcano plot for differences between PA and BSA treatments was drawn using EnchancedVolcano (https://github.
com/kevinblighe/EnhancedVolcano). Significant DEGs were then divided into 12 clusters using the soft clustering tool Mfuzz v2. 40. 0  (Kumar & M, 2007)  and computed clusters were assigned to expected expression change patterns. We investigated more closely the genes with expression patterns changed between BSA and PA treatment as well as PA and PA/OA treatment. Using Bioconductor package clusterProfiler v3. 8. 1  (Yu et al. , 2012) , enriched gene ontology categories for biological processes were compared and 25 most significant terms were plotted. All the analysis and data visualization was conducted in R v4. 1. 0. For the transcription factor activity estimation, T-values of the differential analysis of PAvsCtrl, OAvsCtrl, OAvsPA/OA, PA/OAvsCtrl and PAvsPA/OA were used as input statistic for the viper algorithm  (Alvarez et al, 2016).
Regulon of TF and targets were obtained from the dorothea R package  (Holland et al. , 2020). Only TF-target interactions that belong in the confidence class A,. B and C were kept. The viper function was used with default parameters, except minimum regulon size of 5, eset. filter parameter set to FALSE and pleiotropy parameter set to FALSE. Biweight midcorrelation (bicor) was systematically estimated between TFs and lipid abundances using the bicor function of the WGCNA R package. To do so, average TF activities were first estimated at the level of individual conditions using the same method as described in the previous paragraph. Then, average TF activities across conditions (Ctrl, OA, PA/OA, PA) were correlated with average lipid abundance across the same conditions. To focus on the top associations between TFs and lipids, we selected TFs-lipids bicor coefficients above 0.
MS data acquisition Samples were analyzed by direct infusion on a QExactive mass spectrometer (Thermo Scientific) equipped with a TriVersa NanoMate ion source (Advion Biosciences). Samples were analyzed in both positive and negative ion modes with a resolution of Rm/z=200=280000 for MS and Rm/z=200=17500 for MSMS experiments, in a single acquisition. MSMS was triggered by an inclusion list encompassing corresponding MS mass ranges scanned in 1 Da increments  (Surma et al, 2015). Both MS and MSMS data were combined to monitor CE, DAG and TAG ions as ammonium adducts; PC, PC O-, as acetate adducts; and CL, PA, PE, PE O-, PG, PI and PS as deprotonated anions. MS only was used to monitor LPA, LPE, LPE O-, LPI and LPS as deprotonated anions; Cer, HexCer, SM, LPC and LPC O-as acetate adducts and cholesterol as ammonium adduct of an acetylated derivative  (Liebisch et al, 2006).
Data analysis and post-processing Data were analysed with in-house developed lipid identification software based on LipidXplorer  (Herzog et al, 2012; Herzog et al, 2011). Data post-processing and normalization were performed using an in-house developed data management system. Only lipid identifications with a signal-to-noise ratio >5, and a signal intensity 5-fold higher than in corresponding blank samples were considered for further data analysis. Lipidomics data were represented using the cytoscape software (https://cytoscape. org).
Lipid droplets protect from PA-induced cytotoxicityTAG formation is catalyzed by DGAT1 and DGAT2. To test their role in LD formation, we tested inhibitors of DGAT1 (T863) and DGAT2 (PF06424439) at different concentrations. We found that the combination of DGAT1 and DGAT2 inhibitors completely inhibited the formation of LDs (Fig S7A,B). Moreover, in iRECs treated with BSA or PA/OA, DGAT1/2 inhibitors caused only minimal changes in the relative amount and saturation of each lipid class (Fig 7A,C). By contrast, in iRECs treated with PA, the inhibitors caused major disturbances (Fig 7B). We observed a massive accumulation of oversaturated TAG precursors (lysophosphatidic acid, phosphatidic acid and diacylglycerols) as well as increased relative levels of saturated lysophospholipids. Especially remarkable is the increase of lysophosphatidylcholine, again reflecting the homeostatic response to prevent the production of oversaturated phosphatidylcholine species.
photon laser set to 800 nm. Two emission bands were acquired (band1: 43-463 nm, band2 473-503) using a 20x objective. Next, individual pixels (containing the signals of the two bands) were trained and classified using Ilastik (v. 1. 3. 3) (Berg et al, 2019)  as 'background', 'nuclear', 'perinuclear', or 'periphery'. Of all pixels except 'background', C-Laurdan Generalized Polarization (GP) values were calculated by the following formula: GP= (Iband1-Iband2)/(Iband1 + Iband2). For convenience, absolute GP values were z-scaled (mean = 0, sd = 1, over the full dataset). Images of pseudocolored GP values were generated in R (v. 4. 1. 0) using the packages ggplot2 (v. 3. 3. 5) and tiff (v. 0. 1-8).
Acknowledgements We thank  Sophie Berissi  for help with histology staining procedures,  Hermann-Josef Gröne  for help with the histological evaluation,  Shrey Kohli  and  Berend Iserman  for help with urine analysis and  Yung-Hsin Shin  and  Gwenn Le Meur  for excellent technical assistance. We acknowledge the  European Research Council (ERC)  under the European  Horizon 2020 research and innovation programme  (Grant agreement No. 865408  (RENOPROTECT) to M. S and No. 804474  (DiRECT) to S. S. L), the  Deutsche Forschungsgemeinschaft  ( DFG SI1303/5-1  ( Heisenberg-Programm ) and  DFG SI1303/6-1 ), the  Steno Collaborative Grant  from the  NovoNordisk Foundation  ( NNF18OC0052457 ) (all to M. S. ) and the  Swiss National Science Foundation (NCCR Kidney. CH  and  310030_189102 ) to S. S. L.
Tkwant is a Python package for the simulation of quantum nanoelectronics devices to which external time-dependent perturbations are applied. Tkwant is an extension of the kwant package (https://kwant-project. org/) and can handle the same types of systems: discrete tight-binding-like models that consist of an arbitrary central region connected to semi-infinite electrodes. The problem is genuinely many-body even in the absence of interactions and is treated within the non-equilibrium Keldysh formalism. Examples of tkwant applications include the propagation of plasmons generated by voltage pulses, propagation of excitations in the quantum Hall regime, spectroscopy of Majorana fermions in semiconducting nanowires, current-induced skyrmion motion in spintronic devices, multiple Andreev reflection, Floquet topological insulators, thermoelectric effects, and more.
This article presents tkwant, a software library that implements state-of-the-art algorithms for the simulation of non-interacting time-dependent quantum transport. 29 kwant (Time-dependent kwant) is an extension of the kwant  30  Python library for DC quantum transport. Tkwant can simulate a wide variety of models for different materials (semiconductors, graphene, topological materials, superconductors, metals, magnets, etc. ), different geometries (Hall bars, rings, wires, etc. ) in arbitrary dimension (1D, 2D, 3D,. ), in presence of arbitrary perturbations (voltage pulses, polarized light, static or dynamical disorder, time-dependent electrostatic gates, etc. ), and an arbitrary number of connected electrodes. Tkwant has been designed to be easy to learn, to use, and to extend. It is the hope of its authors that it will be useful for many new projects outside of its original range of applications.
The article is organized as follows: Sec. II introduces tkwant through a simple concrete example: the propagation of a voltage pulse inside an electronic Fabry-Perot cavity. Sec. III provides a brief presentation of the main theoretical objects of time-dependent quantum transport. The different numerical algorithms used in tkwant are discussed in Sec. IV. Sec. V discusses how the structure of the code is organized to handle one-body and many-body problems. Sec. VI illustrates various aspects of tkwant with a full-scale application: propaga-tion of a voltage pulse sent off an electrostatic gate deposited on top of a graphene quatum billard. Summary and conclusion remarks are given in Sec. VII. Additional technical details on the band structure analysis and calculation of boundary conditions in electrodes are given, respectively, in Appendix A and B.
II. TKWANT IN A NUTSHELL This section features a rapid tour of tkwant. We start by formulating the type of problems that tkwant can solve. Then, we present a simple, yet nontrivial, example calculation for the propagation of an abrupt voltage raise in a one-dimensional Fabry-Perot interferometer. The complete source code for this example is discussed, in order to illustrate the close relation between the short Python code that one writes and the mathematical model than one wants to simulate. Finally, we review various existing applications of tkwant.
The Hamiltonian for this system reads where i is a static onsite potential that defines the cavity. The Fermi level is fixed at E F = -1 and the temperature at zero. The time-dependent ramp-up voltage, Ĥ(t) = Ns+1 i i ĉ † i ĉi - ∞ -∞ ĉ † i+1 ĉi -[e iφ(t) -1]ĉ † 1 ĉ0 +h. c. , (8) V (t) =      0, for t < 0 V b 2 1 -cos πt τ , for 0 ≤ t ≤ τ V b , for t > τ (9) is applied to the left electrode (i ≤ 0). The voltage ramp amounts to adding an extra phase φ(t) to the hopping from the electrode to the central system, see Eq. (  4 ). The current I(t) takes the form I(t) = i[ ĉ † i0 ĉi0+1 (t) -ĉ † i0+1 ĉi0 (t)], (10) where the site i 0 is chosen in the right part of the central region, outside of the Fabry-Perot cavity. To simulate the system described above with tkwant, it is sufficient to write the short Python program that can be found below in Listing 1.
Such Python scripts replace the traditional input files of standalone numerical simulation programs while providing more flexibility for defining the system, analyzing the results and combining tkwant with other packages. Tkwant defines objects that represent highlevel concepts closely matching the mathematical objects of the underlying formalism. All these objects have a documented application programming interface (API) and are exposed to the user in order to provide as much flexibility as possible. import tkwant import kwant from math import sin, pi import matplotlib. pyplot as plt def make_fabry_perot_system(): # Define an empty tight-binding system on a square lattice. Understanding this script requires basic familiarity with the Python language. The first function make_-fabry_perot_system() defines a kwant system that implements Eq.
The actual tkwant code starts with tkwant. manybody. lead_occupation(), when one defines a chemical potential of E F = -1 for all leads. The temperature is zero by default. The creation of a tkwant. manybody. State instance initializes the timedependent many-body state. This many-body state is evolved according to the many-body Schrödinger equation using the state. evolve() method. The state. evaluate() method is used for the on-the-fly calculation of the current. Note that the function state. evaluate() returns either scalars or regular Python (NumPy 35 ) arrays so that any post-processing or plotting of the data can be performed with standard Python tools. The apparent simplicity of the above script hides a lot of technicalities and default values for certain parameters. Tkwant can be used in this default "automatic" mode which is sufficient for many purposes.
V. SOFTWARE ARCHITECTURE AND MAIN CONCEPTS In this section, we describe how tkwant is organized. tkwant implements several concepts that provide a clean separation between the different subproblems and allow the package to be easily modified or extended. For instance, although tkwant's main focus is time-dependent nanoelectronic problems, it can also be used for simpler problems such as the propagation of a single-particle wave packet in an infinite or even finite system. Tkwant has separate APIs for one-body problems and many-body problems. For each of these, it proposes a low-level interface that exposes all the mathematical objects used in the algorithms and a high-level interface that provides additional functionality as well as heuristics to propose robust values of the simulation parameters (such as the imaginary potential or the number quadrature points in the calculation of the integrals).
5 ). The Hamiltonian matrix Eq. (  42 ) is defined explicitly using sparse matrices, psi0 is the initial condition and the one-body Schrödinger equation is solved using tkwant. Running this script takes only a few seconds on a desktop computer. Listing 3 performs the same task as Listing 2 but uses kwant  30  for the construction of the Hamiltonian matrix and for the calculation of the density. For such a simple example, using kwant is superfluous. However in more complex situations (time-dependent systems of various shapes, with different lattices or topologies, etc. ) it becomes very handy. The method evaluate() calculates the expectation value of an operator. The class onebody. WaveFunction interprets any argument with name time automatically as the time argument and attributes the corresponding Hamiltonian elements to the W (t) matrix.
1 from tkwant import onebody 2 import kwant 3 import numpy as np 4 import matplotlib. pyplot as plt    Listing 3. This Python code is similar to Listing 2 except that the Hamiltonian matrix and the density operator are defined using kwant  30. The object syst is the Kwant object that represents the finite system. It contains the Hamiltonian matrix and can be used by tkwant's one-body solver onebody. WaveFunction. Running this script takes only a few seconds on a desktop computer.
Infinite systems The dynamics of the probability density |ψ(t, x)| 2 for an infinite system is shown in the right panel of Fig. 5. In contrast to the previous example, the wavepacket is not reflected on the boundary of the system but continues its propagation indefinitely. The finite system here only corresponds to the window that we are monitoring but the physical system is strictly infinite and translationally invariant. The corresponding code is shown in Listing 4. The differences with Listing 3 are highlighted in blue. The chain is extended to positive and negative infinity by attaching semi-infinite leads to the kwant system. The Hamiltonian matrix of the infinite (or open) system has a block structure similar to that of Eq. (  2 ). Note that we have to provide special boundary conditions (imaginary potential, cf.
Sec. B) to the tkwant solver (line 41) to deal with infinite systems. 1 from tkwant import onebody, leads 2 import kwant 3 import numpy as np 4 import matplotlib. pyplot as plt     Listing 4. Python code to calculate the time-evolution of the probability density |ψ(t, i)| 2 for an infinite one-dimensional chain (right panel of Fig. 5 ). The object syst is the kwant system that represents the infinite system. It has leads on both sides of the finite scattering region that extend the chain to ±∞. Additional boundary conditions must be provided to the onebody. WaveFunction solver for a system with leads. New lines of code (in blue) and comments (in gray) are highlighted to show the difference to Listing 3. Running this script takes only a few seconds on a desktop computer.
Second, these initial conditions are defined everywhere in the infinite system (hence the appearance of the source terms in the Schrödinger equation, see Section IV B) as opposed to just inside the scattering region as is the case for a simple wave packet. The high-level class onebody. ScatteringStates handles the calculation of these initial conditions, of the associated source terms, and provides robust automatic heuristics for setting up proper boundary conditions in the leads (imaginary potential). Listing 5 shows an example of the API of onebody. ScatteringStates. An instance of onebody. ScatteringStates is an iterable object that returns onebody. WaveFunction objects upon iteration. wave_func = onebody. ScatteringStates(syst, energy=0. , lead=0, tmax=1200)[0] Listing 5. Python code snippet to set up a one-body solver for the time-dependent Schrödinger equation for an infinite system that starts in an initial scattering state.
Listing 6. Python code snippet to build up the many-body wavefunction manually. The different steps reflect the numerical algorithm and the comments follow the preprocessing step described in Sec. V B. Note that the number of interval splits (number_subintervals=10 in the example) is highly systemdependent. The low-level interface has been designed to be very modular so that it can be adapted or extended to new situations easily. The convergence of the integral of Eq. (38) must be checked manually. Increasing its accuracy is possible by using quadrature rules of higher order and by splitting the initial intervals (such as the one shown in Fig. 3 ) into subintervals. We have found empirically that using 10-20 points per sub-interval is usually optimal while using higher orders often brings little benefit.
High-level API The class manybody. State forms the high-level interface for the many-body problem. It takes care of all the preprocessing steps automatically so that setting up a simulation becomes as simple as 1 from tkwant import manybody as mb  Listing 7. Python code snippet to compute a many-body wavefunction in an automatic way. This code should give results similar to the code of listing 6 but an additional adaptive quadrature helps to assure the numerical accuracy. While being slightly less flexible than the low-level approach, it is more convenient and sufficient in most cases. The main additional facility provided by manybody. State is the ability to dynamically adapt the number of points used to perform the energy/momentum integral. The function refine_interval() on line 11 of Listing 7 estimates the error in the integration and then proceeds to split the integration interval into subintervals if necessary.
C. Overall architecture and code design The design of Tkwant is centered around the four classes that have already been introduced above. They implement, respectively, the one-body/many-body states of the system at low/high level of abstraction. Functions exist to help with the various pre-calculations that arise at the beginning of a simulation. Fig. 6  shows the relation between the main tkwant classes. The four solver classes provide at least two methods: an evolve() method to evolve the wavefunction(s) forward in time and an evaluate() method, to calculate expectation values of an operator. Extending the functionality of the solvers can be achieved by providing classes with a similar interface ("duck typing"). We find this approach preferable to inheritance mechanisms. Additional methods, like for instance adaptive refinement, are present in "high-level" classes which are more specialized.
The typical workflow of a tkwant project starts with an analysis of the static properties, such as the dispersion relation of the leads or (the energy dependance of) the conductance matrix of the system. This static analysis allows one to estimate and tune the relevant timescales of the system and can be done for example with kwant. Here, we skip this part for brevity and focus on the timedependent simulations. The complete Python script to perform this numerical simulation and to plot the result is given in code Listing 8. The structure of the script is quite similar to the first example in code Listing 1 and most of the lines are again related to the construction of the system with kwant. The code in Listing 8 can be optionally run in parallel on several cores to speed up the computation.
A few additional lines (related to the user-defined function am_master()) are needed to redirect all output to the master MPI process "rank zero" responsible for plotting the data. # Initialize the time-dependent manybody state. Listing 8. Python code to simulate the electron density of the graphene dot after perturbation with a pulse. Running the code generates the density snapshots shown in Fig. 8. Note that the code can be run in parallel using MPI. Running the code on 48 cores (AMD Opteron 6176 with 2. 3 GHz) takes about 2 hours.
In particular tkwant exposes all the mathematical objects of the relevant theory (e. g. Green's functions, wave functions, dispersion relations, etc. ) and explicitly solves a given mathematical problem. The application to specific physical problems is left to the end user. This is in contrast to the "numerical experiments" approach where the modeling and associated stream of approximations is often partly implicit. In this article, we have presented the package tkwant for time-dependent quantum transport. The design of tkwant itself aims at lowering the entrance cost to new users as far as possible. Exhaustive documentation is available online including a tutorial, additional examples, and complete reference documentation. 29 The authors hope that tkwant will be used with success by many research groups.
KwantSpectrum package Listing 9 shows the code used to generate the right panel of Fig. 9. Lines 6-14 define a lead using kwant. Kwant automatically handles the translational symmetry, i. e. it automatically constructs the two matrices H 0 and V that are needed for the calculation. The actual computation of the spectrum (matching algorithm and interpolation) is performed in line 18. The function kwantspectrum. spectrum() computes the interpolant of the different bands. It returns an object that provides various methods for calculating the intervals of integrations and special points that are used in the rest of the script. 1 import kwantspectrum as ks 2 import kwant 3 import numpy as np 4 import matplotlib. pyplot as plt     • First we calculate the dispersion relation E α,l = E α (k l ) (E α,r = E α (k r )) at momentum k l (k r ) by diagonalizing Eq.
ACKNOWLEDGMENTS This project has received funding from the  European Union 's  H2020 research and innovation programme  under grant agreement No  86268. X. W. acknowledges funding from  FET open  " UltraFastNano " , ANR Flagera "Gransport", French-Japan ANR   QCONTROL  Project  ANR-18-JSTQ-0001  and  French-USA ANR PIRE. Early work on tkwant was funded by the  ERC consolidator Meso-QMC. T. K. likes to thank  Vera Kontos  for help with the figures and acknowledges support from the  HLRS Stuttgart. We thank early external users of tkwant for useful feedback including  Michel Fruchard ,  Pierre Delplace ,  David Carpentier ,  Adel Abbout ,  Aurélien Manchon ,  Geneviève Fleury ,  Adel Kara Slimane ,  Phillipp Reck ,  Matthieu Santin ,  Manuel Houzet ,  Tatiane Pereira dos Santos ,  Pacôme Armagnat ,  Baptiste Anselme Martin.