FBPIC

https://fbpic.github.io
Admin
FBPIC is a Fourier-Bessel Particle-In-Cell code for relativistic plasma physics simulations,...
Tokens:165,280
Snippets:1,020
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install and Launch openPMD-viewer

Source: https://fbpic.github.io/how_to_run.html

Install the visualization tool and launch the interactive notebook interface.

```bash
pip install openpmd-viewer
```

```bash
conda install -c conda-forge openpmd-viewer
```

```bash
openPMD_notebook
```

--------------------------------

### Install openPMD-viewer

Source: https://fbpic.github.io/_sources/how_to_run.rst.txt

Install the visualization tool required for inspecting HDF5 simulation outputs.

```bash
pip install openpmd-viewer
```

```bash
conda install -c conda-forge openpmd-viewer
```

--------------------------------

### Install FBPIC

Source: https://fbpic.github.io/_sources/install/install_juwels.rst.txt

Clone the FBPIC repository, navigate into the directory, and run the installation command.

```bash
python setup.py install
```

--------------------------------

### Install Anaconda

Source: https://fbpic.github.io/install/install_juwels.html

Download and execute the Anaconda installer script.

```bash
wget https://repo.anaconda.com/archive/Anaconda3-2019.03-Linux-x86_64.sh
bash Anaconda3-2019.03-Linux-x86_64.sh
```

--------------------------------

### Install GPU support

Source: https://fbpic.github.io/_sources/install/install_local.rst.txt

Install CuPy and CUDA dependencies for GPU acceleration.

```bash
conda install -c conda-forge cupy cuda-version=11.8
```

```bash
conda install -c conda-forge cupy cuda-version=12.0 cuda-nvcc cuda-nvrtc
```

--------------------------------

### Install FBPIC from Source

Source: https://fbpic.github.io/install/install_local.html

Installs FBPIC directly from its GitHub repository. This is an alternative to using a release.

```bash
python3 -m pip install git+https://github.com/fbpic/fbpic.git

```

--------------------------------

### Install PyVista and openPMD-viewer

Source: https://fbpic.github.io/advanced/3d_visualization.html

Install the necessary Python packages for 3D visualization. Ensure you have pip available.

```bash
pip install pyvista
pip install openpmd-viewer

```

--------------------------------

### Install Anaconda and Dependencies

Source: https://fbpic.github.io/_sources/install/install_juwels.rst.txt

Download and install Anaconda, then use conda and pip to install FBPIC's required Python packages. Avoid installing 'mpich' and 'mpi4py' directly with Anaconda.

```bash
wget https://repo.anaconda.com/archive/Anaconda3-2019.03-Linux-x86_64.sh
bash Anaconda3-2019.03-Linux-x86_64.sh
```

```bash
conda install numba scipy h5py mkl
conda install cudatoolkit=10.0
pip install cupy-cuda100
```

```bash
pip install mpi4py --no-cache-dir
```

```bash
pip install git+https://bitbucket.org/mpi4py/mpi4py.git --no-cache-dir
```

--------------------------------

### Launch openPMD-viewer Notebook

Source: https://fbpic.github.io/_sources/how_to_run.rst.txt

Start the interactive visualization notebook.

```bash
openPMD_notebook
```

--------------------------------

### Install FBPIC package

Source: https://fbpic.github.io/_sources/install/install_local.rst.txt

Install the FBPIC package via pip.

```bash
pip install fbpic
```

```bash
pip install fbpic[picmi]
```

```bash
python3 -m pip install git+https://github.com/fbpic/fbpic.git
```

--------------------------------

### Install FBPIC with Pip

Source: https://fbpic.github.io/_sources/install/install_comet.rst.txt

Install the FBPIC package using pip after all its dependencies have been successfully installed.

```bash
pip install fbpic
```

--------------------------------

### Install MKL for Intel CPUs

Source: https://fbpic.github.io/_sources/install/install_local.rst.txt

Optional performance optimization for Intel CPUs.

```bash
conda install -c conda-forge mkl
```

--------------------------------

### Install PyVista and openPMD-viewer

Source: https://fbpic.github.io/_sources/advanced/3d_visualization.rst.txt

Required packages for 3D visualization.

```bash
pip install pyvista
pip install openpmd-viewer
```

--------------------------------

### Install FBPIC with PICMI Interface

Source: https://fbpic.github.io/install/install_local.html

Installs FBPIC with support for the PICMI interface. Use this if you intend to use FBPIC through PICMI.

```bash
pip install fbpic[picmi]

```

--------------------------------

### Initialize Simulation Lists

Source: https://fbpic.github.io/_modules/fbpic/main.html

Initializes empty lists for laser antennas and mirrors, and prints the simulation setup. This is typically done at the beginning of a simulation.

```python
self.laser_antennas = []
        # Initialize an empty list of mirrors
        self.mirrors = []

        # Print simulation setup
        print_simulation_setup( self, verbose_level=verbose_level )
```

--------------------------------

### Download Miniconda Installer

Source: https://fbpic.github.io/_sources/install/install_comet.rst.txt

Use wget to download the Miniconda installer script for Linux 64-bit systems.

```bash
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
```

--------------------------------

### OpenPMD File Creation and Mesh Setup

Source: https://fbpic.github.io/_modules/fbpic/openpmd_diag/field_diag.html

Sets up an OpenPMD file with empty meshes and configures its attributes for storing simulation data.

```APIDOC
## POST /websites/fbpic_github_io/create_file_empty_meshes

### Description
Creates an OpenPMD file with empty meshes and sets up all its attributes. This method is used to initialize the file structure before writing simulation data.

### Method
POST

### Endpoint
/websites/fbpic_github_io/create_file_empty_meshes

### Parameters
#### Path Parameters
- **fullpath** (string) - Required - The absolute path to the file to be created.
- **iteration** (int) - Required - The iteration number of this diagnostic.
- **time** (float) - Required - The physical time at this iteration in seconds.
- **Nr** (int) - Required - The number of gridpoints along the radial direction (r).
- **Nz** (int) - Required - The number of gridpoints along the axial direction (z).
- **zmin** (float) - Required - The position of the left end of the box in meters.
- **dz** (float) - Required - The resolution in the z direction in meters.
- **dt** (float) - Required - The timestep of the simulation in seconds.

### Request Example
```json
{
  "fullpath": "/path/to/simulation/data.h5",
  "iteration": 100,
  "time": 1.5e-9,
  "Nr": 512,
  "Nz": 1024,
  "zmin": -0.01,
  "dz": 1.0e-5,
  "dt": 1.0e-15
}
```

### Response
#### Success Response (200)
- **file_handle** (object) - A handle to the created OpenPMD file.

#### Response Example
```json
{
  "message": "File created and meshes setup successfully."
}
```
```

--------------------------------

### Initialize a Laguerre-Gauss laser pulse

Source: https://fbpic.github.io/_modules/fbpic/lpa_utils/laser/laser.html

Example of configuring a Laguerre-Gauss laser profile and adding it to a simulation object.

```python
from fbpic.lpa_utils.laser import add_laser_pulse, LaguerreGaussLaser

profile = LaguerreGaussLaser(a0=0.5, waist=5.e-6, tau=30.e-15, z0=3.e-6, p=1, m=0)

add_laser_pulse( sim, profile )
```

--------------------------------

### Execute Miniconda Installation

Source: https://fbpic.github.io/_sources/install/install_comet.rst.txt

Run the downloaded Miniconda installer script. It is recommended to answer 'yes' when prompted to add Miniconda to your .bashrc file.

```bash
bash Miniconda3-latest-Linux-x86_64.sh
```

--------------------------------

### 3D Visualization of Simulation Data with PyVista

Source: https://fbpic.github.io/advanced/3d_visualization.html

Use PyVista to create a 3D visualization of simulation output. This example opens simulation data using openPMD-viewer, retrieves the 'rho' field, and displays it using PyVista's plotting capabilities. Requires PyVista and openPMD-viewer to be installed.

```python
from openpmd_viewer import OpenPMDTimeSeries
import pyvista

# Open the simulation outputs using openPMD viewer
ts = OpenPMDTimeSeries('./sim_outputs/diags/hdf5')

# Create the PyVista plotter
plotter = pyvista.Plotter()
plotter.set_background("white")

# Retrieve the rho field from the simulation
# The theta=None argument constructs a 3D cartesian grid from the cylindrical data
rho, meta = ts.get_field("rho", iteration=ts.iterations[-1], theta=None)

# Create the grid on which PyVista can deposit the data
grid = pyvista.UniformGrid()
grid.dimensions = rho.shape
grid.origin = [meta.xmin * 1e6, meta.ymin * 1e6, meta.zmin * 1e6]
grid.spacing = [meta.dx * 1e6, meta.dy * 1e6, meta.dz * 1e6]
grid.point_data['values'] = -rho.flatten(order='F')

# Add the grid to the plotter
# Use a cutoff for rho via the clim argument since otherwise it shows only a small density spike
plotter.add_volume(grid, clim=(0, 4e6), opacity='sigmoid',
                  cmap='viridis', mapper='gpu', show_scalar_bar=False)

# A good starting camera position - the three values are the camera position,
# the camera focus, and the up vector of the viewport
plotter.camera_position = [(-74, 32, 51), (0, 0, 88), (0, 1, 0)]

plotter.show()

```

--------------------------------

### Install FBPIC Dependencies

Source: https://fbpic.github.io/install/install_local.html

Installs the core dependencies required for FBPIC using conda. Ensure Anaconda is installed and configured.

```bash
conda install -c conda-forge numba scipy pyfftw mpi4py

```

--------------------------------

### Install FBPIC using Pip

Source: https://fbpic.github.io/_sources/install/install_perlmutter.rst.txt

Install the FBPIC package itself after its dependencies have been met. This command fetches and installs the latest version from PyPI.

```bash
python3 -m pip install fbpic
```

--------------------------------

### Prepare Simulation Directory

Source: https://fbpic.github.io/_sources/install/install_summit.rst.txt

Create a workspace directory and copy the input script.

```bash
mkdir $MEMBERWORK/<project_id>/<simulation name>
cp fbpic_script.py $MEMBERWORK/<project_id>/<simulation name>
```

--------------------------------

### Install MKL for Intel CPU Optimization

Source: https://fbpic.github.io/install/install_local.html

Optionally installs the MKL library for improved performance on Intel CPUs. Not applicable for Macbooks with Apple Silicon or GPU installations.

```bash
conda install -c conda-forge mkl

```

--------------------------------

### Install MPI4py and Cupy

Source: https://fbpic.github.io/_sources/install/install_comet.rst.txt

Load necessary modules for GNU tools and OpenMPI, then install cupy for CUDA 9.2. Finally, install mpi4py using pip, specifying the MPICC path.

```bash
module purge
module load gnutools
module load gnu openmpi_ib
pip install cupy-cuda92
env MPICC=/opt/openmpi/gnu/ib/bin/mpicc pip install mpi4py --user
```

--------------------------------

### Initialize a laser from a lasy file

Source: https://fbpic.github.io/api_reference/lpa_utilities/laser_profiles/from_lasy_file.html

Demonstrates creating a lasy file, propagating it, and subsequently using FromLasyFileLaser to add the pulse to an FBPIC simulation.

```python
# Creating the lasy file
laser_profile = GaussianProfile(wavelength,polarization,
                        energy,spot_size,pulse_duration,t_peak=0)
dimensions     = 'rt'                              # Use cylindrical geometry
lo             = (0,-2.5*pulse_duration)           # Lower bounds of the simulation box
hi             = (5*spot_size,2.5*pulse_duration)  # Upper bounds of the simulation box
num_points     = (300,500)                         # Number of points in each dimension
laser = Laser(dimensions,lo,hi,num_points,laser_profile)
laser.propagate(-1e-3)  # Propagate backwards by 1 mm
laser.write_to_file('lasy_laser', 'h5')
# Note that, in the lasy file, tmin is now a large, negative number.
# (The peak of laser intensity still occurs 2.5*pulse_duration after tmin.)
# FBPIC ignores tmin when reading the file, and sets the start of
# the lasy time axis to zero instead. So, by default, the peak of
# the laser intensity would occur at `t= 2.5*pulse_duration` in FBPIC.
laser_profile = FromLasyFileLaser( 'lasy_laser_00000.h5', t_start=0.5*pulse_duration )
add_laser_pulse(sim, laser_profile, method='antenna', z0_antenna=0)
# Here, modify the `t_start`, which will result in the peak of intensity being
# emitted at `(2.5+0.5)*pulse_duration` instead of `2.5*pulse_duration`.
# Since the `z0_antenna` was set to `0` here, this is as if the centroid
# of the laser would have been initialized at `z = -3*c*pulse_duration` at `t=0`
# (with then ``direct`` method).
```

--------------------------------

### Install FBPIC Dependencies with Conda

Source: https://fbpic.github.io/_sources/install/install_comet.rst.txt

Install core FBPIC dependencies like numba, scipy, h5py, and cudatoolkit version 9.2 using conda. This command assumes you have already installed Miniconda.

```bash
conda install -c conda-forge numba scipy h5py mkl cudatoolkit=9.2
```

--------------------------------

### Install mpi4py for GPUdirect

Source: https://fbpic.github.io/install/install_juwels.html

Install the development version of mpi4py required for GPUdirect support.

```bash
pip install git+https://bitbucket.org/mpi4py/mpi4py.git --no-cache-dir
```

--------------------------------

### Initialize Electron Bunch from File

Source: https://fbpic.github.io/_modules/fbpic/lpa_utils/bunch.html

Loads particle phase space data from a seven-column text file to initialize an electron bunch.

```python
def add_elec_bunch_file( sim, filename, Q_tot, z_off=0., boost=None,
                        direction='forward', z_injection_plane=None ):
    """
    Introduce a relativistic electron bunch in the simulation,
    along with its space charge field, loading particles from text file.

    Parameters
    ----------
    sim : a Simulation object
        The structure that contains the simulation.

    filename : string
        the file containing the particle phase space in seven columns
        all float, no header
        x [m]  y [m]  z [m]  ux [unitless]  uy [unitless]  uz [unitless]

    Q_tot : float (in Coulomb)
        The total charge of the bunch (in absolute value)
        (if a negative number is given, its absolute value will
        automatically be taken)

    z_off: float (in meters)
        Shift the particle positions in z by z_off

    boost : a BoostConverter object, optional
        A BoostConverter object defining the Lorentz boost of
        the simulation.

    direction : string, optional
        Can be either "forward" or "backward".
        Propagation direction of the beam.

    z_injection_plane: float (in meters) or None
        When `z_injection_plane` is not None, then particles have a ballistic
        motion for z<z_injection_plane. This is sometimes useful in
        boosted-frame simulations.
        `z_injection_plane` is always given in the lab frame.
    """
    n_physical_particles = Q_tot / e
    elec_bunch = add_particle_bunch_file(sim, -e, m_e, filename,
                            n_physical_particles, z_off=z_off,
                            boost=boost, direction=direction,
                            z_injection_plane=z_injection_plane)
    return elec_bunch
```

--------------------------------

### Install mpi4py

Source: https://fbpic.github.io/install/install_juwels.html

Install mpi4py to ensure it links against the cluster's MPI library.

```bash
pip install mpi4py --no-cache-dir
```

--------------------------------

### Initialize and Run FBPIC Simulation

Source: https://fbpic.github.io/example_input/lwfa_script.html

Configures the simulation environment, adds species and laser pulses, sets up diagnostics, and executes the simulation steps.

```python
if __name__ == '__main__':

    # Initialize the simulation object
    sim = Simulation( Nz, zmax, Nr, rmax, Nm, dt, zmin=zmin,
        n_order=n_order, use_cuda=use_cuda,
        boundaries={'z':'open', 'r':'reflective'})
        # 'r': 'open' can also be used, but is more computationally expensive

    # Create the plasma electrons
    elec = sim.add_new_species( q=-e, m=m_e, n=n_e,
        dens_func=dens_func, p_zmin=p_zmin, p_zmax=p_zmax, p_rmax=p_rmax,
        p_nz=p_nz, p_nr=p_nr, p_nt=p_nt )

    # Load initial fields
    # Create a Gaussian laser profile
    laser_profile = GaussianLaser(a0, w0, tau, z0)
    # Add the laser to the fields of the simulation
    add_laser_pulse( sim, laser_profile)

    if use_restart is False:
        # Track electrons if required (species 0 correspond to the electrons)
        if track_electrons:
            elec.track( sim.comm )
    else:
        # Load the fields and particles from the latest checkpoint file
        restart_from_checkpoint( sim )

    # Configure the moving window
    sim.set_moving_window( v=v_window )

    # Add diagnostics
    sim.diags = [ FieldDiagnostic( diag_period, sim.fld, comm=sim.comm ),
                  ParticleDiagnostic( diag_period, {"electrons" : elec},
                    select={"uz" : [1., None ]}, comm=sim.comm ) ]

    # Add checkpoints
    if save_checkpoints:
        set_periodic_checkpoint( sim, checkpoint_period )

    # Number of iterations to perform
    N_step = int(T_interact/sim.dt)

    ### Run the simulation
    sim.step( N_step )
    print('')
```

--------------------------------

### Install FBPIC Dependencies

Source: https://fbpic.github.io/_sources/install/install_summit.rst.txt

Install required packages for FBPIC using Conda and pip.

```bash
conda install cython numba=0.49 cudatoolkit=9.0
```

```bash
pip install pyfftw
```

```bash
pip install fbpic
```

--------------------------------

### Initialize Moving Window

Source: https://fbpic.github.io/_modules/fbpic/main.html

Sets up a moving window for the simulation. Deprecated arguments are kept for backward compatibility but will not be used.

```python
def set_moving_window( self, v=c, ux_m=None, uy_m=None, uz_m=None,
                  ux_th=None, uy_th=None, uz_th=None, gamma_boost=None ):
        """
        Initializes a moving window for the simulation.

        Parameters
        ----------
        v: float (in meters per seconds), optional
            The speed of the moving window

        ux_m, uy_m, uz_m: float (dimensionless), optional
            Unused, kept for backward-compatibility
        ux_th, uy_th, uz_th: float (dimensionless), optional
            Unused, kept for backward-compatibility
        gamma_boost : float, optional
            Unused; kept for backward compatibility
        """
        # Raise deprecation warning
        for arg in [ux_m, uy_m, uz_m, ux_th, uy_th, uz_th, gamma_boost ]:
            if arg is not None:
                warnings.warn(
                'The arguments `u*_m`, `u*_th` and `gamma_boost` of '
                'the method `set_moving_window` are deprecated.\n'
                'They will not be used.\nTo suppress this message, ' 
                'stop passing these arguments to `set_moving_window`', 
                DeprecationWarning)

        # Attach the moving window to the boundary communicator
        self.comm.moving_win = MovingWindow( self.comm, self.dt, v, self.time )
```

--------------------------------

### Install FBPIC dependencies

Source: https://fbpic.github.io/_sources/install/install_local.rst.txt

Install core dependencies required for FBPIC using conda.

```bash
conda install -c conda-forge numba scipy pyfftw mpi4py
```

--------------------------------

### Visual GPU profiling with nvprof and Nsight Systems

Source: https://fbpic.github.io/_sources/advanced/profiling.rst.txt

Generates binary files for visual inspection in nvvp or nsight-sys.

```bash
nvprof -o gpu.prof python fbpic_script.py
```

```bash
nvvp
```

```bash
nsys profile python fbpic_script.py
```

```bash
nsight-sys
```

--------------------------------

### Initialize and Run Simulation

Source: https://fbpic.github.io/example_input/boosted_frame_script.html

Main execution block for initializing the simulation, adding species, configuring diagnostics, and running the simulation steps.

```python
if __name__ == '__main__':

    sim = Simulation( Nz, zmax, Nr, rmax, Nm, dt, zmin=zmin,
        v_comoving=v_comoving, gamma_boost=boost.gamma0,
        n_order=n_order, use_cuda=use_cuda,
        boundaries={'z':'open', 'r':'reflective'})

    plasma_elec = sim.add_new_species( q=-e, m=m_e, n=n_e,
                    dens_func=dens_func, boost_positions_in_dens_func=True,
                    p_zmin=p_zmin, p_zmax=p_zmax, p_rmax=p_rmax,
                    p_nz=p_nz, p_nr=p_nr, p_nt=p_nt )
    plasma_ions = sim.add_new_species( q=e, m=m_p, n=n_e,
                    dens_func=dens_func, boost_positions_in_dens_func=True,
                    p_zmin=p_zmin, p_zmax=p_zmax, p_rmax=p_rmax,
                    p_nz=p_nz, p_nr=p_nr, p_nt=p_nt )

    bunch = add_particle_bunch( sim, -e, m_e, bunch_gamma,
        bunch_n, bunch_zmin, bunch_zmax, 0, bunch_rmax, boost=boost )
    if track_bunch:
        bunch.track( sim.comm )

    laser_profile = GaussianLaser(a0, w0, tau, z0, lambda0=lambda0, zf=zfoc)
    add_laser_pulse( sim, laser_profile, gamma_boost=boost.gamma0,
                     method='antenna', z0_antenna=0)

    v_window_boosted, = boost.velocity( [ v_window ] )
    sim.set_moving_window( v=v_window_boosted )

    sim.diags = [
                  FieldDiagnostic( dt_period=dt_boosted_diag_period,
                                   fldobject=sim.fld, comm=sim.comm ),
                  ParticleDiagnostic( dt_period=dt_boosted_diag_period,
                        species={"electrons":plasma_elec, "bunch":bunch},
                        comm=sim.comm),
                  BackTransformedFieldDiagnostic( zmin, zmax, v_window,
                    dt_lab_diag_period, N_lab_diag, boost.gamma0,
                    fieldtypes=['rho','E','B'], period=write_period,
                    fldobject=sim.fld, comm=sim.comm ),
                  BackTransformedParticleDiagnostic( zmin, zmax, v_window,
                    dt_lab_diag_period, N_lab_diag, boost.gamma0,
                    write_period, sim.fld, select={'uz':[0.,None]},
                    species={'bunch':bunch}, comm=sim.comm )
                ]

    N_step = int(T_interact/sim.dt)

    sim.step( N_step )
    print('')
```

--------------------------------

### Install oneDNN on Apple Silicon

Source: https://fbpic.github.io/_sources/install/install_local.rst.txt

Install oneDNN via Homebrew for Apple Silicon machines.

```bash
brew install onednn
```

--------------------------------

### Check CUDA Installation

Source: https://fbpic.github.io/_modules/fbpic/main.html

Checks if CUDA (GPU) acceleration is requested and if it's installed. If not, it issues a warning.

```python
        # Check whether to use CUDA
        self.use_cuda = use_cuda
        if self.use_cuda and not cuda_installed:
            warning_message = 'GPU not available for the simulation.\n'
```

--------------------------------

### Initialize ParticleCatcher

Source: https://fbpic.github.io/_modules/fbpic/openpmd_diag/boosted_particle_diag.html

Sets up the ParticleCatcher class with boost parameters and simulation field objects.

```python
class ParticleCatcher:
    """
    Class that extracts, Lorentz-transforms and gathers particles
    """
    def __init__( self, gamma_boost, beta_boost, fldobject ):
        """
        Initialize the ParticleCatcher object

        Parameters
        ----------
        gamma_boost, beta_boost: float
            The Lorentz factor of the boost and the corresponding beta

        fldobject : a Fields object,
            The Fields object of the simulation, that is needed to
            extract some information about the grid
        """
        # Some attributes necessary for particle selections
        self.gamma_boost = gamma_boost
        self.beta_boost = beta_boost

        # Register the fields object
        self.fld = fldobject
        self.dt = self.fld.dt
```

--------------------------------

### Install FBPIC dependencies

Source: https://fbpic.github.io/install/install_juwels.html

Install core scientific packages and CUDA-specific libraries via conda and pip.

```bash
conda install numba scipy h5py mkl
conda install cudatoolkit=10.0
pip install cupy-cuda100
```

--------------------------------

### Setup OpenPMD Species Records

Source: https://fbpic.github.io/_modules/fbpic/openpmd_diag/particle_diag.html

Initializes OpenPMD species records for various particle properties like position, momentum, spin, and fields. This is typically done by the rank 0 process.

```python
if self.rank == 0:
            if "x" in particle_data:
                self.setup_openpmd_species_record(
                    species_grp["position"], "position" )
            if "ux" in particle_data:
                self.setup_openpmd_species_record(
                    species_grp["momentum"], "momentum" )
            if "sx" in particle_data:
                self.setup_openpmd_species_record(
                    species_grp["spin"], "spin")
            if "Ex" in particle_data:
                self.setup_openpmd_species_record(
                    species_grp["E"], "E" )
            if "Bx" in particle_data:
                self.setup_openpmd_species_record(
                    species_grp["B"], "B" )
```

--------------------------------

### Configure Moving Window and Diagnostics

Source: https://fbpic.github.io/example_input/ionization_script.html

Sets up the moving window for the simulation and defines the diagnostics to be collected, including field, particle, and charge density diagnostics. Checkpoints can also be configured.

```python
# Configure the moving window
    sim.set_moving_window( v=v_window )

    # Add diagnostics
    sim.diags = [
                FieldDiagnostic( diag_period, sim.fld, comm=sim.comm ),
                ParticleDiagnostic( diag_period,
                    {"electrons from N": elec_from_N, "electrons": elec},
                    comm=sim.comm ),
                # Since rho from `FieldDiagnostic` is 0 almost everywhere
                # (neutral plasma), it is useful to see the charge density
                # of individual particles
                ParticleChargeDensityDiagnostic( diag_period, sim,
                    {"electrons": elec} )
                ]
    # Add checkpoints
    if save_checkpoints:
        set_periodic_checkpoint( sim, checkpoint_period )
```

--------------------------------

### Profile GPU execution with nvprof and Nsight Systems

Source: https://fbpic.github.io/_sources/advanced/profiling.rst.txt

Captures GPU profiling data using nvprof or Nsight Systems.

```bash
nvprof --log-file gpu.log python fbpic_script.py
```

```bash
nsys profile --stats=true python fbpic_script.py
```

--------------------------------

### Initialize FBPIC Environment

Source: https://fbpic.github.io/_modules/fbpic/main.html

Configures MPI, threading, and CUDA contexts. Must be executed before other imports to ensure proper GPU selection.

```python
# Copyright 2016, FBPIC contributors
# Authors: Remi Lehe, Manuel Kirchen, Kevin Peters, Soeren Jalas
# License: 3-Clause-BSD-LBNL
"""
Fourier-Bessel Particle-In-Cell (FB-PIC) main file

This file steers and controls the simulation.
"""
# When cuda is available, select one GPU per mpi process
# (This needs to be done before the other imports,
# as it sets the cuda context)
from fbpic.utils.mpi import MPI
# Check if threading is available
from .utils.threading import threading_enabled, numba_version
# Check if CUDA is available, then import CUDA functions
from .utils.cuda import cuda_installed, \
    cupy_installed, cupy_version, numba_cuda_installed
if cuda_installed:
    from .utils.cuda import send_data_to_gpu, \
                receive_data_from_gpu, mpi_select_gpus
    mpi_select_gpus( MPI )
    if cupy_installed:
        import cupy
```

--------------------------------

### Install openPMD-viewer in Jupyter

Source: https://fbpic.github.io/_sources/install/install_lawrencium.rst.txt

Install the openPMD-viewer package within a Jupyter notebook cell on Lawrencium for visualizing simulation results.

```python
!pip install openPMD-viewer --user
```

--------------------------------

### Install FBPIC Dependencies

Source: https://fbpic.github.io/_sources/install/install_lawrencium.rst.txt

Install necessary dependencies for FBPIC using conda and pip. Ensure you have the correct cudatoolkit version (10.0 in this case).

```bash
conda install numba scipy h5py mkl cudatoolkit=10.0
conda install -c conda-forge mpi4py=*=*mpich*
pip install cupy-cuda100
```

--------------------------------

### Configure and Run Interactive Simulation

Source: https://fbpic.github.io/_sources/install/install_summit.rst.txt

Set environment variables and launch the simulation script in an interactive session.

```bash
module purge
module load gcc
module load cuda/9.1.85
module load fftw
module load python/3.7.0-anaconda3-5.3.0
source activate fbpic

export CUPY_CACHE_DIR=$MEMBERWORK/<project_id>/.cupy/kernel_cache
export FBPIC_DISABLE_CACHING=1
export NUMBA_NUM_THREADS=1
export OMP_NUM_THREADS=1

jsrun -n 1 -a 1 -c 1 -g 1 python <fbpic_script.py>
```
Tokens:
Raw