Aurélie Simoës-Perlant

Mélanie Mazars

Céline Lemercier

A study of approach-avoidance patterns in children in response to emotional stimuli

de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Introduction

Approach-avoidance patterns are present regardless of our age. How can we refuse a second piece of cheesecake when we love it or ride a thrill ride with our child when it scares us? Some situations instigate psychophysiological responses and the formation of emotional memory images within very short time frames [START_REF] Hudson | Split-Second Unlearning: Developing a Theory of Psychophysiological Disease[END_REF]. That why, our ability to learn, unlearn, and relearn can be hindered by the images that feed these patterns. The ability to approach a positive stimulus (e.g., a pleasant food) and retreat from a negative stimulus (e.g., fleeing from danger) is of considerable importance in the survival of the individual [START_REF] Payen | Motivation d'approche et d'évitement : effets psychophysiologiques de la couleur rouge sur les processus cognitifs et moteurs[END_REF]. However, it is sometimes necessary to resist these natural tendencies in order to resolve difficult situations (e.g., approaching a fire for a firefighter) or to stay away from temptation (e.g., staying away from a pack of candy). Researchers have studied these approach-avoidance tendencies in adults faced with stimuli with positive or negative emotional valence (e.g., [START_REF] Alexopoulos | The evaluation-behavior link: Direct and beyond valence[END_REF][START_REF] Krieglmeyer | Comparing measures of approach-avoidance behavior: The manikin task vs. two versions of the joystick task[END_REF], but they remain little explored in children. We therefore consider it important to better understand these tendencies in children, and to compare them with those of young adults. The online-VAAST word paradigm [START_REF] Aubé | The online-VAAST: A short and online tool to measure spontaneous approach and avoidance tendencies[END_REF] has been shown to be more effective than other methods of exploring approach-avoidance patterns (e.g., motor or visual paradigms). We used it with both of our populations.

Objective and assumptions

Our goal is to analyze approach and avoidance patterns with emotional stimuli in children and adults using the word version of the Visual Approach/Avoidance by the Self Task (VAAST) tool [START_REF] Rougier | A new look at sensorimotor aspects in approach/avoidance tendencies: The role of visual whole-body movement information[END_REF]. Based on previous studies, we would expect to observe an approach pattern for positive words and an avoidance pattern for negative words in all subjects, but a significantly stronger pattern for children than for adults.

Methodology

Population

Sixty participants (34 children and 26 adults) took part in this online research project. Of these, 11 children and 4 adults could not be included in the study because they did not complete the activity. The remaining 45 participants were divided into two subgroups: 22 young adults (4 males and 18 females) 20-30 years old (mean age = 26.95 years; SD = 3.5) and 23 children (11 girls and 12 boys) 8-11 years old (mean age = 9.64 years; SD = 0.9). None of the children included in the sample had a diagnosed psycho-emotional disorder.

Materials

The online VAAST (words) task [START_REF] Aubé | The online-VAAST: A short and online tool to measure spontaneous approach and avoidance tendencies[END_REF] The online VAAST (words) task investigates the approach-avoidance tendencies of individuals when faced with emotionally valenced words. Unlike paradigms that focus on motor aspects (e.g., the arm using a joystick), it visually gives the individual the impression of moving towards or away from emotionally-charged items (e.g., through image depth effects) in a street setting. Likewise, it shows greater effects than those found via a non-sensorimotor version (e.g., with a virtual character) [START_REF] Rougier | A new look at sensorimotor aspects in approach/avoidance tendencies: The role of visual whole-body movement information[END_REF].

In this task, participants are asked to categorize words written in black according to their valence (positive or negative) on a computer screen as quickly as possible. The appearance of each word is preceded by an O symbol followed by a cross on which the subject must focus before pressing the H (start) key. The subjects must then move towards or away from the items according to their emotional valence by pressing the corresponding keys on the computer keyboard (Y and N keys). The word is zoomed in or out by about 13% and the background changes (e.g., a three-dimensional image of the street that is closer to or farther away than the original situation).

The activity consists of two test blocks whose order changes from one individual to another. In one block, participants perform the task in a congruent situation (e.g., moving toward positive items and away from negative items). In the other block, they are placed in an incongruent situation (e.g., moving away from the positive words and approaching the negative words). Each block consists of 40 words (20 positive and 20 negative words) presented randomly and only once. Before each test block, the participants perform a training phase in which they react to 5 positive words and 5 negative words that are not presented in the main experiment. The software records the proportion of correct answers and the reaction time of each participant (in ms) for each item. If there is an approach-avoidance tendency in individuals, reaction times will be shorter in congruent situations than in incongruent situations.

Words with positive or negative emotional valence

We selected 10 positive words and 10 negative words of between 5 and 7 letters, based on the items rated by 9-year-olds in the study by [START_REF] Syssau | Children's emotional norms for 600 French words[END_REF], having an SFI (Standard Frequency Index, Manulex, Lété, et al., 2006) greater than 50 (occurring more than once every 100,000 words) and with no semantic disparity between valences. Chi-square statistical analysis showed no effect between semantic categories and valence (X²(4) = 2.400, p = .663, ns) for these 20 words.

Procedure

Each participant conducted this study at home on their personal computer via the Psytoolkit platform [START_REF] Stoet | PsyToolkit -A software package for programming psychological experiments using Linux[END_REF][START_REF] Stoet | PsyToolkit: A novel web-based method for running online questionnaires and reaction-time experiments[END_REF]). The protocol was followed in three stages in the same way for each person: reading of the instructions (Stage 1), performance of the task in a congruent or incongruent situation (training blocks and then test blocks, Stage 2), performance of the task in the opposite situation to Stage 2 (training blocks and then test blocks, Stage 3). At the end of each training and testing session, participants were rewarded with colored stars and encouraging messages to keep them motivated.

Results

The data collected were analyzed using a generalized linear mixed measures model of median reaction times (in ms) for each emotional valence carried by the words (positive or negative) and for each type of movement (approach or avoidance). We excluded incorrect responses from children (16.4% of tests) and adults (10.1% of tests). The aim was to test whether there Academia Letters, May 2022

Approach-avoidance tendency in adults

The overall analysis shows that adults were faster when reacting to positive words (885 ms) than negative words (949 ms), F(1, 21) = 11.669, p = .003, ²p = 0.357. However, there was no significant impact of movement type alone (approach: 897 ms, avoidance: 937 ms), F(1, 21) = 2.554, p =.125, ns. Furthermore, participants were faster at approaching positive words (832 ms) and moving away from negative words (857 ms) than approaching negative words (1042 ms) and moving away from positive words (938 ms), F(1, 21) = 15.820, p = .001, ²p = 0.430.

Approach-avoidance tendency in children

The overall analysis shows that children were faster when reacting to positive words (1389 ms) than negative words (1745 ms), F(1, 22) = 18.595, p = .000, ²p = 0.458. There was no significant impact of movement type (approach: 1510 ms, avoidance: 1623 ms), F(1, 22) = 0.054, p =.142, ns. However, participants were faster at approaching positive words (1162 ms) and moving away from negative words (1632 ms) than approaching negative words (1857 ms) and moving away from positive words (1615 ms), F(1, 22) = 16.298, p = .001, ²p = 0.426.

Comparison of approach-avoidance patterns in adults and children

If we compare the approach-avoidance patterns between the two age groups, we observe that children take 1.6 times longer than adults (1389 ms vs. 885 ms) to react to positive words and 1.8 times longer to react to negative words (1745 ms and 949 ms). Interestingly, the effect of the difference in item valence was 5.5 times greater in children (356 ms) than in adults (64 ms).

Moreover, in congruent situations, the children were 1.4 times slower than the adults to approach positive words (1162 ms vs. 832 ms) and they took almost twice as long to move away from negative words (1632 ms vs. 857 ms). In incongruent situations, the children had reaction times almost 1.8 times longer than the adults to approach negative words (1857 ms vs. 1042 ms) and 1.7 times longer to move away from positive words (1615 ms vs. 938 ms).

Discussion

Our first hypothesis postulated the presence of a pattern of approaching positive words and avoiding negative words using the VAAST (words) tool (Aube et al., 2019). This hypothesis is validated. Children, like adults, have shorter reaction times in congruent situations than in incongruent situations. Similarly, they tend to react more quickly to positive words than to negative ones. These data corroborate previous work on this topic (e.g., [START_REF] Alexopoulos | The evaluation-behavior link: Direct and beyond valence[END_REF][START_REF] Huijding | Behavioral route to dysfunctional representations: The effects of training approach or avoidance tendencies towards novel animals in children[END_REF][START_REF] Klein | Approach and avoidance tendencies in spider fearful children: the approach-avoidance task[END_REF][START_REF] Rougier | A new look at sensorimotor aspects in approach/avoidance tendencies: The role of visual whole-body movement information[END_REF].

Our second hypothesis posited that approach-avoidance tendencies would be more marked in children than in adults. This hypothesis is also validated. Children do indeed have globally longer reaction times than their elders, whether the situation is congruent or incongruent, as well as reaction time differences between the two valences 5.5 times greater than adults regarding positive words. In other words, individuals seem to be more reactive to positive words than to negative words when they are children. This effect is still present in adults but is less than in childhood. There seems to be a marked attraction for positive emotional stimuli and especially positive words in children. However, the emotionally charged words used in this research are part of the familiar linguistic landscape of children, including in school textbooks. We can therefore question the influence of the emotional valence carried by these words on the child's learning at school. Approach-avoidance patterns can be seen as facilitating to learning in some cases (e.g., the presence of a positive situation) or as deleterious in other cases (e.g., the presence of a negative situation). Split-second unlearning, the process whereby the learner (adult or child) is able to let go of their approach-avoidance behavior [START_REF] Hudson | Split-Second Unlearning: Developing a Theory of Psychophysiological Disease[END_REF], could be a fruitful course to optimisate learning at school.

©2022 by the authors -Open Access -Distributed under CC BY 4.0

©2022 by the authors -Open Access -Distributed under CC BY 4.0


Z Bern

L J Dixon

F Febres Cordero

S Höche

H Ita

D A Kosower

D Maître

Ntuples for NLO Events at Hadron Colliders

Keywords: QCD, vector boson, jets, LHC, Tevatron QCD, NLO, vector boson, jets. Classification: External routines/libraries: Root, lhapdf Nature

We present an event-file format for the dissemination of next-to-leading-order (NLO) predictions for QCD processes at hadron colliders. The files contain all information required to compute generic jet-based infrared-safe observables at fixed order (without showering or hadronization), and to recompute observables with different factorization and renormalization scales. The files also make it possible to evaluate cross sections and distributions with different parton distribution functions. This in turn makes it possible to estimate uncertainties in NLO predictions of a wide variety of observables without recomputing the short-distance matrix elements. The event files allow a user to choose among a wide range of commonly-used jet algorithms and jet-size parameters.

We provide event files for a W or Z boson accompanied by up to four jets, and for pure-jet events with up to four jets. The files are for the Large Hadron Collider with a center of mass energy of 7 or 8 TeV.

Introduction

With last year's discovery of a Higgs-like boson [START_REF] Aad | Observation of a new particle in the search for the Standard Model Higgs boson with the ATLAS detector at the LHC[END_REF][START_REF] Chatrchyan | Observation of a new boson at a mass of 125 GeV with the CMS experiment at the LHC[END_REF] at the Large Hadron Collider (LHC), the ATLAS and CMS experiments at CERN have rounded out our knowledge of the particle content of the Standard Model. Direct searches for new physics beyond it, and indirect searches via precision measurements of the properties of the Higgs-like boson and of the top quark, remain as challenges for ongoing research. Both of these avenues beyond the Standard Model require extensive calculations in QCD to next-to-leading order (NLO), to high jet multiplicity. NLO is the first order in perturbation theory to provide a quantitatively reliable estimate of backgrounds due to Standard-Model processes [START_REF] Bern | The NLO multileg working group: Summary report[END_REF][START_REF] Andersen | The SM and NLO Multileg Working Group: Summary report[END_REF].

NLO calculations require the computation of both virtual and real-emission corrections to processes with high jet multiplicity. The former require the evaluation of one-loop corrections to the basic tree-level process, and the latter require the integration of matrix elements with an additional emitted parton over the phase space for the additional emission. Both parts of the correction are computationally intensive. In order to obtain sufficiently small statistical uncertainties, one must typically evaluate the matrix elements at millions of different kinematic points when performing phase-space integrals by Monte Carlo sampling techniques.

The end results of the calculations are total cross sections or differential distributions for various observables. In developing an analysis 1 , one may wish to evaluate these quantities with different choices of experimental cuts. Different cuts may also be required for comparison with different experimental analyses. The estimation of uncertainties due to variation of the unphysical renormalization and factorization scales, and due to our imperfect knowledge of the proton's parton distribution functions (pdfs), also require that we we recompute the same differential distributions many times. The latter alone can require dozens or grosses of evaluations. A naive rerunning of the entire calculation would force the computationally expensive shortdistance matrix elements to be recomputed a comparable number of times.

The actual evaluation of multiple differential distributions, given a list of kinematic points and matrix-element weights, is however computationally relatively cheap. It is therefore very desirable to amortize the expensive task of matrix-element computation over many evaluations of differential distributions. We can do this by storing each of the phase-space points, along with the matrix elements and other information, in data files. In order to compress these sizeable volumes of data, we store them as Root n-tuple files, or simply 'n-tuple files' for short. We produce n-tuple files using the BlackHat one-loop library [START_REF] Berger | An automated implementation of onshell methods for one-loop amplitudes[END_REF] in conjuction with SHERPA [START_REF] Gleisberg | SHERPA 1.α: A proof of concept version[END_REF][START_REF] Gleisberg | Event generation with SHERPA 1.1[END_REF][START_REF] Krauss | AMEGIC++ 1.0: A matrix element generator in C++[END_REF][START_REF] Gleisberg | Automating dipole subtraction for QCD NLO calculations[END_REF][START_REF] Gleisberg | Comix, a new matrix element generator[END_REF]. In this paper we describe in more detail an implementation of this strategy for a class of interesting multi-jet final states at the Large Hadron Collider (LHC). We document n-tuple files for processes producing a single electroweak vector boson (W ± or Z) in association with 1, 2, 3, or 4 jets, and files for pure-QCD processes producing 2, 3, or 4 jets. In addition, we supply a C ++ library that provides an interface to the files. The n-tuple files also allow other researchers, and especially experimenters, to perform their own NLO analyses, using refined cuts, without the computational expense and management complexity of running high-multiplicity codes. The computations recorded in the n-tuple files do not include showering or hadronization, and the events are not a suitable starting point for matched showers with existing implementations. In contrast to files containing showered events, the n-tuple files documented here have a relatively small number of parton momenta recorded per event, which keeps file sizes manageable. A reweighting technique for estimating scale and pdf uncertainties has also been applied to particle-level event samples that have been generated by merging NLO calculations with a parton shower [START_REF] Frederix | Four-lepton production at hadron colliders: aMC@NLO predictions with theoretical uncertainties[END_REF].

The paper is organized as follows. In section 2, we discuss the organization of an NLO calculation. In section 3, we present the content of event files. In section 4 we explain how to compute differential cross sections using the event files. In section 5, we discuss additional details needed to change scales or parton distribution functions from those in the original calculation. In section 6, we present a software library for reading event files. We summarize in section 7.

NLO Calculations

We wish to store and reuse the matrix-element information computed during an NLO calculation. In order to explain what information we need to record, we first review the components of an NLO calculation. We further refine the information needed in section 5.

Let us consider a process that produces n final-state objects (jets or electroweak bosons). At leading order (LO) in QCD, the prediction for associated observables would be given in terms of a tree-level matrix element for a process scattering two colored partons into n final-state partons or electroweak bosons. Schematically, at this order we can write the differential cross-section in an observable O as follows,

dσ LO dv = dσ n δ v = dx 1 dx 2 dLIPS n f 1 (x 1 )f 2 (x 2 ) σn δ v -O({k} n ) , (1)
where f 1 (x 1 ) and f 2 (x 2 ) are the pdfs for the partons inside the two incoming protons, dLIPS n is the n-particle Lorentz-invariant phase-space measure for momenta {k} n , and σn is the short-distance 2 → n squared matrix element.

We sum over all allowed parton species implicitly. The pdfs f 1,2 also depend on a factorization scale µ F , and the parton-level squared matrix element σn depends on a renormalization scale µ R . These two scales will in general depend on the phase-space point {k} n . However, at LO σn depends on the renormalization scale only through its (homogeneous) dependence on the strong coupling α s (µ R ).

In order for eq. ( 1) to produce a meaningful answer, the phase space must be cut off in regions where the squared matrix elements are singular. We are primarily interested in jet cross sections, and so we shall use a jet algorithm to impose such cuts. We leave them implicit in eq. ( 1).

The integral will typically be performed by Monte-Carlo integration, using a random sample of phase-space points. More sophisticated approaches will adapt the sample to the squared matrix element. The evaluation will generate a list of phase-space points and momentum fractions, along with the associated integration weight. At each phase-space point, we evaluate only a single subprocess, fixing the incoming and outgoing parton types and flavors. In order to recompute any observable in an LO calculation, or compute a new one, it then suffices to save the generated phase-space configurations, along with each configuration's integration weight. Each configuration can be saved by saving the four-momenta of each final-state parton it contains. In order to estimate the scale sensitivity of observables, we must recompute them with different choices of renormalization scale. For this purpose, it suffices to save the choice of µ R for each configuration, as the weight is homogeneous in α s with a fixed power. In order to estimate the uncertainty in an observable due to imprecise knowledge of the pdfs, we must recompute them with different pdfs drawn from an error ensemble. For this purpose, we must also save the initial-state momentum fractions and choice of µ F for each configuration. It is also convenient to save separately the matrix-element weight multiplied by the phase-space volume element; this is the quantity that would yield the integration weight upon multiplication by the pdfs.

The NLO prediction for the same process is more intricate. We can decompose the computation of an observable into a Born-level contribution, along with virtual and real-emission corrections,

dσ NLO dv = dσ Born n + dσ virt n δ v + dσ real n+1 δ v , (2)
where the subscripts indicate the number of particles in the final-state phase space. The virtual and the real-emission corrections are separately infrared divergent. The virtual corrections, given by the interference of one-loop and tree matrix elements, have explicit divergences arising from the integration over the loop momenta. These are usually regulated using dimensional regularization (D = 4 -2ǫ), and appear as double and single poles in ǫ. The infrared divergences in the real-emission contributions arise from regions of (n + 1)-body phase space in which two massless partons become collinear or a gluon becomes soft. We can think of the (n + 1)-body phase space factorizing into a phase space for n final-state objects and an unresolved phase space over soft or collinear partons. Were we to integrate these contributions over a dimensionally-regulated unresolved phase space, the resulting poles in ǫ would cancel against those in the virtual contributions for infrared-safe observables, allowing us to obtain a finite result in the ǫ → 0 limit. However, the integration over the dimensionally-regulated real-emission phase space is intractable analytically in the presence of kinematical cuts. Accordingly, we must integrate numerically; but it is hard to extract singularities, and more importantly, the underlying finite term, by numerical integration in D dimensions. Instead, we seek to separate the real-emission contributions into two parts: a simple part, containing all singularities, to be integrated analytically in D dimensions; and a remainder, whose numerical integral is finite over the complete phase space. The universality of the singular limits of the matrix elements makes this possible. The most common approach, which we use as well, is to add and subtract an approximation to the real-emission squared matrix element that captures all of its divergent collinear and soft limits, and yet is simple enough to be integrated analytically over the unresolved phase-space. This approach started with applications to specific processes [START_REF] Ellis | The Perturbative Calculation of Jet Structure in e + e -Annihilation[END_REF][START_REF] Mangano | Heavy quark correlations in hadron collisions at next-to-leading order[END_REF][START_REF] Kunszt | Calculation of jet cross-sections in hadron collisions at order α 3 3[END_REF][START_REF] Frixione | Three jet cross-sections to next-to-leading order[END_REF] and was later generalized by Catani and Seymour [START_REF] Catani | The Dipole formalism for the calculation of QCD jet cross-sections at next-to-leading order[END_REF][START_REF] Catani | A General algorithm for calculating jet cross-sections in NLO QCD[END_REF] to a process-independent method. We use an implementation of the Catani-Seymour dipole method within the AMEGIC++ [START_REF] Krauss | AMEGIC++ 1.0: A matrix element generator in C++[END_REF][START_REF] Gleisberg | Automating dipole subtraction for QCD NLO calculations[END_REF] and Comix [START_REF] Gleisberg | Comix, a new matrix element generator[END_REF] tree-level matrix-element package (both parts of SHERPA [START_REF] Gleisberg | SHERPA 1.α: A proof of concept version[END_REF][START_REF] Gleisberg | Event generation with SHERPA 1.1[END_REF], with Comix used for the highest-multiplicity processes). Other subtraction methods have also been applied, especially in NNLO calculations [START_REF] Frixione | Three jet cross-sections to next-to-leading order[END_REF][START_REF] Gehrmann-De Ridder | Antenna subtraction at NNLO[END_REF], and related methods are under development [START_REF] Nagy | General subtraction method for numerical calculation of one loop QCD matrix elements[END_REF]. Some of these have also been automated [START_REF] Frederix | Automation of next-toleading order computations in QCD: The FKS subtraction[END_REF]. With a subtraction term, we obtain the following formula for a differential cross section computed to NLO,

dσ NLO dv = dσ Born n δ v + dσ virt n + dσ int n δ v + dσ real n+1 -dσ sub n+1 δ v , (3)
where σint n is the integral of σsub n+1 over the unresolved phase space. Each integral in eq. ( 3) is now finite as ǫ → 0. (The observable must be infrared and collinear safe, that is O n+1 must approach O n in every singular limit, for this to be true.) As the divergent terms in σvirt n cancel those in σint n , we can drop them all, retaining only the finite contributions,

dσ NLO dv = dσ Born n δ v + dσ fin. virt n δ v + dσ fin. int n δ v + dσ real n+1 -dσ sub n+1 δ v . (4)
As in an LO computation, the integrals in eq. ( 4) are most easily computed by Monte-Carlo sampling. (In our setup, using SHERPA [START_REF] Gleisberg | SHERPA 1.α: A proof of concept version[END_REF][START_REF] Gleisberg | Event generation with SHERPA 1.1[END_REF], the code first adapts an integration grid to the integrand, and many independent integrations are done using these grids.) We generate events separately for each of the four types of contributions, over n-particle phase space for the Born (B), virtual (V), and integrated-subtraction (I) contributions, and over (n + 1)-particle phase space for the subtracted real-emission (R) contributions. At lower multiplicities, this split-up is sufficient. At higher multiplicities, however, a further subdivision of contributions is desirable. Different parts of each contribution have very different computational complexities and magnitudes; for example, the subleading-color contributions are more costly by at least an order of magnitude with three or more colored partons, yet give only a small contribution to cross sections. A subdivision according to initial-state parton types is also helpful in this regard. For each part, we adapt the number of phase-space points according to its relative contribution to cross sections. The subdivision also allows us to add more statistics to selected parts without having to perform additional computations for parts whose statistics are adequate. In order to keep the subdivision flexible, and make code using them more robust to future evolution, we simply label the different parts sequentially within each of the four types, for example (R001, R002, R003).

As in an LO calculation, we must save all particle four-momenta in each phase-space configuration in order to be able to recompute (or compute afresh) observables. We must also save the renormalization scale µ R in order to be able to vary it, and the initial-state parton momentum fractions x 1,2 and factorization scale µ F in order to be able to vary the pdfs and thereby estimate pdf uncertainties. We must also save each configuration's integration weight; alongside it, we again save the matrix-element weight as well.

Unlike for an LO calculation, however, these elements do not suffice in order to be able to vary scales or pdfs. They do suffice for the Born and subtracted real-emission contributions, as both the strong coupling and the pdfs appear as simple overall factors in the integrand. However, the virtual contribution contains additional dependence on µ R arising from the oneloop amplitude; and the integrated-subtraction contribution contains both additional dependence on µ R and µ F , and different dependence on pdfs for different parton species. We must save more detailed information for these contributions, as we discuss in greater depth in section 5.

The n-tuple collections we describe are focused on the computation of jet cross sections. The framework we describe is applicable to other infraredsafe observables, but the specific files we have generated and are documenting herein rely on a jet algorithm, and can only be used to compute observables which also are defined using one of a selected set of jet algorithms. Modern jet algorithms are characterized by a clustering (or seedless cone) algorithm; a minimum jet p T ; and a jet size R. The event samples described here allow for any one of the anti-k T [START_REF] Cacciari | The Anti-k(t) jet clustering algorithm[END_REF], k T [START_REF] Catani | Longitudinally invariant K t clustering algorithms for hadron hadron collisions[END_REF], and SISCone [START_REF] Salam | A Practical Seedless Infrared-Safe Cone jet algorithm[END_REF] algorithms, in each case with jet sizes R chosen from the set {0.4, 0.5, 0.6, 0.7}. The SISCone merging fraction parameter is taken to be f = 0.75. We use the FastJet library [START_REF] Cacciari | FastJet User Manual[END_REF] to implement these jet algorithms. The minimum p T is specified in each file, but is typically 20 or 25 GeV. Only observables imposing this cut, or a tighter one, are allowed for use with n-tuple files. (If the minimum p T cut is too tight, the number of events in the sample passing the cut may be too small for adequate statistical accuracy.) These restrictions on jet algorithm and minimum jet p T could of course be relaxed by generating new event samples within our framework.

The main practical tradeoff in this approach is the sizable storage requirement for the n-tuple files. For example, the provided 7 TeV n-tuple files for W + +3 jets all together require 50 GB of storage, while the corresponding files for W + + 4 jets would require 375 GB. Of course, the storage requirements depend greatly on the process and on the desired statistics. The files are quite voluminous, especially at higher multiplicities; the compression offered by Root yields a significant reduction compared to a naive binary format both in disk-space usage and in transmission times.

The n-Tuple Files

As described in the previous section, we save collections of phase-space configurations along with additional information. Each phase-space configuration represents one event at LO. The same is true for three of the four types of contributions at NLO: the Born (B), the virtual (V), and the integrated-subtraction (I) contributions. In the fourth type of contribution, the subtracted real-emission (R) one, each event in general will contain multiple configurations: one corresponding to an emission, with the rest of the configurations corresponding to subtractions; we will call each of the configurations 'entries'. Each Root n-tuple file contains a collection of events. Each (numbered) part within each of the contribution types (B,V,I,R at NLO) may in general be split up into a number of different files for convenience. The event files we describe in this section were produced using BlackHat [START_REF] Berger | An automated implementation of onshell methods for one-loop amplitudes[END_REF] and SHERPA [START_REF] Gleisberg | SHERPA 1.α: A proof of concept version[END_REF][START_REF] Gleisberg | Event generation with SHERPA 1.1[END_REF][START_REF] Krauss | AMEGIC++ 1.0: A matrix element generator in C++[END_REF][START_REF] Gleisberg | Automating dipole subtraction for QCD NLO calculations[END_REF][START_REF] Gleisberg | Comix, a new matrix element generator[END_REF], according to the setups described in refs. [START_REF] Berger | Precise predictions for W + 3jet production at hadron colliders[END_REF][START_REF] Berger | Next-to-leading order QCD predictions for W + 3-jet distributions at hadron colliders[END_REF][START_REF] Berger | Next-to-leading order QCD predictions for Z, γ * + 3-jet distributions at the Tevatron[END_REF][START_REF] Berger | Precise predictions for W + 4jet production at the Large Hadron Collider[END_REF][START_REF] Ita | Precise predictions for Z + 4 jets at hadron colliders[END_REF][START_REF] Bern | Driving missing data at nextto-leading order[END_REF][START_REF] Bern | Four-jet production at the Large Hadron Collider at next-to-leading order in QCD[END_REF]. Each file is a Root file, containing a set of events, along with information about the file content, and sample histograms which can be used to cross-check analyses using the file. (For a review of Root and its file formats, the reader may consult ref. [START_REF] Brun | ROOT: An object-oriented data analysis framework[END_REF].)

Information for the entries in each file is stored in a Root tree called BHSntuples. The branches of this tree are listed in Table 1. We have chosen to restrict the numerical precision for the momenta to single precision in order to limit disk space usage. This means that the weights cannot be recomputed exactly from the momenta for each entry; but there is of course no need to do so. For this reason, because each individual weight is in any case not necessarily accurate even to single precision (see refs. [START_REF] Berger | An automated implementation of onshell methods for one-loop amplitudes[END_REF][START_REF] Berger | Next-to-leading order QCD predictions for W + 3-jet distributions at hadron colliders[END_REF][START_REF] Berger | Next-to-leading order QCD predictions for Z, γ * + 3-jet distributions at the Tevatron[END_REF][START_REF] Berger | Vector Boson + Jets with BlackHat and Sherpa[END_REF][START_REF] Bern | Next-to-Leading Order W + 5-Jet Production at the LHC[END_REF] for examples of numerical uncertainty distributions of matrix elements), and because the weights include phase-space and Jacobian factors arising from SHERPA's integration grids, they are not suitable as reference points for verifying or comparing matrix elements. For such purposes, reference points and matrix-element values quoted in refs. [START_REF] Berger | Next-to-leading order QCD predictions for W + 3-jet distributions at hadron colliders[END_REF][START_REF] Berger | Next-to-leading order QCD predictions for Z, γ * + 3-jet distributions at the Tevatron[END_REF] 1: Branches in a BlackHat+SHERPA Root file. The type of the data entry follows Root's notation. In the second column, "D" stands for "double-precision floating point number", "F" for "single-precision floating point number", "I" for "integer", "S" for "short integer", and "C" for "character array". Square brackets denote an array.

Process

n-tuple file sets References W ± (→ e ± ( ) ν ) + 0, 1, 2 jets B001, I001, R001, V001 [25, 26] W ± (→ e ± ( ) ν ) + 3 jets B001, I001, R001, V001-V002 [25, 26] W -(→ e -ν) + 4 jets B001, I001, R001, V001 [28, 35] W + (→ e + ν) + 4 jets B001, I001, R001-R005, V001 [28, 35] Z(→ e + e -) + 0, 1, 2 jets B001, I001, R001, V001 [27] Z(→ e + e -) + 3 jets B001, I001, R001, V001-V002 [27] Z(→ e + e -) + 4 jets B001, I001-I003, R001-R006, V001-V006 [29] n jets (n = 1, 2, 3, 4) B001, I001, R001, V001 [31]
Table 2: Available processes at NLO, and their decomposition into n-tuple file sets.

Coordinates and units

We take the coordinate axes such that the beams are directed along the z axis, with the initial-state parton with momentum fraction x1 and Particle Data Group (PDG) code id1 moving in the positive z direction. The transverse directions are labeled by x and y, with (x, y, z) forming a right-handed coordinate system. The energies of particles are denoted by E and the spatial momenta by (p x , p y , p z ). We use natural units ( = c = 1) and GeV for energies, masses and momenta. Weights are normalized to yield cross sections in picobarns.

n-Tuple Collections

In this article, we document n-tuple files for the LHC processes listed in Table 2, which we have made available as described in section 3.3. The corresponding references for each class of processes are given in the last column.

As explained in section 2, the events for each process are split up into different types according to the different terms in eq. ( 4). They are further subdivided into different parts, organized in subdirectories, with each part in turn split into multiple files. We must add together contributions from all parts within all types of contributions to obtain the complete NLO cross sections or distributions, as we describe in greater detail in sections 4 and 5. The different parts are independent, analogous to different subprocesses, so their statistical integration errors can be added in quadrature. We show the list of the different parts for each process in Table 2.

The n-tuples were generated using the MSTW2008 [START_REF] Martin | Parton distributions for the LHC[END_REF] NLO parton distribution functions, and a five-flavor running α s (µ) where the value of α s (M Z ) is specified by the parton distribution set. The renormalization and factorization scales are,

µ F,0 = µ R,0 = 1 2 Ĥ′ T ≡ 1 2 j p j T + E V T . (5)
In this equation, originally given in ref. [START_REF] Berger | Precise predictions for W + 4jet production at the Large Hadron Collider[END_REF], the sum runs over all partons in the final state, with p j T the transverse momentum of the jth parton, and

E V
T is the transverse energy of the vector boson,

E V T = m 2 V + (p V T ) 2 . (6)
(For pure-jet processes, the E V T term is of course omitted.) As we explain in more detail in section 5, the n-tuples can be used to generate predictions for other parton distributions, and other choices of renormalization and factorization scales 2 .

The getInfo program (see section 6.4) provides useful information about the process, input parameters, cuts and jet algorithms for a specific n-tuple file.

For processes containing a single electroweak boson, we fold in its decay into a massless lepton pair. We label the pair by e + ν for a W + boson, e -ν for a W -boson, and e + e -for a Z boson. Results for the corresponding muon channels are identical in the massless-lepton approximation. Off-shell effects are taken into account by distributing the lepton-pair invariant mass in a relativistic Breit-Wigner profile with width Γ V around the mass m V of the electroweak vector boson V . In the case of the Z boson (that is, e + e - final states), we include virtual photon γ * exchange as well. For all processes we neglect the contribution of a massive top quark in the quark loops.

W + n-jet processes

For W + n-jet processes, we take the CKM matrix to be diagonal. We provide separate sets of files for W -+ n-jet and W + + n-jet production. The files we provide yield results for the W + 4-jet process in the leading-color approximation for the virtual contributions. The n-tuple collections impose no cuts on the generated momenta of the final-state electron or neutrino, no isolation cuts between the leptons and the jets, and no cuts on the jet rapidities. We impose cuts only on the transverse momenta of the jets,

p jet T > 25 GeV , 7 TeV n-tuples for W + 1, 2, 3, 4 jets , p jet T > 20 GeV , 8 TeV n-tuples for W + 1, 2, 3 jets . ( 7
)
As noted in section 2, the allowed jet algorithms are the anti-k T , k T , and SIS-Cone ones, in each case with jet sizes R chosen from the set {0.4, 0.5, 0.6, 0.7}. In the SISCone case the merging parameter is taken to be f = 0.75.

Z, γ * + n-jet processes

In contrast to the W + n-jet processes, for Z processes we also impose a cut on the invariant mass of the e + e -pair in a window around the Z mass, 60 < M e + e -< 120 GeV, in order to suppress the contribution of the virtual photon. Otherwise, we again impose only a cut on the jet transverse momenta,

p jet T > 25 GeV , 7
The allowed jet algorithms are the same as given above for W + n-jet processes.

The virtual contributions for the Z + 4-jet process are again computed in the leading-color approximation described in ref. [START_REF] Ita | Precise predictions for Z + 4 jets at hadron colliders[END_REF]. Based on studies of lower multiplicities [START_REF] Berger | Next-to-leading order QCD predictions for W + 3-jet distributions at hadron colliders[END_REF][START_REF] Berger | Next-to-leading order QCD predictions for Z, γ * + 3-jet distributions at the Tevatron[END_REF] and also in the case of W + 4-jets [START_REF] Ita | Colour Decompositions of Multi-quark Oneloop QCD Amplitudes[END_REF], we expect these neglected pieces to be on the order of 3% of the total cross section. As in ref. [START_REF] Ita | Precise predictions for Z + 4 jets at hadron colliders[END_REF], we also drop the axial-and vector-coupling loop contributions, along with the effects of top quarks in the loop. We expect these neglected pieces to contribute under 1%. If we neglect the small effect from the muon mass, these n-tuples are just as valid for the Z boson decaying into a pair of muons.

Pure-jet processes

For pure-jet processes, we impose the cut, Table 3: List of the histograms provided to test validate the analysis of an n-tuple file. A non-parton can be an electron, positron, photon, neutrino or anti-neutrino

p jet T > 40 GeV . (9
We treat the five light-flavor quarks as massless, and drop top-quark loops, following ref. [START_REF] Bern | Four-jet production at the Large Hadron Collider at next-to-leading order in QCD[END_REF] (this has a sub-percent effect). We include the full color dependence of all contributions.

Location

An up-to-date list of available processes is maintained at http://blackhat.hepforge.org/trac/wiki/Availability The locations from which the n-tuple files may be obtained are given in http://blackhat.hepforge.org/trac/wiki/Location. They are currently available at CERN on CASTOR and on the LHC Grid. At each location, the files are in base /BHSNtuples/PROCESS/ENERGY/PART where ENERGY is either 7TeV or 8TeV, and PART is one of B, V, I, or R.

Checks

All n-tuple files contain several histograms which can be used to check their consistency and the implementation of the program reading them. The histograms are listed in Table 3.

Each of the histograms listed in Table 3 comes in two copies, one in which the distributions are computed using the original weights, without change of renormalization or factorization scale, and a second in which both µ R and µ F have been changed to H all T , defined to be the scalar sum of the transverse momentum of all particles (including the neutrino) in the event 3 . The histogram names have Orig and HTallp respectively appended to them.

The program getInfo (see section 6.4) can be used to obtain the cuts and jet algorithm used for the histograms.

Using the n-tuple files

One can analyze the entries in the n-tuple files to generate histograms with a wide variety of experimental cuts, so long as all of the following conditions are met:

• One of the jet algorithms used in generating the n-tuple file is applied.

(The list of compatible jet algorithms and parameters are stored in each file but are the same for all files for the same process and center-of-mass energy. See section 6.4 for a description of this information and how to extract it from an n-tuple file.)

• The number of jets passing the algorithm and associated cuts is at least n for an n-jet process.

• All cuts and observables are defined in terms of jets passing the cuts and not in terms of partons. (It is perfectly acceptable, and indeed often desirable, to define the renormalization and/or factorization scales using parton momenta so long as the definition is infrared-and collinear-safe.)

As explained above, each type of contribution ('B', 'R', . . .) to a process is split up into a number of parts (R001, R002, . . .). The number of parts will depend on the process and type of contribution. An analysis should in general sum over all available parts and all types of contributions. (Once one has verified that a given part yields a negligible contribution to the observables of interest compared to the desired accuracy, one may choose to omit it.) The events for each part may be split up into a number of files; each file will contain an independent sample of events. An analysis should sum over as many files as required to obtain the desired statistical accuracy for the given part and type of contribution, but need not sum over all available files. Summing over more files for a given part will increase the statistical accuracy of estimates for that part.

To compute the contribution of a given type t and part p to an observable, one must sum the weight times the observable's value over all entries in all chosen files, and normalize by the total number of entries in these files,

O (t,p) = 1 N t,p Nt,p e=1 w t,p,e O t,p,e , (10)
where N t,p is the total number of entries (across all files) for the given part of the given type, w t,p,e the weight of the entry (given by the weight branch of the Root file), and O t,p,e the value of the observable evaluated on the entry. The value of an observable is then giving by summing over all parts of all types of contributions, O = t∈T,p∈Pt

O (t,p) . ( 11
)
where T is the set of types, and P t the set of parts in type t. As a simple example, if we choose O t,p,e = Θ cuts (where Θ cuts = 1 if the entry is allowed by our chosen jet algorithm and all other applied analysis cuts, and 0 otherwise), we obtain the total cross section. In eq. ( 10), all types of contributions are computed in a similar manner. The weight itself can be recomputed to alter the factorization scale, the renormalization scale, or the pdf, as we shall explain in section 5. The overwhelming fraction of the computation effort in an analysis is in the execution of eq. ( 10). One can combine different batches or sets of files part-by-part by weighting with the total number of entries in each,

O (t,p) 1+2 = 1 N t,p,1+2 N t,p,1 O (t,p) 1 + N t,p, 2 O (t,p) 2 (12)
(where N t,p,1+2 = N t,p,1 + N t,p,2 ), and then re-evaluating eq. [START_REF] Frederix | Four-lepton production at hadron colliders: aMC@NLO predictions with theoretical uncertainties[END_REF]. One would of course typically compute several observables in parallel during a single pass over the selected files.

In order to compute the error estimate for the observable, we must however treat the subtracted real-emission contributions (R) specially. For each part in each of the other types of contributions (B, V, and I), the error estimate is the standard one for Monte-Carlo integration, .

ε (t,p) O = 1 N t,p (N t,p -1)
(13) (We denote the error estimate by ε in order to avoid confusion with the cross section σ.) The R contributions are special, because each event in general contains more than one entry. (In the Root file, all entries within a given event share the same id.) The entries (or phase-space configurations) are of two different kinds, a real-emission configuration and counter-configurations. The latter correspond to the subtraction term that regulates the squared matrix element in the soft and collinear limits, where the unregulated matrix element diverges. The real-emission configurations and subtraction counterconfigurations for a given event are strongly anticorrelated. This means that simply adding the weights independently as in eq. ( 13) will grossly overestimate the statistical error. (The estimated error would typically be of order the central value. Using these weights will, however, yield the correct central value in eq. [START_REF] Gleisberg | Comix, a new matrix element generator[END_REF].) The anticorrelation must be taken into account properly, which we can do using the following formula,

ε (R,p) O = 1 N R,p ( N R,p -1) N R,p e=1
where N R,p is the total number of events (or equivalently, different (filename,ID) pairs with the ID given by the id branch) in the files analyzed for the given part p, in contrast to the total number of entries N R,p ; where N p,e is the number of different entries in the given event, and where w R,p,e,j is the secondary or correlated weight of the entry (given by the weight2 branch of the Root file). For simplicity of use, events are ordered in the n-tuple files, with real-emission entries and counter-entries with the same id appearing contiguously.

If we choose to combine different batches of files using eq. ( 12), we also need the corresponding formula for combining uncertainty estimates,

ε (t,p) O,1+2 = 1 N t,p,1+2 (N t,p,1+2 -1) × N t,p,1 (N t,p,1 -1) ε (t,p) O,1 2 + N t,p,2 (N t,p,2 -1) ε (t,p) O,2 2 1/2 , (15)
for the B, V, and I contributions, and a similar equation with N t,p → N R,p for the R contribution.

The different types of contributions are statistically independent, as they are generated using independent sets of phase-space configurations, and so the overall error estimate simply adds the error estimates for the different parts in quadrature,

ε O = t∈T,p∈Pt ε (t,p) O 2 1/2 . ( 16
)
In addition to overall values of observables, we will typically want to obtain values of distributions as well. To obtain the prediction for the distribution in a variable v, we must divide its range B into bins (possibly including overflow and underflow bins). For each bin, the expected value is given by, dσ dv b = t∈T,p∈Pt dσ dv

(t,p) b , (17)
where dσ dv

(t,p) b = 1 ∆ b 1 N t,p Nt,p e=1 w t,p,e δ(v t,p,e , b) , (18)
where ∆ b is the bin's width (in the units of the observable), and where δ(v, b) is 1 if the value lies in the given bin b, and 0 otherwise. The values of the distribution for different bins can of course be obtained in parallel, by assigning each file entry to the appropriate bin. This formula is what is typically implemented by histogramming codes, which can be used straightforwardly to process the n-tuple files for all the types of contributions.

For the error estimates, we must again treat the subtracted real-emission contribution specially. For each part in each of the other types (B, V, and I), we have a standard form for the error estimate,

ε (t,p) dσ/dv,b = 1 ∆ b 1 N t,
2 1/2 . ( 19
)
This again is the formula that will typically be the one implemented by histogramming routines.

For the R contribution, we must take the anticorrelation into account, so that the error estimate is given by,

ε (R,p) O = 1 ∆ b 1 N R,p ( N R,p -1) N R,p e=1
Np,e j=1 w R,p,e,j δ(v t,p,e,j , b)

2 - 1 N R,p N R,p e=1
Np,e j=1 w R,p,e,j δ(v t,p,e,j , b)

2 1/2 . (20)
A given event is counted as being in a bin if any of its entries are in a bin; a given event can therefore appear in more than one bin. The extent to which this happens, and hence the error estimates, will depend on the value of the integrated subtraction's α dipole parameter [START_REF] Nagy | Next-to-leading order calculation of three jet observables in hadron hadron collision[END_REF], which is 0.03 for all the n-tuple files documented here. This formula is not what is implemented by standard histogramming routines; in particular, current versions of Rivet [START_REF] Buckley | Rivet user manual[END_REF] do not take anticorrelations into account, and so will not compute statistical error estimates correctly for this contribution. The user will typically need to supply his or her own histogramming routines to obtain correct estimates.

Histograms with statistical uncertainty estimates obtained using eq. ( 20) cannot be rebinned in the usual way (that is keeping track of the sum of the weights and the sum of the weights squared for each bin). To understand why, let us consider two neighboring bins b 1 and b 2 and see what happens if we want to compute the error associated with the combined bins which we will refer to as b 1 + b 2 . The second term in the calculation of the error will be the same, whether one considers the bins separately or not. Let us consider the first term, w R,p,e,j δ(v t,p,e,j ,b

1 ) w R,p,e,j ′ δ(v t,p,e,j ′ , b 2 ) ( 21
)
The terms on the penultimate line are typically recorded (as the statistical uncertainty estimate) for each bin alongside the sum of weights. The term on the last line is not. In the absence of correlations between entries in an event -if N p,e = 1 -the double sum over j and j ′ would disappear, and we would recover the usual formula for combining uncertainty estimates of two bins. Because the weights of real-emission and counter-configuration entries in an event are typically anticorrelated, however, the last term typically will be negative and will reduce the uncertainty estimate significantly. Accordingly, naively rebinning histograms with uncertainties computed according to eq. ( 20) but then combined in quadrature will overestimate the statistical uncertainty. The same argument applies to extracting cumulative distributions from a histogram. If the user plans to rebin or extract cumulative distributions, the last term in eq. ( 21) should be recorded for all bin pairs along with the sum of the squared weights.

We again obtain the overall error estimate for each bin by adding the separate contributions in quadrature,

ε dσ/dv,b = t∈T,p∈Pt ε (t,p) dσ/dv,b 2 1/2 . ( 22
)

Changing Scales and Parton Distributions

The BlackHat+SHERPA n-tuple files contain the information needed to recompute the weight of the event for a different renormalization or factorization scale, or for a different pdf set. The new weights can be used to compute new central values, or to compute scale-variation bands and pdfuncertainty estimates. In the following subsections, we explain the additional information stored in the n-tuple files, and how to make use of it. We denote by f 1 and f 2 the pdf of the first and second hadron respectively. For the LHC, in which both beams are protons, they both correspond to proton pdfs. Variables shown in a distinct font correspond to branches in the Root file. Indices in arrays such as usr wgts are zero-based.

Born and subtracted-real contributions

The new weight is given by

n = alphas power , (23)
w = me wgt2 f 1 (id1, x1, µ F ) f 2 (id2, x2, µ F ) α s (µ R ) n (alphas) n , ( 24
)
where µ F is the new factorization scale, µ R the new renormalization scale, f 1,2 the new pdf, α s the corresponding running coupling, and n the power of the strong coupling α s . (In the case of W or Z + n j -jet processes, this power is n j in the Born (B) contribution and n j + 1 in the subtracted-real (R) contribution.) The new scales must be infrared-and collinear-safe functions of the final-state momenta. If the factorization scale and pdf set are left unchanged, one can simplify the computation of w, eliminating the pdf function call:

w = weight2 α s (µ R ) n (alphas) n . ( 25
)
Alternatively, if we leave the renormalization scale unaltered, we could simplify the computation of w to:

w = me wgt2 f 1 (id1, x1, µ F ) f 2 (id2, x2, µ F ) . ( 26
)
For the Born contribution (but not the subtracted-real one), weight and weight2 are the same.

Virtual contribution

The virtual contribution (V) is treated in a similar way as the real and Born contributions, except that the matrix element has an explicit dependence on the renormalization scale. In dimensional regularization, this dependence arises from the introduction of a scale to give the coupling g the required dimension, g → gµ ǫ , along with the MS ultraviolet subtraction that replaces the bare coupling g 0 with the physical coupling g(µ R ),

g n µ ǫ R c Γ Â(1) n -→ g n µ ǫ R c Γ Â(1) n -b 0 (n -2)g n c Γ Â(0) n , ( 27
)
where b 0 = 11/2 -n f /3, c Γ = Γ(1 + ǫ)Γ 2 (1 -ǫ)/ (4π) 2-ǫ Γ(1 -2ǫ)
, and Â(0,1) are respectively the tree-level and one-loop amplitude with factors of g and c Γ removed. This gives rise to a term of the form b 0 α s A (0) ln(µ R /s). Because µ R also enters terms with infrared divergences, there are also double-logarithmic terms in the virtual contribution. In the sum over all contributions, they will cancel statistically against similar terms in the integrated-subtraction term, leaving only double logs of ratios of invariants as well as the linear term in ln µ R . A dependence on ln µ R beyond linear will remain from the running of the strong coupling α s . In calculations using n-tuples, the dependence on µ R,F is taken into account using the additional weights usr wgts. These weights are computed from the coefficients L (1,2) of the 1/ǫ and 1/ǫ 2 poles respectively in the virtual contribution [with the coupling removed],

usr wgts[0] = 1 2π L (1) Φ , usr wgts[1] = 1 2π L (2) Φ , (28)
and saved in the n-tuple file. The coefficient L (1) depends on b 0 . In this equation, Φ is the phase-space measure at the configuration for the event, including Jacobian factors from any remappings used by the phase-space generator. The b 0 terms mentioned above reside within L (1) . An analysis code can then recompute the event weight using the following formulas,

n = alphas power , (29)
l = ln µ 2 R ren scale 2 , (30)
m = me wgt + l usr wgts[0] + l 2 2 usr wgts[1] , (31)
w = m f 1 (id1, x1, µ F )f 2 (id2, x2, µ F ) α s (µ R ) n (alphas) n . (32)
In these equations, ren scale is the reference renormalization scale µ R,0 . If a new pdf set is chosen, the α s should correspond to that set. If we do not change the renormalization scale, the scale-changing logarithm in eq. ( 30) will vanish, and along with it the additional terms in eq. ( 31). (In the case of W or Z + n j -jet processes, n is n j + 1 for this contribution.)

Integrated subtraction contribution

The computation of the new weight for the integrated subtraction contribution (I) is the most complicated. The n-tuple file has 16 additional weights {usr wgts [START_REF] Chatrchyan | Observation of a new boson at a mass of 125 GeV with the CMS experiment at the LHC[END_REF],. . .,usr wgts [START_REF] Catani | A General algorithm for calculating jet cross-sections in NLO QCD[END_REF]} which make a re-computation possible. These weights are computed from the virtual pole coefficients defined in sect. 5.2, along with other quantities extracted from the Catani-Seymour subtraction formalism [START_REF] Catani | A General algorithm for calculating jet cross-sections in NLO QCD[END_REF]. These additional quantities include the coefficients V (1,2) i of the 1/ǫ and 1/ǫ 2 poles respectively in the integrated subtraction functions for parton i, extracted from eqs. (5.32-5.34) of ref. [START_REF] Catani | A General algorithm for calculating jet cross-sections in NLO QCD[END_REF],

V (2) i =    C F , i = q , C A , i = g ; (33) V (1) i =        3 2 C F , i = q , 11 6 C A - n f 3 , i = g , (34)
(C R is the Casimir in representation R of SU(3)); the color-(and helicity-) summed squared tree-level matrix element with factors of the strong coupling removed, |M| 2 ; a logarithm ℓ ik = ln µ 2 F,0 /|2p i • p k |; and the color-correlated squared tree-level matrix element as given [up to a different normalization] in eq. (3.13) of ref. [START_REF] Catani | A General algorithm for calculating jet cross-sections in NLO QCD[END_REF],

M ik = 1, . . . , n| T i • T k T 2 i |1, . . . , n , (35)
where |1, . . . , n is the tree amplitude in the color-helicity basis of ref. [START_REF] Catani | A General algorithm for calculating jet cross-sections in NLO QCD[END_REF] (again, with factors of the strong coupling removed).

We also need the four-dimensional regularized Altarelli-Parisi splitting functions P ab (x), given in eqs. (5.85-5.88) of ref. [START_REF] Catani | A General algorithm for calculating jet cross-sections in NLO QCD[END_REF]; an additional function, related to the splitting functions,

P q,q (x) = 2C F ln 1 1 -x -x - x 2 2 , P g,g (x) = 2C A ln 1 1 -x , P g,q (x) = P q,g (x) = 0 ; (36)
the auxiliary functions K ab (x), defined in eqs. (8.32-8.25) of ref. [START_REF] Catani | A General algorithm for calculating jet cross-sections in NLO QCD[END_REF]; and additional functions,

Kq,q (x) = 2C F Li 2 (x) - 1 2 ln 2 (1 -x) + ln(x) ln(1 -x) -C F 5 -π 2 , Kg,g (x) = 2C A Li 2 (x) - 1 2 ln 2 (1 -x) + ln(x) ln(1 -x) - 50 9 -π 2 C A - 8 9 n f , Kq,g (x) = Kg,q (x) = 0 , (37)
and

P i (x) = γ i 1 -ln(1 -x) , (38)
where

γ i = V (1) i
is the collinear anomalous dimension given in eq. (5.90) of ref. [START_REF] Catani | A General algorithm for calculating jet cross-sections in NLO QCD[END_REF], with V (1) i defined in eq. [START_REF] Bern | Next-to-Leading Order W + 5-Jet Production at the LHC[END_REF].

In terms of these quantities, we have the following expressions for the set of usr wgts,

usr wgts[0] = |M| 2 Φ L (1) + n B b 0 - i =k M ik |M| 2 V (1) i + V (2) i ln µ 2 R,0 |2p i • p k | , usr wgts[1] = |M| 2 Φ L (2) - i =k M ik |M| 2 V (2) i , usr wgts[2] = |M| 2 Φ Kq,a (x) + δ qa i =a M ia |M| 2 P i (x) -P q,a (x)ℓ ia , usr wgts[3] = |M| 2 Φ 1 x ′ K q,a (x ′ ) + i =a M ia |M| 2 δ qa γ i 1 -x ′ + M ai |M| 2 P q,a (x ′ )ℓ ia , usr wgts[4] = |M| 2 Φ Kg,a (x) + δ ga i =a M ia |M| 2 P i (x) -P g,a (x)ℓ ia , usr wgts[5] = |M| 2 Φ 1 x ′ K g,a (x ′ ) + i =a M ia |M| 2 δ ga γ i 1 -x ′ + M ai |M| 2 P g,a (x ′ )ℓ ia , usr wgts[6] = |M| 2 Φ Kq,b (x) + δ qb i =b M ib |M| 2 P i (x) -P q,b (x)ℓ ib , usr wgts[7] = |M| 2 Φ 1 x ′ K q,b (x ′ ) + i =b M ib |M| 2 δ qb γ i 1 -x ′ + M bi |M| 2 P q,b (x ′ )ℓ ib , usr wgts[8] = |M| 2 Φ Kg,b (x) + δ gb i =b M ib |M| 2 P i (x) -P g,b (x)ℓ ib , usr wgts[9] = |M| 2 Φ 1 x ′ K g,b (x ′ ) + i =b M ib |M| 2 δ gb γ i 1 -x ′ + M bi |M| 2 P g,b (x ′ )ℓ ib , usr wgts[10] = |M| 2 Φ P q,a (x) , usr wgts[14] = |M| 2 Φ P q,b (x) , usr wgts[11] = |M| 2 Φ 1 x ′ P q,a (x ′ ) , usr wgts[15] = |M| 2 Φ 1 x ′ P q,b (x ′ ) , usr wgts[12] = |M| 2 Φ P g,a (x) , usr wgts[16] = |M| 2 Φ P g,b (x) , usr wgts[13] = |M| 2 Φ 1 x ′ P g,a (x ′ ) , usr wgts[17] = |M| 2 Φ 1 x ′ P g,b (x ′ ) . (39
) In these expressions, Φ is again the phase-space measure at the configuration for the event, including Jacobian factors from any remappings used by the phase-space generator; n B is the order in α s of the Born process. In these equations, a is the initial-state parton type and flavor in hadron 1, and b is the initial-state type and flavor of the parton from hadron 2. In the weights where a appears (2-5 and 10-13), x is x1 and x ′ is x1p, whereas in the weights where b appears (6-9 and 14-17), x is x2 and x ′ is x2p.

With the additional usr wgts coefficients, an analysis code can use the following formulas to recompute the event weight,

n = alphas power , (40)
l = ln µ 2 R ren scale 2 , (41)
ω 0 = me wgt + l usr wgts[0] + l 2 2 usr wgts[1] , (42)
ω i = usr wgts[i+1] + usr wgts[i+9] ln µ 2 F fac scale 2 , (43)
m = ω 0 f 1 (id1, x1, µ F ) f 2 (id2, x2, µ F ) + 4 j=1 f (j) 1 (id1, x1, x1p, µ F ) ω j f 2 (id2, x2, µ F ) (44) +f 1 (id1, x1, µ F ) 4 j=1 f (j) 2 (id2, x2, x2p, µ F ) ω j+4 , w = m α s (µ R ) n (alphas) n , (45)
where (r = 1 or 2)

f (1) r (i, x, x ′ , µ F ) = i = quark: f r (i, x, µ F ) , i = gluon : quarks q f r (q, x, µ F ) , (46)
f (2) r (i, x, x ′ , µ F ) = i = quark: f r (i, x/x ′ , µ F )/x ′ , i = gluon : quarks q f r (q, x/x ′ , µ F )/x ′ , (47)
f (3) r (i, x, x ′ , µ F ) = f r (g, x, µ F ) , (48) f (4) r (i, x, x ′ , µ F ) = f r (g, x/x ′ , µ F )/x ′ . ( 49
)
The sums over quarks are taken over the quark flavors active at the scale µ F , typically five. In these equations, ren scale is the reference renormalization scale µ R,0 , and fac scale is the reference factorization scale µ F,0 . (In the case of W or Z + n j -jet processes, n is n j + 1 for this contribution.)

Library for Reading BHS n-Tuple Files

This section describes a C ++ library, nTupleReader, which provides an easy-to-use interface to the n-tuple files described in the above sections.

Dependencies

The library depends on lhapdf [START_REF] Whalley | The Les Houches Accord PDFs (LHAPDF) and Lhaglue[END_REF] (http://lhapdf.hepforge.org/) and Root [START_REF] Brun | ROOT: An object-oriented data analysis framework[END_REF] (http://root.cern.ch/drupal/).

Installation

The library is an autotools package, and is installed using the usual paradigm of configure; make; make install. Along with the usual autotools options, the library's configure script offers the following options: To install in a different location than the standard one, use the --prefix option to the configure script.

Usage

Your source code must include the header file nTupleReader.h to use the library. Your code may access information in the n-tuple files via an object of the nTupleReader class. We give an example of a C ++ program using the library in section 6.8.

The nTupleReader-config script returns the compiler and linker flags needed to compile a user program and link it to the library. The script is located in the bin subdirectory of the installation directory. Assuming this script is in your executable search path, you would compile and link a program as follows, CFLAGS='nTupleReader-config --include' g++ -c $CFLAGS -o NTRexample.o NTRexample.cpp LDFLAGS='nTupleReader-config --libs' g++ $LDFLAGS -o NTRexample NTRexample.o

The getInfo program

The make step creates a program called getInfo along with the library. This program takes one argument, the name of a n-tuple file. The program prints useful information about events in the file:

• their center-of-mass energy;

• their initial-state hadrons;

• the process that generated them;

• the part of the NLO calculation to which they contribute;

• the jet algorithms and parameters allowed in an analysis;

• the minimum jet transverse-momentum cut allowed;

• additional generation-level cuts, such as the lepton invariant-mass cut for processes with a Z boson.;

• the electroweak parameters used;

• the pdf set used in the n-tuple generation.

Member functions of an nTupleReader object

This section describes the member functions of the nTupleReader class, which allow access to the data in n-tuple files. We give an example of their use in section 6.8.

The member functions are, void addFile(const std::string &fileName) Adds a file to the reader. fileName is the name of the file.

void addFiles(std::vector<std::string> fileNames) Adds a list of files to the reader fileNames is a vector of std::string containing the names of the files to be added, which will be read in the order given.

double computeWeight(double newFactorizationScale, double newRenormalizationScale) Returns the weight (weight) of the current entry recomputed for the new scales, using the current pdf member number in the current pdf set.

newFactorizationScale is the new factorization scale (in GeV) newRenormalizationScale is the new renormalization scale (in GeV) double computeWeight2(double newFactorizationScale, double newRenormalizationScale) Returns the secondary weight (weight2) of the current entry recomputed for the new scales, using the current pdf member number in the current pdf set. One should use this weight for the real part in order to take into account the correlation between the entry and counter entries.

newFactorizationScale is the new factorization scale (in GeV) newRenormalizationScale is the new renormalization scale (in GeV) short getAlphasPower() Returns the power of the strong coupling constant in the current entry.

long getEndEntryIndex() Returns the (1-based) index of the entry at which reading will stop.

double getEnergy(int i) Returns the energy of the i th particle in the current entry.

i is a 0-based index; an argument equal to or larger than the number of final state particles will throw an nTR OutOfBounds exception.

void getEntry(long index)

Reads the entry corresponding to the index specified; nextEntry() will start from that position. index is the index of the entry to be read. double getMEWeight2() Returns the secondary weight for the current entry omitting the pdf factors, to be used as described in section 4 to obtain the correct estimate of the statistical uncertainty.

long getMaxEvent() Returns the ID of the event (phase-space configuration-counter-configuration group of entries, or simply entries for contribution types with one entry per event) after which reading will stop.

long getNumberOfEntries() Returns the total number of entries.

int getPDGcode(int i) Returns the PDG code of the i th particle in the current entry.

i is a 0-based index; an argument equal to or larger than the number of final state particles will throw an nTR OutOfBound exception.

int getParticleNumber()

Returns the number of final state particles in the current entry.

double getRenormalizationScale() Returns the renormalization scale used to compute the weights for the current entry.

long getStartEntryIndex() Returns the (1-based) index of the entry at which reading will start.

char getType() Returns the type of the current entry, 'B' standing for born, 'I' for integrated subtraction, 'V' for the virtual, and 'R' for the subtracted real emission.

double getWeight() Returns the weight (weight) for the current entry.

double getWeight2() Returns the secondary weight (weight2) for the current entry, to be used as described in section 4 to obtain the correct estimate of the statistical uncertainty.

double getX(int i) Returns the x component of the i th particle's momentum in the current entry.

i is a 0-based index; an argument equal to or larger than the number of final state particles will throw an nTR OutOfBound exception.

double getX1()

Returns the momentum fraction x 1 in the current entry.

double getX2() Returns the momentum fraction x 2 in the current entry.

double getY(int i) Returns the y component of the i th particle's momentum in the current entry.

i is a 0-based index; an argument equal to or larger than the number of final state particles will throw an nTR OutOfBound exception.

double getZ(int i)

Returns the z component of the i th particle's momentum in the current entry.

i is a 0-based index; an argument equal to or larger than the number of final state particles will throw an nTR OutOfBound exception.

bool nextEntry()

Reads the next entry and returns true upon success, false otherwise (including when the end of the file is reached).

void setEndEntryIndex(long index) Sets the index of the entry at which reading will stop. index 1-based index at which the reading will stop (the index-th entry will not be read) void setMaxEvent(long count)

Sets the reader to stop reading entries when the given number of events (phase-space configuration-counter-configuration groups of entries, or simply entries for contribution types with one entry per event) have been read. count is a 1-based sequence number specifying the first event that will not be read. void setPDF(const std::string &name)

Sets the pdf set to be used. name is the name of the file to be loaded by LHAPDF, for example CT10.LHgrid. void setPDFmember(int member)

Sets the pdf member number to be used.

member is an integer labeling the member; 0 is typically used to denote the central value.

void setPP()

Sets the initial state to proton-proton. This is the default if no calls to setPP() or setPPbar() are issued. This routine should only be invoked before using files generated for proton-proton colliders.

void setPPbar() Sets the initial state to proton-antiproton. This routine should only be invoked before using files generated for proton-antiproton colliders.

void setStartEntryIndex(long index) Sets the index of the entry at which reading will start. index 1-based index at which the reading will start (the index-th entry will be read at the next call of nextEntry()) void setStartEvent(long count)

Sets the number for the event sequence counter at which the library will start reading in events (phase-space configuration-counter-configuration groups of entries, or simply entries for contribution types with one entry per event). count is a 1-based sequence number specifying the first event that will be read.

Histogram Implementation Example

This section gives an example of the implementation of a histogramming procedure, as described in section 4. nTupleReader r; . . . bool notFinished=r.nextEntry(); int lastID=r.getID(); while(notFinished){ double wgt; // compute the value of the weight wgt here... int ID=r.getID() r.getZ(i) )

Example of the usage of the library in a C++ program

The following listing shows an example of a C ++ program using the nTupleReader library. This example is included after installation in the directory share/ntuplereader/.

#include "nTupleReader.h" using namespace std; int main(){ std::vector<std::string> fs; fs.push_back("@prefix@/share/ntuplereader/sample.root"); nTupleReader r; r.setPDF("cteq6ll.LHpdf"); r.addFiles(fs); while(r.nextEntry()){ int id=r.getID(); cout << "Checking momentum conservation for event ID: " << id << std::endl; double sumX=0; double sumY=0; double sumZ=0; int nbrP=r.getParticleNumber(); std::cout << "Number of particles: " << nbrP << std::endl; for (int i=0;i<nbrP;i++){ sumX+=r.getX(i);

sumY+=r.getY(i); sumZ+=r.getZ(i); } std::cout << "Sum X: " << sumX << std::endl; std::cout << "Sum Y: " << sumY << std::endl; std::cout << "Sum Z: " << sumZ << " to be compared with: " << 3500 * (r.getX1()-r.getX2()) << std::endl; } return 0; }

Conclusions

In this Article we described software tools for obtaining predictions to NLO in QCD using an n-tuple event-file format generated by SHERPA using the BlackHat software library. This framework offers a convenient means for evaluating cross-sections and distributions with different parton distribution functions, bypassing repeated and computationally costly evaluations of matrix elements. The set-up described here makes it straightforward to compute scale-variation bands and to obtain uncertainty estimates due to imprecise knowledge of the parton distribution functions. The n-tuple files also make it convenient to study the effects of varying jet algorithms and cuts, within a wide range of commonly-used ones. These tools have already proved useful in a number of theoretical [START_REF] Bern | Four-jet production at the Large Hadron Collider at next-to-leading order in QCD[END_REF][START_REF] Bern | Missing Energy and Jets for Supersymmetry Searches[END_REF][START_REF] Bern | Next-to-Leading Order W + 5-Jet Production at the LHC[END_REF] and experimental studies [START_REF] Aad | Measurement of the production cross section for Z/γ * in association with jets in pp collisions at √ s = 7 TeV with the ATLAS detector[END_REF][START_REF] Aad | Study of jets produced in association with a W boson in pp collisions at √ s = 7 TeV with the ATLAS detector[END_REF]. The reader may find an up-to-date list of available n-tuple sets at http://blackhat.hepforge.org/trac/wiki/Availability, stored at locations given in http://blackhat.hepforge.org/trac/wiki/Location. We look forward to further theoretical and experimental studies using the tools described here.

We display the √ s = 8 TeV cross sections for W + n jet production in Table A.4. We define jets using the anti-k T algorithm [START_REF] Cacciari | The Anti-k(t) jet clustering algorithm[END_REF] with parameter R = 0.5. We apply the following cuts, where Ĥ′ T is defined in eq. ( 5). The LO cross sections are computed using MSTW2008 [START_REF] Martin | Parton distributions for the LHC[END_REF] LO pdfs, and the NLO cross sections using the MSTW2008 NLO pdfs. In each case, we use the α s (µ) corresponding to the parton distribution set. The corresponding 7 TeV cross sections are given in table I of ref. [START_REF] Bern | Next-to-Leading Order W + 5-Jet Production at the LHC[END_REF]. where η is the pseudorapidity and M e + e -is the invariant mass of the e + e - decay pair. The invariant-mass cut is tighter than that used in generating the n-tuples, and other cuts are added in this calculation, illustrating precisely

  TeV n-tuples for Z, γ * + 1, 2 jets , p jet T > 20 GeV , 7 TeV n-tuples for Z, γ * + 3, 4 jets , p jet T > 20 GeV , 8 TeV n-tuples for Z, γ * + 1, 2, 3 jets .

) xsection total cross section 1

 1 bin of width 1 h pt jN transverse momentum of jet N 50 bins: [0, 1000] h eta jN pseudo-rapidity of jet N 22 bins: [-4.4, 4.4] h pt NP trans. momentum of the non-parton NP 200 bins [0, 2000]

  p,e,j O R,p,e,j 2 1/2 ,

2 = 2 = 2 + 2 +2

 2222 p,e,j δ(v t,p,e,j , b 1 + b 2 ) p,e,j δ(v t,p,e,j , b 1 ) + δ(v t,p,e,j , b 2 ) p,e,j δ(v t,p,e,j , b 1 )Np,e j=1 w R,p,e,j δ(v t,p,e,j , b 2 )Np,e j,j ′ =1;j =j ′

  double getFactorizationScale()Returns the factorization scale used to compute the weights for the current entry.int getID() Returns the ID of the current event.double getId1() Returns the PDG code for the first (forward) incoming parton in the current entry.double getId2()Returns the PDG code for the second (backward) incoming parton in the current entry.long getIndexOfNextEntry() Returns the index of the next entry.double getMEWeight() Returns the weight for the current entry omitting pdf factors.

  E eT > 20 GeV ,|η e | < 2.5 , / E T > 20 GeV , p jet T > 25 GeV , |η jet | < 3 , M W T > 20 GeV . (A.1)The transverse mass of the W -boson is computed from the kinematics of its decay products, W → eν e : M W T = 2E e T E ν T (1 -cos(∆φ eν )). In this case, the factorization and renormalization scales are set to, µ R,0 = µ F,0 = 1 2Ĥ′T , (A.2)

Appendix A. 2 .

 2 Inclusive Z, γ * + n-jet Production (0.02) 26.50(0.06) Z + 3 7.452(0.009) 6.58(0.09) TableA.5: Total cross sections in pb for Z, γ * + n jet production at the LHC at √ s = 8 TeV, using the anti-k T jet algorithm with R = 0.5 and the cuts given in eq. (A.3).For the 8 TeV cross sections listed in TableA.5, we choose the anti-k T algorithm with R = 0.5 and impose the following set of cuts,E e T >20GeV , |η e | < 2.5 , 66 GeV < M e + e -< 116 GeV , p jet T > 25 GeV , |η jet | < 3 , (A.3)

  should be used.

	Branch name	Type	Notes
	id	I	ID of the event. Real-emission entries and their
			associated counterterms share the same ID.
	nparticle	I	number of particles in the final state
	px, py, pz F[nparticle] array of p x , p y , p z respectively, for final-state
			particles
	E	F[nparticle] array of energies E for final-state particles
	kf	I[nparticle] PDG codes of the final-state particles
	weight	D	total weight of the entry
	weight2	D	secondary or correlated weight used to compute
	me wgt2	D	coefficient of the product of parton-distribution
			functions in weight2
	x1, x2	D	fraction of hadron momentum carried by the
			first and second incoming partons, respectively
	x1p,x2p	D	secondary momentum fractions x ′ 1,2 used in in-
			tegrated subtraction entries [9]
	id1, id2	I	PDG codes of the first and second incoming
			partons respectively
	fac scale	D	factorization scale used (µ F,0 )
	ren scale	D	renormalization scale used (µ R,0 )
	nuwgt	I	number of additional weights
	usr wgts	D[nuwgt] additional weights needed to recompute the en-
			try's weight for a different scale or pdf choices
	part	C	type of contribution: B, V, I, or R
	alphas power	S	power of the coupling
	alphas	D	α s value used for this entry
	Table

the subtracted real-emission's statistical errors. Identical to weight for the B, V, and I contributions; the normalization differs for the R contribution me wgt D coefficient of the product of parton-distribution functions in weight. For the B, V, and R contributions, this is the squared matrix element multiplied by the phase-space measure and the Jacobian from SHERPA's phase-space mapping

  p (N t,p -1)

	Nt,p
	w 2 t,p,e δ(v t,p,e , b)
	e=1 N t,p -1	Nt,p

e=1 w t,p,e δ(v t,p,e , b)

  --with-lhapdf-path= path to lhapdf installation Sets the location of the lhapdf installation; this option is needed only if the helper program lhapdf-config is not in the executable search path. --with-root-path= path to Root installation

	Sets the location of the root installation;
	this option is needed only if the helper program
	root-config is not in the executable search path.
	--enable-pythoninterface
	Compiles the python interface (see section 6.7).
	To install the library, unpack the .tar.gz file,
	tar -xzf ntuplereader-version .tar.gz
	where version is a string like '1.0'. Configure, with options as needed,
	cd ntuplereader-version
	./configure options
	and then compile and install,
	make
	make install

We use this term in the sense used by experimenters when analyzing data.

Cross sections and distributions computed using the n-tuples documented here may not match the results quoted in the references in the last column of Table2exactly, because the earlier results used six-flavor running (above the top-quark mass) and a different definition of the leading-color approximation.

This scale is not appropriate for observables sensitive to the polarization of the vector boson, as explained in ref.[START_REF] Bern | Left-Handed W Bosons at the LHC[END_REF].

Acknowledgments

We thank Tanju Gleisberg for his collaboration in the initial stages of the development described above; he contributed in an important way to the tools described here. We are also grateful to Kemal Ozeren for his collaboration and input, and we thank Joey Huston for his continual encouragement. We also thank David Saltzberg, and Eric Takasugi for discussions and feedback. This research was supported by the US Department of Energy under contracts DE-AC02-76SF00515 and DE-FG02-13ER42022. DAKs research is supported by the European Research Council under Advanced Investigator Grant ERC-AdG-228301. DM's work was supported by the Research Executive Agency (REA) of the European Union under the Grant Agreement number PITN-GA-2010-264564 (LHCPhenoNet). SH's work was partly supported by a grant from the US LHC Theory Initiative through NSF contract PHY-0705682. This research used resources of Academic Technology Services at UCLA, and of the National Energy Research Scientific Computing Center, which is supported by the Office of Science of the U.S. Department of Energy under Contract No. DE-AC02-05CH11231.

where NbrBins is the numbers of bins in the histograms.

Example of the usage of the python interface

To use the python interface, make sure that the installation path for the libraries installed with the C ++ library is included in the locations searched for python modules. The following is a sample python program, import nTupleReader as NR r=NR.nTupleReader() r.addFile('@prefix@/share/ntuplereader/sample.root') r.nextEntry() for i in range(r.getParticleNumber()):

print "p(%d)=(%f,%f,%f,%f)" % ( i, r.getEnergy(i), r.getX(i), r.getY(i),

Appendix A. Tables of Cross Section Values

In this appendix we provide tables of cross sections obtained using the √ s = 8 TeV n-tuples currently available on CASTOR and on the LHC Grid.

These can serve as a reference for comparison purposes, and as a cross check that the sum over different contributions has been carried out correctly in user code. We list cross sections for a specific set of cuts identical to the ones used at 7 TeV in refs. [START_REF] Berger | Precise predictions for W + 4jet production at the Large Hadron Collider[END_REF][START_REF] Ita | Precise predictions for Z + 4 jets at hadron colliders[END_REF][START_REF] Bern | Four-jet production at the Large Hadron Collider at next-to-leading order in QCD[END_REF]. (Sample distributions listed in Table 3 are included with each n-tuple file.) where Ĥ′ T is defined in eq. ( 5). The MSTW2008 parton distribution functions are used. Cross sections at 7 TeV are given in ref. [START_REF] Ita | Precise predictions for Z + 4 jets at hadron colliders[END_REF].

Appendix A. [START_REF] Bern | The NLO multileg working group: Summary report[END_REF] 14.36(0.01) 8.12(0.17)

Table A.6: Total cross sections in nb for pure jet production at the LHC at √ s = 8 TeV, using the anti-k T jet algorithm with R = 0.4 and the cuts given in eq. (A.5).

The cross sections for 2, 3, 4-jet production at √ s = 8 TeV are given in Table A. [START_REF] Gleisberg | SHERPA 1.α: A proof of concept version[END_REF]. In this case we use the anti-k T jet algorithm with R = 0.4 with the same cuts as in ref. [START_REF] Bern | Four-jet production at the Large Hadron Collider at next-to-leading order in QCD[END_REF]: where the sum runs over all final-state partons j. Again we use the MSTW2008 parton distribution functions. The 7 TeV cross sections are given in table I of ref. [START_REF] Bern | Four-jet production at the Large Hadron Collider at next-to-leading order in QCD[END_REF].


L Mokhtari
email: lounes.mokhtari@g2elab.grenoble-inp.fr

B Delinchant

J-L Coulomb

T Le Duc

O Chadebec

J-M Guichon

G Meunier

SOFTWARE METHODOLOGY 1 Software Coupling and Orchestration Tool to the Modeling of Multi-physic Problems

Keywords: Software component, weak coupling, PEEC and MoM method

We present in this paper Scot, which is a modular solution for weakly coupling models, methods and orchestration of the simulation. The goal behind this modular approach is to make easier the phase of modeling and to optimize the phase of simulation by tuning the solvers. Specifications and composition of Scot are exposed. To illustrate it, we have chosen the coupling of PEEC and MoM method to the modeling of an electromagnetic device.

I. INTRODUCTION

The problem in the multi-physics modeling is that researchers attempt to model all the different parts of the system that don't appear from their research field, so the models they develop are often of poor quality and may contain many errors of modeling.

In this context, it appears interesting to improve the modeling of each physic by scientists in the same field of research, or to use specialized software to carry out the different models and then link them to rebuild the overall representation [START_REF] Mokhtari | Comparing Weak and Strong PEEC-MoM Coupling[END_REF].

Scot (Software Coupling and Orchestration Tool) is a software tool with a modular architecture developed for the purpose of coupling weakly models, methods and specialized software. It includes some interfaces and makes easy to develop others as required. Models written in any language and embedded in Java, can be linked to Scot.

The test application concerns the modeling of a real electromagnetic device by coupling the PEEC (Partial Elements Equivalent Circuit method) and MoM (Method of Moments) method for respectively each of the electric and magnetic part.

II. SPECIFICATIONS OF SCOT

Coupling strategies are described in two ways in Scot; in the first, the models are implemented directly in Scot and both of the control and the simulation is done on Scot, however, in the second, there are two layers as shown in (Fig 1). The layer of supervision from where we configure and control the coupling and, the layer of simulation where the models exchange the unknowns variables.

When the desired convergence is reached, the layer of supervision calls the layer of simulation to get the results for post processing.

Socket

Model

Configuratio Control

Input Output

Simulation layer

Supervision layer

Fig. 1. General Scot Coupling scheme of two models using coupling terms.

A. Composition of Scot 1) variables: State variables, are tokens consumed or produced by an ScotComponent or ScotTransformer, characterized by its type (integer, real, boolean. . . ), size, and value. Among Scot variables, there are also variables of configuration and control.

2) ScotComponent: Scot has two types of components. In the first one, the models are directly implemented on Scot, it contains specific solvers which will be tuned by the ScotCoupler regarding the ScotCouplingAlgo. The second one is an interface that allows controlling the external models simulation (Fig 2 3) ScotTransformer: the models are not necessarily designed to be coupled thus state variables produced by one model can not be consumed by another. In this case, it is necessary to use coupling terms "ScotTransformer". These ScotTransformers may also be transition matrices to reduce the ordre of the state variables or, software that performs interpolation between different scale meshes such such as OASIS [2], MpCci [3].

4) ScotCoupler:

At this level, we can specify the ScotComponents, ScotTransformers to build the different parts of the system and their coupling strategy (ScotCouplingAlgo).

III. COUPLING OF SCOT AND MATLAB

A Socket based communication is developed to couple and adapt the Matlab models to the ScotComponent (Fig 2), it contains 2 java classes and a ".dll" library. This ScotComponent Matlab caller implements 3 methods :

1) Initialization of the the Matlab models (build the models according to the model parameters). 2) resolution of the models and getting the residuals to test the convergence of the coupling. 3) getResults to recover the final results when the convergence criteria is achieved.

This Scot-Matlab interface has been used in the following test application.

IV. APPLICATION

We have chosen as an application the modeling of a microinductance [START_REF] Le Duc | Delinchant Numerical experimentations on the coupling between PEEC and volume integral method[END_REF] The numerical model of the micro-inductance is given by the system of equations below [START_REF] Mokhtari | Comparing Weak and Strong PEEC-MoM Coupling[END_REF].

[M M ] • [M] + [BS m ] • [I] = [0] [Z m ] • [I] + [LF m ] • [M] = [V ] , (1)
where, The model of the micro-inductance has been validated with the finite element approach in [START_REF] Le Duc | Delinchant Numerical experimentations on the coupling between PEEC and volume integral method[END_REF]. For the same results of magnetizations and electric current in the inductance, we have compared the time resolution of strong and tuned weak coupling regarding the number of unknowns (Fig 4). The concept of layers introduced in Scot minimises a lot exchanging data with the supervisor which vacates space memory and requests much less the processor. The architecture based software components of Scot promotes the reusing of models libraries and provides the modeling of multi-physic systems.

In the case application, we have used a static ScotComponent, our future research concerns the specification of dynamic ScotComponents to the co-simulation of temporal models with variable subcycling step time to accelerate and optimize these type of couplings.

Fig. 3 .

 3 Fig. 3. Micro-inductance, composed by two magnetic regions (µr = 1000) and an electric inductance powered by a source voltage (V = 1volt, f = 1kHz).

[

  M M ] Magnetostatic matrix, obtained with LOCAPI [5] [BS m ] Impact of the electric on magnetic, coupling term, [Z m ] Impedance matrix, obtained with INCA3D [6] [LF m ] Impact of the magnetic on electric, coupling term. The resolution of the system (1) gives us the vector of material magnetizations [M] and the electric current in the inductance [I], according to the sources vector [V ].

Fig. 4 .

 4 Fig. 4. Curves of the time resolution regarding the number of unknowns.

  ).

	Supervision layer	----	Inputs Coupling strategy Configuration Control		Scot	-Visualization -Post-processing -Residuals -Convergence + Results
	Simulation layer		CT 1 Exchange data according to ScotCouplingAlgo CT 2 Model 1 Model 2
	Configuration 1 2 2. Simulation configuration 1. Model parameters	3	Control 4 5
	3. Initialization
	4. Resolution, get Residuals 5. get Results			Send to a component
	Input		Socket			Output
	Received from a
	component		Model
						Residuals, Results

Fig. 2. Representation of Scot Coupling component, its parameters and interactions with Scot and other components.