Search NASA⌕ Search

SEARCH · Search NASA

Results for “C++ (programming language)”

Search indexed NASA NTRS and DOE OSTI research on propulsion, heat transfer, battery materials and energy systems. Follow report and document links to the original sources.

Quote a phrase for an exact phrase match. Source license links do not imply unrestricted reuse.

At least 19 records

Modbus RTU for Embedded Cyber Secure Inverter Controller

The Modbus communication protocol is a widely adopted communication standard in industrial control systems. This communication protocol is known for being reliable and straightforward to implement while being versatile in terms of its operating parameters while supporting multiple formats over various hardware infrastructures and architectures. Many intelligent devices such as Programmable Logic Controllers (PLCs), Human-Machine Interfaces (HMIs), Internet-of-Things (IoT), and various Operational Technologies (OT) utilize Modbus for their communication systems. These types of systems must communicate with each other through a standardized and central communication process. To support the integration of these modular systems, a Field-Programmable Gate Array (FPGA) can act as an embedded central routing fabric for this communication to take place. Embedded systems are versatile enough to interface with various devices and systems to accomplish various goals. Additionally, embedded systems require relatively small physical designs to minimize the required resources to facilitate the intended application by providing low-level system access. This minimization of system resources goes hand in hand with reducing the financial cost of a proposed solution or system. As remotely collaborating researchers often use FPGAs to prototype designs that are required to have a method for data transmission among systems, it is imperative to provide a baseline standard for communications among devices and systems. A typical method of implementing the Modbus RTU communication protocol in an embedded environment is using integrated logic architectures within the FPGA called “Intellectual Property (IP) cores.” IP cores can be designed using integrated logic or circuit designs to function as an embedded processor. These IP cores can then perform the required computational actions to support the Modbus RTU communication protocol by utilizing high-level programming languages such as the C programming language. The hardware description language of Very High-Speed Integrated Circuit Hardware Description Language (VHDL) allows for the control of real hardware at the logic gate and signal level. These logic gates and signals can be designed and controlled to perform desired actions based on the system design. Programming an FPGA using VHDL allows an individual to access the lowest abstraction level of the system during FPGA development. This level of abstraction is referred to as the register-transfer level (RTL), which gives access to manipulating values and variables at the register level. This register-level manipulation provides precision over creating the logical circuit within the FPGA, thus minimizing the required code to perform desired operations. The Modbus RTU communication protocol can be implemented within an FPGA using VHDL programming to establish a standardized and embedded serial communication pathway. This implementation provides a standardized communication protocol to streamline research efforts among researchers, thus increasing the efficiency of research efforts. Additionally, this Modbus RTU implementation requires fewer resources when compared to typical communication protocol implementations that utilize an IP core, reducing the hardware requirement for effective research efforts.

communication↗

TU-C-17A-03: An Integrated Contour Evaluation Software Tool Using Supervised Pattern Recognition for Radiotherapy

Purpose: Radiotherapy (RT) contours delineated either manually or semiautomatically require verification before clinical usage. Manual evaluation is very time consuming. A new integrated software tool using supervised pattern contour recognition was thus developed to facilitate this process. Methods: The contouring tool was developed using an object-oriented programming language C# and application programming interfaces, e.g. visualization toolkit (VTK). The C# language served as the tool design basis. The Accord.Net scientific computing libraries were utilized for the required statistical data processing and pattern recognition, while the VTK was used to build and render 3-D mesh models from critical RT structures in real-time and 360° visualization. Principal component analysis (PCA) was used for system self-updating geometry variations of normal structures based on physician-approved RT contours as a training dataset. The inhouse design of supervised PCA-based contour recognition method was used for automatically evaluating contour normality/abnormality. The function for reporting the contour evaluation results was implemented by using C# and Windows Form Designer. Results: The software input was RT simulation images and RT structures from commercial clinical treatment planning systems. Several abilities were demonstrated: automatic assessment of RT contours, file loading/saving of various modality medical images and RT contours, and generation/visualization of 3-D images and anatomical models. Moreover, it supported the 360° rendering of the RT structures in a multi-slice view, which allows physicians to visually check and edit abnormally contoured structures. Conclusion: This new software integrates the supervised learning framework with image processing and graphical visualization modules for RT contour verification. This tool has great potential for facilitating treatment planning with the assistance of an automatic contour evaluation module in avoiding unnecessary manual verification for physicians/dosimetrists. In addition, its nature as a compact and stand-alone tool allows for future extensibility to include additional functions for physicians’ clinical needs.

62 RADIOLOGY AND NUCLEAR MEDICINE↗

Improving robustness and computational efficiency using modern C++

For nearly two decades, the C++ programming language has been the dominant programming language for experimental HEP. The publication of ISO/IEC 14882:2011, the current version of the international standard for the C++ programming language, makes available a variety of language and library facilities for improving the robustness, expressiveness, and computational efficiency of C++ code. However, much of the C++ written by the experimental HEP community does not take advantage of the features of the language to obtain these benefits, either due to lack of familiarity with these features or concern that these features must somehow be computationally inefficient. In this paper, we address some of the features of modern C+-+, and show how they can be used to make programs that are both robust and computationally efficient. We compare and contrast simple yet realistic examples of some common implementation patterns in C, currently-typical C++, and modern C++, and show (when necessary, down to the level of generated assembly language code) the quality of the executable code produced by recent C++ compilers, with the aim of allowing the HEP community to make informed decisions on the costs and benefits of the use of modern C++.

Paterno, M.↗

Long Reach Robotic Arm

The Accelerator Division at Fermilab began a robotics program, known as the AD Robotics Initiative. A multi-axis robotic arm was proposed to be included in the program. This summer internship, our team began the planning and design for this project, called the Long Reach Robotic Arm. The problem is that critical systems around the magnets require analysis when water leaks cause them to fail. However, the tightly compacted parts and the quadrupole magnet, weighing approximately 1,000 pounds, cause access viewing problems. The process of having to dismantle and remove the magnet is time-consuming; it is not an efficient solution. The goal for the Long Reach Robotic Arm was to extend and reach behind the component of the Main Injector while "snaking" around and avoiding obstructions. At the start of the project, my teammate, Amanda Hoeksema, and I coded a program in the C language that will determine the number of links and their respective lengths for the robot arm. After, we began the 3D CAD model of the robot arm, base, and counterweight system. The design of the Long Reach Robotic Arm provided a learning experience in learning how to code in the C programming language, using SDL libraries and understanding mechanical engineering.

43 PARTICLE ACCELERATORS↗

ISO_Fortran_binding_m v0.1.0

The Fortran programming language standard defines a broad feature set supporting the interoperability of Fortran programs with program written according to the C programming language standard. Among Fortran's C-interoperability features is a a C header file "ISO_Fortran_binding.h" This header file defines the interface to various C data structures and functions that C programs may use to access Fortran data entities. The ISO_Fortran_binding_m software defines a native Fortran module that presents an interface to these same data structures and functions. ISO_Fortran_bind_m thus enables Fortran programs to access and manipulate Fortran entities in ways that precisely mirror what C programs can do using ISO_Fortran_binding.h. ISO_Fortran_binding_m facilitates writing portable standard-conforming Fortran programs that emulate non-interoperable features, e.g., dynamic polymorphism, in a standard-conforming interoperable way similar but broader than what is demonstrated in Berkeley Lab's Caffeine software [1]. ISO_Fortran_binding_m also enables a Fortran programmer to extend Fortran's capabilities to emulate certain C functionality such as memory address arithmetic or computing C's "sizeof" function. [1] https://github.com/BerkeleyLab/caffeine/blob/213e3df1c319f0663306354414f352acda42a24f/src/caffeine/collective_subroutines/co_reduce_s.f90#L88 [2] https://github.com/BerkeleyLab/ISO_Fortran_binding_m/blob/0c585362bb4f2c72cf9049c800a7115b529ec533/src/iso_fortran_binding_m.F90#L196

Rouson, Damian↗

Implementation of McMurchie–Davidson Algorithm for Gaussian AO Integrals Suited for SIMD Processors

We report an implementation of the McMurchie− Davidson evaluation scheme for 1- and 2-particle Gaussian AO integrals designed for processors with Single Instruction Multiple Data (SIMD) instruction sets. Like in our recent MD implementation for graphical processing units (GPUs) [Asadchev, A.; Valeev, E. F.. J. Chem. Phys. 2024, 160, 244109.], variable-sized batches of shellsets of integrals are evaluated at a time. By optimizing for the floating point instruction throughput rather than minimizing the number of operations, this approach achieves up to 50% of the theoretical hardware peak FP64 performance for many common SIMD-equipped platforms (AVX2, AVX512, NEON), which translates to speedups of up to 30 over the state-of-the-art one-shellset-at-a-time implementation of Obara−Saika-type schemes in Libint for a variety of primitive and contracted integrals. As with our previous work, we rely on the standard C++ programming language such as the std::simd standard library feature to be included in the 2026 ISO C++ standard without any explicit code generation to keep the code base small and portable. The implementation is part of the open source LibintX library freely available at https://github.com/ValeevGroup/libintx.

Basis sets↗

Evaluation of Low Power ARM Processors for Monte Carlo Particle Transport: MCNP6 on the ARM Cortex-A8 - Paper 83

In the push towards exascale computing, the limiting factors are power requirements and heat dissipation. Using current technology, the power required to drive an exascale supercomputer would near 400-MW. Clearly, future computing hardware will have to be more energy efficient in order to achieve exascale performance. Most of the current research in advanced computing architectures is in the use of standard CPUs with accelerators. However, these accelerators are not generally supported by the traditional scientific programming languages (C, C++, and Fortran) and the scientific software must be tailored specifically to take advantage of the accelerators. Large scale scientific software (hundreds-of-thousand to millions of lines of code) can not be easily ported to the computing platform du jour. The widespread use of low power ARM based processors in the mobile computing market offer a low power alternative to accelerators that are also supported by the traditional scientific programming languages and programming paradigms such as MPI and OpenMP. Computing architectures for scientific computing are often assessed using standard benchmarks such as LINPACK benchmark or using suites of mini-applications that are greatly simplified stand-ins for scientific software. Often the real applications that will deployed on the scientific supercomputers are not ported or tested until delivery of the machines. In order to evaluate the use of ARM processors for scientific computing the Monte Carlo particle transport code, MCNP version 6 was compiled on the ARM Cortex-A8 and a set of benchmark problems were used to assess performance in comparison to an Intel Xeon E5-2670 and the low power Intel Atom N270. MCNP is a continuous energy Monte Carlo particle transport code in development at Los Alamos National Laboratory since 1977. MCNP is used to transport neutrons, photon, electrons, and charged particles using continuous energy interaction data. It is commonly used in fields of nuclear power, nuclear medicine, radiation protection, and high-energy physics through-out the world. MCNP version 6 is approximately 450 thousand lines of code, written primary in Fortran90, with some C and C++. MCNP supports distributed multiprocessing using MPI and threading with OpenMP. The ARM Cortex-A8 executes MCNP6 using about twice as much power as the Intel Xeon E5-2670 and about the same amount of power as the Intel Atom N270. However, these results are encouraging for the use of low-power ARM chips in future supercomputers. The ARM Cortex-A8 is a 32-bit CPU and it's NEON general-purpose SIMD (single-instruction multiple data) engine does not support double-precision floating-point arithmetic. More recent ARM processors (ARM Cortex-A53 and Cortex-A57) support 64-bit addressing and have NEON co-processors that support double-precision floating-point arithmetic. ARM claims that the A50 series delivers a performance increase of 15 times the Cortex-A8 performance for similar power usage. (authors)

61 RADIATION PROTECTION AND DOSIMETRY↗

PcapDB: Search Optimized Packet Capture, Version 0.1.0.0

PcapDB is a packet capture system designed to optimize the captured data for fast search in the typical (network incident response) use case. The technology involved in this software has been submitted via the IDEAS system and has been filed as a provisional patent. It includes the following primary components: capture: The capture component utilizes existing capture libraries to retrieve packets from network interfaces. Once retrieved the packets are passed to additional threads for sorting into flows and indexing. The sorted flows and indexes are passed to other threads so that they can be written to disk. These components are written in the C programming language. search: The search components provide a means to find relevant flows and the associated packets. A search query is parsed and represented as a search tree. Various search commands, written in C, are then used resolve this tree into a set of search results. The tree generation and search execution management components are written in python. interface: The PcapDB web interface is written in Python on the Django framework. It provides a series of pages, API's, and asynchronous tasks that allow the user to manage the capture system, perform searches, and retrieve results. Web page components are written in HTML,CSS and Javascript.

Ferrell, Paul↗

PcapDB: Search Optimized Packet Capture, Version 0.1.0.0

PcapDB is a packet capture system designed to optimize the captured data for fast search in the typical (network incident response) use case. The technology involved in this software has been submitted via the IDEAS system and has been filed as a provisional patent. It includes the following primary components: capture: The capture component utilizes existing capture libraries to retrieve packets from network interfaces. Once retrieved the packets are passed to additional threads for sorting into flows and indexing. The sorted flows and indexes are passed to other threads so that they can be written to disk. These components are written in the C programming language. search: The search components provide a means to find relevant flows and the associated packets. A search query is parsed and represented as a search tree. Various search commands, written in C, are then used resolve this tree into a set of search results. The tree generation and search execution management components are written in python. interface: The PcapDB web interface is written in Python on the Django framework. It provides a series of pages, API's, and asynchronous tasks that allow the user to manage the capture system, perform searches, and retrieve results. Web page components are written in HTML,CSS and Javascript.

Ferrell, Paul↗

Emulating Multiple Inheritance in Fortran 2003/2008

Although the high-performance computing (HPC) community increasingly embraces object-oriented programming (OOP), most HPC OOP projects employ the C++ programming language. Until recently, Fortran programmers interested in mining the benefits of OOP had to emulate OOP in Fortran 90/95. The advent of widespread compiler support for Fortran 2003 now facilitates explicitly constructing object-oriented class hierarchies via inheritance and leveraging related class behaviors such as dynamic polymorphism. Although C++ allows a class to inherit from multiple parent classes, Fortran and several other OOP languages restrict or prohibit explicit multiple inheritance relationships in order to circumvent several pitfalls associated with them. Nonetheless, what appears as an intrinsic feature in one language can be modeled as a user-constructed design pattern in another language. The present paper demonstrates how to apply the facade structural design pattern to support a multiple inheritance class relationship in Fortran 2003. The design unleashes the power of the associated class relationships for modeling complicated data structures yet avoids the ambiguities that plague some multiple inheritance scenarios.

97 MATHEMATICS AND COMPUTING↗

Exploiting Modern C++ for Portable Parallel Programming in Lattice QCD Applications

The evolution of ISO C++ standards increasingly serves the needs of scientific computing, offering potential benefits for developing portable applications. The recent revisions of C++ programming language, for instance, introduces a suite of algorithms capable of being executed on accelerators. Although this approach may not yield best performance, it can present a viable balance between code productivity and computational efficiency. In this report, we discuss the implementation of the HISQ operator utilizing a range of features from the C++17/20/23 standards and include an assessment of their performance.

Strelchenko, Alexei↗

STARlight: A Monte Carlo simulation program for ultra-peripheral collisions of relativistic ions

© 2016 Elsevier B.V. Ultra-peripheral collisions (UPCs) have been a significant source of study at RHIC and the LHC. In these collisions, the two colliding nuclei interact electromagnetically, via two-photon or photonuclear interactions, but not hadronically; they effectively miss each other. Photonuclear interactions produce vector meson states or more general photonuclear final states, while two-photon interactions can produce lepton or meson pairs, or single mesons. In these interactions, the collision geometry plays a major role. We present a program, STARlight, that calculates the cross-sections for a variety of UPC final states and also creates, via Monte Carlo simulation, events for use in determining detector efficiency. Program summary Program Title: STARlight (v2.2) Program Files doi: http://dx.doi.org/10.17632/xjpf4rxtbj.1 Licensing provisions: GNU GPLv3 Programming Language: C++ External Routines: PYTHIA 8.2 and DPMJET 3.0 are needed for some final states. Nature of problem: The cross-section for ultra-peripheral collisions is obtained by integrating the photon fluxes in transverse impact parameter space, subject to the requirement (which is also impact parameter dependent) that the colliding nuclei do not interact hadronically. The program is a two step process. First, it calculates the cross-sections for the reaction of interest, as a function of W (photon–Pomeron or two-photon center of mass energy), Y (final state rapidity) and pT (final state transverse momentum). Second, STARlight generates Monte Carlo events which can be used to determine cross-sections within specific kinematic constraints or for studies of detector efficiencies. The second step includes the decay of any unstable particles produced in the reaction, with appropriate consideration of particle spins and parity. It outputs these events in ASCII format. Solution method: The program generates a two dimensional look-up table of the production cross-section as a function of final state rapidity and mass. The dimensions of the table are selectable, allowing the user to choose the desired accuracy. For certain final states, a second two-dimensional look-up table, giving the transverse momentum distribution, as a function of rapidity, is also used. With these look-up tables, the program generates final states. Particle decays and the final angular distributions are calculated for each event. Restrictions: The program is focused on ultra-relativistic collisions at Brookhaven's RHIC (Relativistic Heavy Ion Collider) and CERN's LHC (Large Hadron Collider), with final states that are visible in a central detector. At lower energies (i.e., at the CERN SPS), caution should be exercised because STARlight does not account for the longitudinal momentum transfer to the nucleus; this is larger at low beam energies. References: http://starlight.hepforge.org and references in this article.

71 CLASSICAL AND QUANTUM MECHANICS, GENERAL PHYSIC↗

C++ Implementation of IAPWS Water Properties

For the calculations of water-involved systems, such as safety analysis of light water reactors, it is essential to provide accurate water properties. The International Association for the Properties of Water and Steam is an international non-profit association of national organizations concerned with the properties of water and steam. It provides internationally accepted formulations of water/steam properties for scientific and industrial applications. The purpose of this work is to provide a stand-alone software package in C++ programming language to provide accurate and efficient water/steam properties evaluation, based on the latest IAPWS releases. The discussion on related IAPWS releases, code implementations and verifications are provided in details.

22 GENERAL STUDIES OF NUCLEAR REACTORS↗

A universal implementation of radiative effects in neutrino event generators

Due to the similarities between electron-nucleus (eA) and neutrino-nucleus scattering (νA), eA data can contribute key information to improve cross-section modeling in eA and hence in νA event generators. However, to compare data and generated events, either the data must be radiatively corrected or radiative effects need to be included in the event generators. We implemented a universal radiative corrections program that can be used with all reaction mechanisms and any eA event generator. Our program includes real photon radiation by the incident and scattered electrons, and virtual photon exchange and photon vacuum polarization diagrams. It uses the “extended peaking” approximation for electron radiation and neglects charged hadron radiation. This method, validated with GENIE, can also be extended to simulate νA radiative effects. This work facilitates data-event-generator comparisons used to improve νA event generators for the next-generation of neutrino experiments. Program Title: emMCRadCorr CPC Library link to program files:https://doi.org/10.17632/hmsxg82vnf.1 Developer's repository link:https://github.com/e4nu/emMCRadCorr Licensing provisions: AGPLv3 Programming language:C++ Nature of problem: Radiative effects can significantly modify the event kinematics and the resulting cross-sections. Such effects must be accounted for when comparing event generators to eA data. Existing radiative correction codes are tailored to specific processes and topologies, and are limited to a restricted phase space defined by the spectrometer acceptance. Therefore, a more general approach is required to apply radiative corrections to semi-inclusive and exclusive eA measurements. Solution method: Our program incorporates real photon radiation from both the incident and scattered electrons, as well as virtual photon exchange and photon vacuum polarization effects. It employs the “extended peaking” approximation for electron radiation while neglecting contributions from charged hadron radiation. The code is fully decoupled from event generator codes and can be used for all event generators in the market.

72 PHYSICS OF ELEMENTARY PARTICLES AND FIELDS↗

Simulating low-energy neutrino interactions with MARLEY

Monte Carlo event generators are a critical tool for the interpretation of data obtained by neutrino experiments. Several modern event generators are available which are well-suited to the GeV energy scale used in studies of accelerator neutrinos. However, theoretical modeling differences make their immediate application to lower energies difficult. In this paper, I present a new event generator, MARLEY, which is designed to better address the simulation needs of the low-energy (tens of MeV and below) neutrino community. The code is written in C++14 with an optional interface to the popular ROOT data analysis framework. The current release of MARLEY (version 1.2.0) emphasizes simulations of the reaction 40 Ar ( ν e , e − ) 40 K ⁎ but is extensible to other channels with suitable user input. This paper provides detailed documentation of MARLEY's implementation and usage, including guidance on how generated events may be analyzed and how MARLEY may be interfaced with external codes such as Geant4. Further information about MARLEY is available on the official website at http://www.marleygen.org. Program title:MARLEY 1.2.0 CPC Library link to program files:https://doi.org/10.17632/4v7zxnc8j3.1 Developer's respository link:http://github.com/MARLEY-MC/marley Code Ocean capsule:https://codeocean.com/capsule/9868179 Licensing provisions: GNU General Public License 3.0 Programming language: C++14 External routines/libraries used: GNU Scientific Library [1,2] (required), ROOT [3,4] (optional) Nature of problem: Simulation of neutrino-nucleus scattering events at energies of tens-of-MeV and below Solution method: Initial two-to-two scattering kinematics are sampled using the allowed approximation differential cross section and tables of precomputed nuclear matrix elements. Subsequent de-excitations of the remnant nucleus are simulated using a Monte Carlo implementation of the Hauser-Feshbach statistical model and tabulated γ-ray decay schemes for discrete nuclear levels. Additional comments including restrictions and unusual features: Input data are provided with the code that are suitable for producing simulations of the charged-current reaction 40 Ar ( ν e , e − ) 40 K ⁎ , coherent elastic neutrino-nucleus scattering on spin-zero target nuclei, and neutrino-electron elastic scattering on any atomic target. Preparation of new reaction input files (whose format is documented in Appendix B) would enable other reaction channels and nuclear targets to be handled by the existing code framework. Although there is no maximum neutrino energy enforced by the code itself, realistic neutrino-nucleus scattering events may be generated up to roughly 50 MeV. Above this energy, the effects of forbidden nuclear transitions, which are neglected in the current treatment of the cross sections (see section 2.1), become increasingly important.

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗

Lightweight runtime checking of C programs with RTC

The C Programming Language is known for being an efficient language that can be compiled on almost any architecture and operating system. However the absence of dynamic safety checks and a relatively weak type system allows programmer oversights that are hard to spot. In this paper, we present RTC, a runtime monitoring tool that instruments unsafe code and monitors the program execution. RTC is built on top of the ROSE compiler infrastructure. RTC finds memory bugs and arithmetic overflows and underflows, and run-time type violations. Most of the instrumentations are directly added to the source file and only require a minimal runtime system. As a result, the instrumented code remains portable. In tests against known error detection benchmarks, RTC found 98% of all memory related bugs and had zero false positives. Finally, in performance tests conducted with well known algorithms, such as binary search and MD5, we determined that our tool has an average run-time overhead rate of 9.7× and memory overhead rate of 3.5×.

97 MATHEMATICS AND COMPUTING↗

LeptonInjector and LeptonWeighter: A neutrino event generator and weighter for neutrino observatories

In this work, we present a high-energy neutrino event generator, called LeptonInjector, alongside an event weighter, called LeptonWeighter. Both are designed for large-volume Cherenkov neutrino telescopes such as IceCube. The neutrino event generator allows for quick and flexible simulation of neutrino events within and around the detector volume, and implements the leading Standard Model neutrino interaction processes relevant for neutrino observatories: neutrino-nucleon deep-inelastic scattering and neutrino-electron annihilation. In this paper, we discuss the event generation algorithm, the weighting algorithm, and the main functions of the publicly available code, with examples. Program summary: Program Titles: LeptonInjector and LeptonWeighter CPC Library link to program files: https://doi.org/10.17632/662gkpjfd9.1 Developer's repository links: https://github.com/icecube/LeptonInjector and https://github.com/icecube/LeptonWeighter Licensing provisions: GNU Lesser General Public License, version 3. Programming Language: C++11 External Routines: • Boost • HDF5 • nuflux (https://github.com/icecube/nuflux) • nuSQuIDS (https://github.com/arguelles/nuSQuIDS) • Photospline (https://github.com/icecube/photospline) • SuiteSparse (https://github.com/DrTimothyAldenDavis/SuiteSparse) Nature of problem: LeptonInjector: Generate neutrino interaction events of all possible topologies and energies throughout and around a detector volume. LeptonWeighter: Reweight Monte Carlo events, generated by a set of LeptonInjector Generators, to any desired physical neutrino flux or cross section. Solution method: LeptonInjector: Projected ranges of generated leptons and the extent of the detector, in terms of column depth, are used to inject events in and around the detector volume. Event kinematics follow distributions provided in cross section files. LeptonWeighter: Event generation probabilities are calculated for each Generator, which are then combined into a generation weight and used to calculate an overall event weight.

72 PHYSICS OF ELEMENTARY PARTICLES AND FIELDS↗