Setting Simulation Parameters for a Radar

The following procedure helps you configure the simulation parameters for a radar sensor in the simulation parameters JSON file.

In this procedure many steps are optional because most of the radar simulation parameters are optional.

The optional parameters without default values are optional parameters both in the JSON file and for the simulation.

The optional parameters with default values are optional in the JSON but required for the simulation. When such parameters are not present in the JSON file, the default value will apply.

For more details about each parameter, see Radar Simulation Parameters.

To set the simulations parameters for a radar:

Prerequisites:

You have prepared the simulation parameters json file.

Use the reader function on your *.sencfgx file to:

get the ID of the sensor (which corresponds to the name given for the sensor in the sensor layout (*.sencfgx file).
make sure that the sensor is compatible with AVX and executable in AVX simulation.

Inside the sensorSimulationParameters section, add a subsection with the minimal content for a radar sensor:

{
"identifier": "identifier of your radar",
    "radarSimulation": {
        "numberOfRayReflections": 3,
        "numberOfRayTransmissions": 1,
        "gridSampling": {
            "globalSampling": {
                "raySpacing": 30
            }
        }
    }
}

Specify the identifier of the sensor for which you are setting the simulation parameters.
If you want to specify a delay for the start of a sensor simulation, particularly in the case of a multi-sensor configuration, specify the startOffset.
```
"startOffset": 10,
```
If you want to configure the way in which sensor data is stored:
1. add the following section:
```
"dataAccessSettings": {},
```
2. If you want to output the radar simulation results on disk, in dataAccessSettings, add the following subsection and set the radarRecordingFormat to TEXT or PROTOBUF:
```
"recordingFormat": {
  "radarRecordingFormat": "PROTOBUF"
},
```
3. If you do not want the data produced by the sensor during the simulation to be stored in shared memory, in the dataAccessSettings section include the sharedMemoryAccess parameter and set its value to false.
If you want this sensor process to be executed on a deploy host (in the context of a multi-machine simulation): add the deployNodeId parameter and set the identifier of a deploy node which is defined in the Deploy Parameters for the deploy host.

Important: When a deploy node ID is set for a sensor in its simulation parameters, make sure that the GPU you define and the deploy node belong to the same deploy host.
In radarSimulation, define the required parameters.
1. For numberOfRayReflections, set the maximum number of reflections that are allowed before the ray is sent back to the sensor. This parameter is useful to prevent the ray from having too many interactions and reduce its propagation capacity.
2. For numberOfRayTransmissions, set the maximum number of transmissions that are allowed before the ray is sent back to the sensor. This parameter is useful to prevent the ray from having too many interactions and reduce its propagation capacity.
3. For gridSampling:
  1. specify the globalSampling and set the raySpacing parameter to define the ray spacing to apply to the entire scene.
```
"gridSampling": {
  "globalSampling": {
    "raySpacing": 30
  }
}
```
  2. if you want to specify an adaptive sampling with specific ray spacings for the detection of tagged objects, inside gridSampling add the adaptiveSampling parameter, and include each tag and its associated raySpacing parameter.
```
"adaptiveSampling": {
  "Wheel": {
    "raySpacing": 0.01
  },
  "Vehicle": {
    "raySpacing": 0.1
  }
}
```
    Note: Ray spacing values assigned to tags belonging to the same hierarchy of objects must be coherent. ¹
If you want to specify the maximum ray path length per mode:
1. Add the maxRayPathLengthByMode parameter inside the radarSimulation section.
2. Specify the maximum ray path length in meters for each mode in the radar. For example:
```
"maxRayPathLengthByMode": {
  "0": 100,
  "1": 150
}
```
  Note: In the current release, this parameter can only be applied to Arbitrary Pulse Doppler or Arbitrary FMCW waveforms.
If you want to specify the maximum velocity per mode:
1. Add the maxVelocityByMode parameter inside the radarSimulation section.
2. Specify the velocity in meters per second for each mode in the radar. For example:
```
"maxVelocityByMode": {
  "0": 55,
  "1": 65
}
```
  Note: In the current release, this parameter can only be applied to Arbitrary Pulse Doppler or Arbitrary FMCW waveforms.
If you want the geometry of the Ego vehicle to be taken into account in calculations when the rays hit the Ego vehicle on the first bounce, add the following parameter inside the radarSimulation section:
```
"egoVehicleEmissionBlockage": true
```
Note: By default (when this parameter is not present or when it is set to fasle), the ego vehicle geometry is not considered in calculations when it is hit by the rays on the first bounce.

Note: Activating this parameter may affect the accuracy of the radar results.
If you want to generate debug view images:
1. add the following section inside the radarSimulation section:
```
"debugViewParameters": {}
```
2. inside the debugViewParameters section, you can add the colorMode parameter and set its value according to the characteristics of the objects you want to highlight:
  - BLACKWHITE: creates the image by coloring according to the angles of incidence between the surfaces in the radar's field of view and viewing direction. (default color mode)
  - COATING: creates the image by coloring according to the dielectric properties of the materials detected by the radar.
  - VELOCITY: creates the image by coloring according to the relative velocity of the objects in the radar's field of view.
  - NORMAL: creates the image by coloring the normal of a surface and converting the color to RGB.
3. if you want to define the width of the debug view images, add the imageWidth and set its value in pixels.
4. if you want to define the gray level of the debug view's image background, add the backgroundGrayLevel parameter and set its value.
5. when the colorMode set to COATING, if you want to add shading to the images from the debug view, add the following parameter:
```
"enableMaterialShading": true 
```
6. if you want to define the oversample value to control the rasterization density in the debug view images, add the overSampling parameter and set its value.
If you want to generate a tx waveform report (at first frame, then each time radar parameters are changed through the feedback control), add the following parameter inside the radarSimulation section:
```
"txWaveformReport": true
```
If you want to activate the radar batching, add one of the following subsections inside the radarSimulation section :
- for manual batching: "manualBatching": {}
- for automatic batching: "automaticBatching": {}
If you added the automaticBatching subsection, you have to configure the automatic batching parameters:
1. add the maxNumberOfRayBatches parameter and set its value to define the maximal number of sequences used to send the total number of rays.
2. add one of the following parameters to the automaticBatching subsection:
- gpuMemoryQuota then define the maximum percentage of GPU memory to be allocated to the radar simulation execution on the default GPU,
- gpuQuotas then define the maximal percentage of the GPU memory for each available GPU
If you added the manualBatching subsection, you have to configure the manual batching parameters:
1. add the following content to the manualBatching subsection:
```
"manualBatching": {
  "numberOfRayBatches": 1,
  "rxBatching":[
    {
    "modeId": 0,
    "numberOfRxBatches": 4
    }
  ]
}
```
2. in numberOfRayBatches, define the number of sequences used to send the total number of rays.
  
  Note: The default value is 1.
3. in rxBatching, for each mode define:
  - the radar mode ID in modeId
  - the number of batches used to execute the total number of receiving antennas in the mode in numberOfRxBatches
4. if you want to define the specific GPU to assign to the execution of each mode of the radar, add the gpuByModes parameter. For example:
```
"gpuByModes": { 
  "0": "local GPU RTX A5000",
  "1": "local GPU RTX A6000"
}
```
If you need to simulate a radar sensor with a high number of antennas and retrieve the output data through the Sensor Data Access service of the AVxcelerate Sensors Simulator APIs or via dumped protobuf files, set the output splitting mode, either per mode or per transmitter. To do so:
1. add the following section after the closing bracket of the radarSimulation section:
```
"outputSplitting": {
  "radarOutputSplitting": {
    "radarOutputSplittingLevel": "TRANSMITTER"
    }
}
```
2. set the value to TRANSMITTER or to MODE.
Validate the content of the file against JSON specifications to check its well-formedness.