### Install Documentation Dependencies

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/user_guide/build.rst

Installs the necessary Python packages required for building the documentation. This command should be run from the project's root directory.

```bash
pip install -r requirements-dev.txt
```

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

### Verify RadarSimPy Installation

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/user_guide/installation.rst

Imports the radarsimpy package and prints the current version to ensure the module is correctly installed and accessible in the environment.

```python
import radarsimpy
print(f"RadarSimPy version: {radarsimpy.__version__}")
```

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

### Configure Radar Transmitters

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Demonstrates how to initialize a Transmitter object for FMCW chirps and multi-channel TDM-MIMO setups. It defines frequency sweeps, power levels, and antenna channel characteristics.

```python
import radarsimpy as rs
import numpy as np

# Basic FMCW transmitter with 4 GHz bandwidth chirp
tx = rs.Transmitter(
    f=[77e9, 81e9],           # Frequency sweep: 77-81 GHz (4 GHz bandwidth)
    t=[0, 100e-6],            # Chirp duration: 100 microseconds
    tx_power=15,              # Transmit power: 15 dBm
    pulses=128,               # Number of chirps per frame
    prp=200e-6,               # Pulse repetition period: 200 microseconds
    channels=[
        {
            "location": [0, 0, 0],                    # Antenna location (m)
            "polarization": [0, 0, 1],                # Vertical polarization
            "azimuth_angle": np.arange(-90, 91, 1),   # Azimuth pattern angles
            "azimuth_pattern": np.zeros(181),         # Isotropic pattern (dB)
            "elevation_angle": np.arange(-90, 91, 1),
            "elevation_pattern": np.zeros(181),
        }
    ]
)

# Multi-channel TDM-MIMO transmitter with pulse modulation
tx_mimo = rs.Transmitter(
    f=[77e9, 77.5e9],
    t=[0, 50e-6],
    tx_power=10,
    pulses=256,
    prp=100e-6,
    channels=[
        {
            "location": [0, 0, 0],
            "pulse_amp": np.array([1, 0] * 128),      # TDM: TX0 active on even pulses
            "pulse_phs": np.zeros(256),
        },
        {
            "location": [0.006, 0, 0],                # 6mm spacing (lambda/2 at 77 GHz)
            "pulse_amp": np.array([0, 1] * 128),      # TDM: TX1 active on odd pulses
            "pulse_phs": np.zeros(256),
        }
    ]
)
```

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

### Validate Build Environment Configuration

Source: https://github.com/radarsimx/radarsimpy/blob/master/build_instructions.md

Runs the project's internal configuration script to verify that all system dependencies, such as CMake, Python versions, and compilers, are correctly installed and configured.

```python
python build_config.py
```

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

### Configure MIMO Radar for DoA Estimation

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Provides the setup for a MIMO radar system utilizing a Uniform Linear Array (ULA) receiver, which serves as the foundation for performing Direction of Arrival estimation.

```python
tx = rs.Transmitter(f=[77e9, 77.2e9], t=[0, 50e-6], pulses=64, prp=100e-6)
rx = rs.Receiver(
    fs=4e6, noise_figure=10, rf_gain=20, baseband_gain=30,
    channels=[{"location": [0, i * 0.00195, 0]} for i in range(8)]
)
radar = rs.Radar(transmitter=tx, receiver=rx)
```

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

### Check License Status

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/user_guide/installation.rst

Checks whether the current RadarSimPy installation is running in licensed mode or free tier mode. If licensed, it retrieves and displays the license information.

```python
import radarsimpy

# Check license status
if radarsimpy.is_licensed():
    # Get license information
    info = radarsimpy.get_license_info()
    print(f"License info: {info}")
else:
    print("Running in free tier mode with limitations")
```

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

### Configure Radar Systems with Motion and Multi-frame Support

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Demonstrates how to initialize a radar system with constant velocity or multi-frame time-varying parameters. These configurations are essential for simulating dynamic scenes.

```python
moving_radar = rs.Radar(
    transmitter=tx,
    receiver=rx,
    location=[0, 0, 0],
    speed=[10, 0, 0],
    rotation=[0, 0, 0],
    rotation_rate=[0, 0, 0]
)

multi_frame_radar = rs.Radar(
    transmitter=tx,
    receiver=rx,
    frame_time=[0, 0.1, 0.2],
    location=[0, 0, 0],
    speed=[0, 0, 0]
)
```

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

### Clean and Build Documentation Formats

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/user_guide/build.rst

Provides commands for cleaning previous builds and generating documentation in various formats like PDF, EPUB, and single-page HTML. Also includes commands for checking external links and running doctests.

```bash
make clean
make latexpdf
make epub
make singlehtml
make linkcheck
make doctest
```

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

### Build HTML Documentation (Windows)

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/user_guide/build.rst

Builds the HTML version of the documentation on Windows systems. Navigate to the 'gen_docs' directory before running this command.

```batch
cd gen_docs
make.bat html
```

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

### Build HTML Documentation (Linux/macOS)

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/user_guide/build.rst

Builds the HTML version of the documentation on Linux and macOS systems. Navigate to the 'gen_docs' directory before running this command.

```bash
cd gen_docs
make html
```

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

### Configure Radar Receivers

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Shows how to set up Receiver objects including sampling rate, noise parameters, and multi-channel array configurations for DoA estimation.

```python
import radarsimpy as rs
import numpy as np

# Single-channel receiver
rx = rs.Receiver(
    fs=20e6,                  # Sampling rate: 20 MHz
    noise_figure=10,          # Noise figure: 10 dB
    rf_gain=20,               # RF amplifier gain: 20 dB
    load_resistor=500,        # Load resistance: 500 ohms
    baseband_gain=30,         # Baseband gain: 30 dB
    bb_type="complex",        # Complex baseband (I/Q)
    channels=[
        {"location": [0, 0, 0], "polarization": [0, 0, 1]}
    ]
)

# 4-channel linear receiver array for DoA estimation
rx_array = rs.Receiver(
    fs=40e6,
    noise_figure=8,
    rf_gain=25,
    baseband_gain=35,
    bb_type="complex",
    channels=[
        {"location": [0, i * 0.00195, 0]}  # lambda/2 spacing at 77 GHz
        for i in range(4)
    ]
)
```

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

### Initialize Radar System

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Integrates a Transmitter and Receiver into a complete Radar system, including motion parameters like location and velocity.

```python
import radarsimpy as rs

# Create transmitter and receiver
tx = rs.Transmitter(f=[77e9, 77.5e9], t=[0, 40e-6], tx_power=10, pulses=64, prp=100e-6)
rx = rs.Receiver(fs=10e6, noise_figure=10, rf_gain=20, baseband_gain=30, bb_type="complex")

# Static radar system
radar = rs.Radar(
    transmitter=tx,
    receiver=rx,
    location=[0, 0, 0],
    speed=[0, 0, 0],
    rotation=[0, 0, 0],
    rotation_rate=[0, 0, 0]
)
```

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

### Simulate LiDAR and Access Point Cloud Data

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Demonstrates how to define scene targets using STL models and execute a LiDAR simulation. The resulting point cloud data, including positions and directions, is then extracted for analysis.

```python
targets = [
    {
        "model": "./models/surface.stl",
        "origin": [0, 0, 0],
        "location": [10, 0, 0],
        "speed": [0, 0, 0],
        "rotation": [0, 0, 0],
        "rotation_rate": [0, 0, 0],
        "unit": "m"
    }
]

rays = rs.sim_lidar(
    lidar=lidar,
    targets=targets,
    frame_time=0
)

positions = rays["positions"]
directions = rays["directions"]

print(f"Number of points: {len(rays)}")
print(f"Point cloud bounds: X[{positions[:,0].min():.2f}, {positions[:,0].max():.2f}]")
```

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

### Perform Range-Doppler Processing with Windowing

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Shows how to simulate radar data and apply range and Doppler FFTs using specific window functions like Hamming and Hanning. It also demonstrates a combined range-Doppler processing function and calculates resolution metrics.

```python
import radarsimpy as rs
from radarsimpy import processing
import numpy as np

tx = rs.Transmitter(f=[77e9, 77.2e9], t=[0, 50e-6], tx_power=10, pulses=128, prp=100e-6)
rx = rs.Receiver(fs=4e6, noise_figure=10, rf_gain=20, baseband_gain=30, bb_type="complex")
radar = rs.Radar(transmitter=tx, receiver=rx)

targets = [{"location": [30, 0, 0], "rcs": 10, "speed": [-10, 0, 0]}]
result = rs.sim_radar(radar, targets)
baseband = result["baseband"]

range_win = np.hamming(baseband.shape[2])
range_profile = processing.range_fft(baseband, rwin=range_win, n=512)

doppler_win = np.hanning(baseband.shape[1])
range_doppler = processing.doppler_fft(range_profile, dwin=doppler_win, n=256)

rd_map = processing.range_doppler_fft(
    baseband,
    rwin=np.hamming(baseband.shape[2]),
    dwin=np.hanning(baseband.shape[1]),
    rn=512,
    dn=256
)

print(f"Range-Doppler map shape: {rd_map.shape}")
```

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

### Simulate Targets and Estimate Direction of Arrival (DoA) using Python

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

This snippet demonstrates simulating radar targets at different angles and then processing the resulting baseband data to estimate the Direction of Arrival (DoA) using MUSIC, Root-MUSIC, ESPRIT, Bartlett, and Capon beamforming algorithms. It requires the radarsimpy library and numpy.

```python
import radarsimpy as rs
from radarsimpy import processing
import numpy as np

# Simulate targets at different angles
targets = [
    {"location": [30 * np.cos(np.radians(15)), 30 * np.sin(np.radians(15)), 0],
     "rcs": 10, "speed": [0, 0, 0]},  # Target at 15 degrees
    {"location": [40 * np.cos(np.radians(-20)), 40 * np.sin(np.radians(-20)), 0],
     "rcs": 8, "speed": [0, 0, 0]}   # Target at -20 degrees
]

# Assuming 'radar' is a pre-defined radar object
# result = rs.sim_radar(radar, targets)
# baseband = result["baseband"]

# Placeholder for baseband data for demonstration
# In a real scenario, this would come from rs.sim_radar
channels = 4
pulses = 128
baseband = np.random.rand(channels, pulses) + 1j * np.random.rand(channels, pulses)

# Extract signal at specific range bin and compute covariance matrix
# Placeholder for range_profile for demonstration
# In a real scenario, this would come from processing.range_fft
range_profile = np.random.rand(channels, pulses, 256) + 1j * np.random.rand(channels, pulses, 256)

range_bin = 50                         # Select range bin with targets
signal = range_profile[:, :, range_bin]  # [channels, pulses]
covmat = signal @ signal.conj().T / signal.shape[1]

# MUSIC algorithm
doa_angles, doa_idx, spectrum = processing.doa_music(
    covmat=covmat,
    nsig=2,                            # Number of signals
    spacing=0.5,                       # Element spacing in wavelengths
    scanangles=range(-90, 91)          # Scan angles
)
print(f"MUSIC DoA estimates: {doa_angles}")

# Root-MUSIC algorithm (no spectral search)
doa_root = processing.doa_root_music(
    covmat=covmat,
    nsig=2,
    spacing=0.5
)
print(f"Root-MUSIC DoA estimates: {doa_root}")

# ESPRIT algorithm
doa_esprit = processing.doa_esprit(
    covmat=covmat,
    nsig=2,
    spacing=0.5
)
print(f"ESPRIT DoA estimates: {doa_esprit}")

# Bartlett beamforming
spectrum_bartlett = processing.doa_bartlett(
    covmat=covmat,
    spacing=0.5,
    scanangles=range(-90, 91)
)

# Capon (MVDR) beamforming
spectrum_capon = processing.doa_capon(
    covmat=covmat,
    spacing=0.5,
    scanangles=range(-90, 91)
)

print(f"Bartlett peak: {np.argmax(spectrum_bartlett) - 90} degrees")
print(f"Capon peak: {np.argmax(spectrum_capon) - 90} degrees")
```

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

### Simulate LiDAR Point Clouds

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Configures a LiDAR system and simulates point cloud generation by ray-tracing against 3D mesh models with defined scanning patterns.

```python
lidar = {
    "position": [0, 0, 1.5],
    "phi": np.arange(-60, 61, 0.5),
    "theta": np.arange(80, 101, 1)
}
```

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

### Simulator Execution

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/api/sim.rst

Documentation for the main simulator module used to execute radar simulation scenarios.

```APIDOC
## POST /simulator/run

### Description
Executes a radar simulation based on the provided configuration parameters and scene definitions.

### Method
POST

### Endpoint
/simulator/run

### Parameters
#### Request Body
- **scene** (object) - Required - The scene definition containing targets and environment settings.
- **radar** (object) - Required - The radar configuration parameters.
- **simulation_params** (object) - Optional - Additional parameters for simulation fidelity and duration.

### Request Example
{
  "scene": { "targets": [] },
  "radar": { "frequency": 77e9 },
  "simulation_params": { "step": 1e-6 }
}

### Response
#### Success Response (200)
- **data** (object) - The resulting radar signal data or detection list.

#### Response Example
{
  "status": "success",
  "data": { "signal": [0.1, 0.2] }
}
```

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

### Mesh Loading Utilities

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Functions for loading and scaling 3D mesh files for electromagnetic simulation.

```APIDOC
## POST /mesh_kit/load_mesh

### Description
Loads a 3D mesh file (STL, OBJ, PLY) and applies a scaling factor to convert units to meters.

### Method
POST

### Endpoint
/mesh_kit/load_mesh

### Parameters
#### Request Body
- **mesh_file_name** (string) - Required - Path to the mesh file.
- **scale** (float) - Optional - Scaling factor (default 1.0).

### Response
#### Success Response (200)
- **points** (array) - Vertex coordinates [N, 3].
- **cells** (array) - Face indices [M, 3].
```

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

### Load 3D Meshes from Various Formats using Python

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

This snippet demonstrates how to load 3D mesh files (STL, OBJ, PLY) using the radarsimpy.mesh_kit module. It automatically imports an available mesh processing library (like trimesh, pyvista, etc.) and allows loading meshes with a specified scale factor.

```python
from radarsimpy import mesh_kit
import numpy as np

# Import available mesh module (tries trimesh, pyvista, pymeshlab, meshio)
mesh_module = mesh_kit.import_mesh_module()
print(f"Using mesh library: {mesh_module.__name__}")

# Load 3D model with scale factor
# Ensure a file named 'cr.stl' exists in a './models/' directory or adjust path
# mesh_data = mesh_kit.load_mesh(
#     mesh_file_name="./models/cr.stl",
#     scale=1.0,                         # Scale factor (1.0 = meters)
#     mesh_module=mesh_module
# )

# Placeholder for mesh_data for demonstration
mesh_data = {
    "points": np.random.rand(100, 3),
    "cells": np.random.randint(0, 100, size=(200, 3))
}

vertices = mesh_data["points"]         # Vertex coordinates [N, 3]
faces = mesh_data["cells"]             # Face indices [M, 3]

print(f"Vertices: {vertices.shape[0]}")
print(f"Faces: {faces.shape[0]}")
print(f"Bounding box: [{vertices.min(axis=0)}, {vertices.max(axis=0)}]")

# Load model in different units
# Ensure a file named 'plate.stl' exists in a './models/' directory or adjust path
# mesh_mm = mesh_kit.load_mesh("./models/plate.stl", scale=1000, mesh_module=mesh_module)  # millimeters
# mesh_cm = mesh_kit.load_mesh("./models/plate.stl", scale=100, mesh_module=mesh_module)   # centimeters

# Placeholder for loaded meshes
mesh_mm = {"points": np.random.rand(50, 3) * 1000, "cells": np.random.randint(0, 50, size=(100, 3))}
mesh_cm = {"points": np.random.rand(50, 3) * 100, "cells": np.random.randint(0, 50, size=(100, 3))}

print("Loaded mesh in millimeters (example)")
print("Loaded mesh in centimeters (example)")
```

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

### sim_radar Parameters

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/user_guide/ray_tracing_simulation.rst

Parameters controlling the mesh simulation behavior for ray-tracing and Physical Optics.

```APIDOC
## sim_radar Parameters

### Description
These parameters control the mesh simulation behavior for ray-tracing and Physical Optics (PO) based simulations.

### Parameters

#### density
- **Type**: float
- **Default**: 1.0
- **Description**: Ray density, defined as the number of rays per wavelength. Higher values increase accuracy at the cost of computation time and memory. Lower values decrease computation time but may reduce accuracy. A value of 1.0 is a reasonable starting point. Individual targets can override this by setting a per-target `density` value (0.0 uses the global density).

#### level
- **Type**: str or None
- **Default**: None
- **Description**: Controls simulation fidelity by determining how often ray-tracing is performed.
  - `None` or `"frame"`: One ray-tracing simulation for the entire frame. Suitable for static or slowly moving targets.
  - `"pulse"`: Ray-tracing for each pulse. Captures intra-frame motion. Recommended for moving targets.
  - `"sample"`: Ray-tracing for each sample. Captures rapid target dynamics and micro-Doppler effects. Most computationally expensive.

#### ray_filter
- **Type**: list or None
- **Default**: None
- **Description**: Filters rays based on their number of reflections (bounces). Only rays with reflection counts within `[ray_filter[0], ray_filter[1]]` are included. When `None`, no filtering is applied. Useful for isolating specific scattering mechanisms (e.g., `[1, 1]` for single-bounce).

#### back_propagating
- **Type**: bool
- **Default**: False
- **Description**: Enables backward ray propagation analysis. When `True`, an additional backtracing pass is performed to check for additional multi-bounce paths scattering energy back to the receiver. Increases computation time.
```

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

### Implement CFAR Detection for Radar Targets

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Illustrates the use of CA-CFAR and OS-CFAR algorithms to detect targets in radar data. It covers 1D and 2D implementations with configurable guard and training cells to manage false alarm rates.

```python
rd_map = processing.range_doppler_fft(result["baseband"])
power_map = np.abs(rd_map[0])**2

cfar_threshold_2d = processing.cfar_ca_2d(
    data=power_map,
    guard=[2, 2],
    trailing=[4, 8],
    pfa=1e-6,
    detector="squarelaw"
)

detections = power_map > cfar_threshold_2d
num_detections = np.sum(detections)
print(f"Number of detections: {num_detections}")
```

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

### Simulate Radar Baseband Responses

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Uses the sim_radar function to generate baseband signals for point targets and 3D mesh models. It supports GPU acceleration and configurable ray-tracing fidelity.

```python
result = rs.sim_radar(
    radar=radar,
    targets=targets,
    density=1.0,
    level=None,
    device="gpu"
)

mesh_result = rs.sim_radar(
    radar=radar,
    targets=mesh_targets,
    density=2.0,
    level="pulse",
    ray_filter=[0, 3],
    back_propagating=False,
    device="gpu"
)
```

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

### Define Local Euler Rotation Configuration

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/user_guide/coordinate.rst

This snippet demonstrates how to define a rotation configuration array using the Z-Y-X convention (yaw, pitch, roll) in Python. The values represent degrees of rotation applied sequentially.

```python
# Define rotation: 45° yaw, 10° pitch, 5° roll
rotation = [45, 10, 5]
```

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

### radarsimpy.Radar

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/api/radar.rst

API documentation for the Radar class, the primary interface for managing radar system simulation.

```APIDOC
## radarsimpy.Radar

### Description
Integrates Transmitter and Receiver components to simulate a complete radar system, including motion and environmental noise.

### Method
Class Initialization

### Parameters
#### Attributes
- **transmitter** (Transmitter) - Required - Configured transmitter object
- **receiver** (Receiver) - Required - Configured receiver object
- **motion** (dict) - Optional - Radar motion parameters

### Response
Returns a Radar system object capable of executing simulation cycles.
```

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

### Radar and LiDAR Simulation

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Simulate radar or LiDAR systems by defining targets and sensor parameters to generate point clouds or baseband signals.

```APIDOC
## POST /sim_lidar

### Description
Simulates a LiDAR sensor against a set of defined targets to produce a point cloud.

### Method
POST

### Endpoint
/sim_lidar

### Parameters
#### Request Body
- **lidar** (object) - Required - The LiDAR sensor configuration object.
- **targets** (array) - Required - A list of target objects containing model, origin, location, and movement parameters.
- **frame_time** (float) - Optional - The timestamp of the simulation frame.

### Request Example
{
  "lidar": { "..." },
  "targets": [{"model": "./models/surface.stl", "location": [10, 0, 0]}],
  "frame_time": 0
}

### Response
#### Success Response (200)
- **positions** (array) - Hit positions [N, 3]
- **directions** (array) - Ray directions [N, 3]

#### Response Example
{
  "positions": [[10.1, 0, 0], ...],
  "directions": [[-1, 0, 0], ...]
}
```

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

### Calculate Radar Cross-Section (RCS)

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Performs RCS simulation for 3D models using the Shooting and Bouncing Rays (SBR) method. Supports monostatic and bistatic configurations, as well as angular sweeps.

```python
rcs = rs.sim_rcs(
    targets=targets,
    f=77e9,
    inc_phi=0,
    inc_theta=90,
    inc_pol=[0, 0, 1],
    density=1.0
)

rcs_bistatic = rs.sim_rcs(
    targets=targets,
    f=77e9,
    inc_phi=0,
    inc_theta=90,
    inc_pol=[0, 0, 1],
    obs_phi=45,
    obs_theta=90,
    obs_pol=[0, 0, 1],
    density=1.5
)
```

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

### ROC Analysis for Radar Detection Probability using Python

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

This snippet shows how to compute the probability of detection (Pd) for various Swerling target models and calculate the required Signal-to-Noise Ratio (SNR) for a desired Pd. It utilizes the radarsimpy.tools module and requires numpy.

```python
import radarsimpy as rs
from radarsimpy import tools
import numpy as np

# Calculate probability of detection for given SNR
pd = tools.roc_pd(
    pfa=1e-6,                          # Probability of false alarm
    snr=15,                            # SNR in dB
    npulses=16,                        # Number of integrated pulses
    stype="Swerling 1"                 # Target fluctuation model
)
print(f"Pd (Swerling 1, 16 pulses, SNR=15dB): {pd:.4f}")

# Compare different Swerling models
snr_range = np.arange(0, 25, 0.5)
swerling_models = ["Swerling 0", "Swerling 1", "Swerling 2", "Swerling 3", "Swerling 4"]

for model in swerling_models:
    pd_curve = tools.roc_pd(pfa=1e-6, snr=snr_range, npulses=10, stype=model)
    idx_90 = np.argmin(np.abs(pd_curve - 0.9))
    print(f"{model}: SNR for Pd=0.9 is ~{snr_range[idx_90]:.1f} dB")

# Calculate required SNR for target Pd
required_snr = tools.roc_snr(
    pfa=1e-6,
    pd=0.9,                            # Desired probability of detection
    npulses=32,
    stype="Coherent"
)
print(f"Required SNR for Pd=0.9: {required_snr:.2f} dB")

# Coherent vs non-coherent integration comparison
npulses_list = [1, 4, 16, 64]
for n in npulses_list:
    snr_coherent = tools.roc_snr(pfa=1e-6, pd=0.9, npulses=n, stype="Coherent")
    snr_swerling0 = tools.roc_snr(pfa=1e-6, pd=0.9, npulses=n, stype="Swerling 0")
    print(f"N={n}: Coherent={snr_coherent:.2f}dB, Non-coherent={snr_swerling0:.2f}dB")
```

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

### radarsimpy.Receiver

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/api/radar.rst

API documentation for the Receiver class, used to define radar reception properties.

```APIDOC
## radarsimpy.Receiver

### Description
Defines the properties and behavior of a radar receiver, including noise floor calculation and channel processing.

### Method
Class Initialization

### Parameters
#### Attributes
- **noise_figure** (float) - Required - Receiver noise figure in dB
- **bandwidth** (float) - Required - Receiver bandwidth in Hz
- **gain** (float) - Required - Receiver gain in dB

### Response
Returns an instance of the Receiver class configured for signal acquisition.
```

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

### Target Flags

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/user_guide/ray_tracing_simulation.rst

Flags that can be set in the target dictionary for 3D mesh targets to modify simulator handling.

```APIDOC
## Target Flags

### Description
These flags can be set in the target dictionary for 3D mesh targets to modify how the simulator handles them during simulation.

### Parameters

#### skip_diffusion
- **Type**: bool
- **Default**: False
- **Description**: When `True`, the simulator skips the diffusion (diffraction) calculation for this target. Primarily intended for large flat reflectors where diffusion is negligible compared to specular reflection, reducing computational load.

#### environment
- **Type**: bool
- **Default**: Not specified
- **Description**: Indicates if the target is considered part of the environment. (Further details not provided in the source text).
```

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

### CFAR Detection

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Implement Constant False Alarm Rate (CFAR) detection algorithms to identify targets in radar data.

```APIDOC
## POST /processing/cfar_ca_2d

### Description
Performs 2D Cell Averaging CFAR detection on a range-Doppler map.

### Method
POST

### Endpoint
/processing/cfar_ca_2d

### Parameters
#### Request Body
- **data** (array) - Required - The range-Doppler power map.
- **guard** (array) - Required - Number of guard cells [Doppler, range].
- **trailing** (array) - Required - Number of training cells [Doppler, range].
- **pfa** (float) - Required - Probability of false alarm.

### Request Example
{
  "data": ["..."],
  "guard": [2, 2],
  "trailing": [4, 8],
  "pfa": 1e-6
}

### Response
#### Success Response (200)
- **threshold** (array) - The calculated detection threshold map.
```

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

### radarsimpy.Transmitter

Source: https://github.com/radarsimx/radarsimpy/blob/master/gen_docs/api/radar.rst

API documentation for the Transmitter class, used to define radar transmission properties.

```APIDOC
## radarsimpy.Transmitter

### Description
Defines the properties and behavior of a radar transmitter, including signal generation and pulse modulation.

### Method
Class Initialization

### Parameters
#### Attributes
- **f_c** (float) - Required - Carrier frequency in Hz
- **peak_power** (float) - Required - Peak transmit power in Watts
- **phase_noise** (dict) - Optional - Oscillator phase noise characteristics

### Response
Returns an instance of the Transmitter class configured for radar signal simulation.
```

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

### Direction of Arrival (DoA) Estimation

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Endpoints for estimating the direction of arrival of signals using various spectral and subspace-based algorithms.

```APIDOC
## POST /processing/doa_music

### Description
Estimates the direction of arrival using the MUSIC algorithm based on a provided covariance matrix.

### Method
POST

### Endpoint
/processing/doa_music

### Parameters
#### Request Body
- **covmat** (matrix) - Required - Covariance matrix of the received signal.
- **nsig** (int) - Required - Number of signals to detect.
- **spacing** (float) - Required - Element spacing in wavelengths.
- **scanangles** (array) - Required - Range of angles to scan.

### Response
#### Success Response (200)
- **doa_angles** (array) - Estimated angles of arrival.
- **spectrum** (array) - MUSIC pseudospectrum values.
```

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

### ROC Analysis API

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Utilities for calculating probability of detection (Pd) and required signal-to-noise ratio (SNR) for radar systems.

```APIDOC
## POST /tools/roc_pd

### Description
Calculates the probability of detection (Pd) given a specific SNR and target fluctuation model.

### Method
POST

### Endpoint
/tools/roc_pd

### Parameters
#### Request Body
- **pfa** (float) - Required - Probability of false alarm.
- **snr** (float) - Required - Signal-to-noise ratio in dB.
- **npulses** (int) - Required - Number of integrated pulses.
- **stype** (string) - Required - Target fluctuation model (e.g., 'Swerling 1').

### Response
#### Success Response (200)
- **pd** (float) - Calculated probability of detection.
```

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

### Range-Doppler Processing

Source: https://context7.com/radarsimx/radarsimpy/llms.txt

Perform signal processing on radar baseband data, including range FFT, Doppler FFT, and combined range-Doppler maps.

```APIDOC
## POST /processing/range_doppler_fft

### Description
Processes baseband radar data to generate a range-Doppler map using FFTs and window functions.

### Method
POST

### Endpoint
/processing/range_doppler_fft

### Parameters
#### Request Body
- **baseband** (array) - Required - Raw baseband signal data.
- **rwin** (array) - Optional - Window function for range FFT.
- **dwin** (array) - Optional - Window function for Doppler FFT.
- **rn** (int) - Optional - Range FFT size.
- **dn** (int) - Optional - Doppler FFT size.

### Request Example
{
  "baseband": ["..."],
  "rn": 512,
  "dn": 256
}

### Response
#### Success Response (200)
- **rd_map** (array) - The resulting range-Doppler map.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.