Pitfalls and troubleshooting
Serpent produces two types of error messages:
- Input errors, identified by text "Input error", followed by the error message. If the error can be related to a specific input parameter, then also the name of the parameter and the line number in the input file are printed.
- Run-time errors, in which case the name of the associated subroutine is printed, along with some additional information.
The first class of errors are (ideally) related to a problem in the input file. It should be noted, however, that the parameter name and line number may not reflect the original cause of the error, but rather the point where things started going wrong. Incorrectly typed input card names, for example, cause the parser to ignore the card altogether, and the following values are interpreted as entries belonging to the previous card.
Run-time errors should not occur, and they should always be reported to the developer team. This is also the case if the calculation crashes (segmentation fault or similar). In such case repeating the calculation in debug mode may reveal some additional information on what went wrong.
Serpent also produces a number of warning messages that may or may not be important. The code is pretty meticulous about errors, so problems let off with a warning are usually not too severe.
- 1 Things to check in case of suspicious results
- 2 Debugging the input model
Things to check in case of suspicious results
Material volumes are not necessarily needed for most transport simulations, but they do affect the results of burnup calculation. Serpent prints an error message if the volume of an irradiated material is not available. The most typical error related to volumes is that the code attempts to calculate the volumes of two-dimensional pin-structures automatically, but for some reason this calculation produces incorrect results. This happens, for example, when:
- The geometry has axial dimension (3D geometry is assumed to be 2D)
- Some parts of the fuel pins are located outside the geometry (pins are clipped by cell, universe or geometry boundary)
- When universe symmetries are used (unable to account for pins in symmetry positions)
Serpent cannot identify these problems, so no error message is printed.
Material volumes should always be checked using the Monte Carlo based volume checker routine before running the calculation. If the values are incorrect, or the calculation produces an error message on missing values, the volumes must be set manually.
Unresolved resonance probability table sampling
Unresolved resonance probability table sampling is not used by default. This method is needed to account for self-shielding effects in the unresolved resonance region. The effect is usually not significant in thermal systems, but can lead to noticeable discrepancies in fast-spectrum systems.
Probability table sampling is switched on using the set ures option.
The methodology for probability table sampling is not complete (as of version 2.1.25), and some nuclides contain data that cannot be processed by Serpent. In such case, a warning message is printed and smooth infinite-dilute cross sections are used instead. This is typical for natural elements, and may cause small discrepancies in results, e.g. when compared to MCNP.
Mass vs. atomic densities
The densities and compositions of materials can be entered in atomic or mass units (see the input syntax of the material card), and using incorrect units may lead to unexpected results. The difference may not be clearly noticeable if the material consists nuclides with similar atomic weight, but if there are both light and heavy nuclides the results can be off by tens of percent.
In particular, using incorrect units for isotopes in water causes a major distortion in the flux spectrum in LWR calculations. In burnup calculation this results in completely unexpected depletion rate of 235U and build-up rate of 239Pu.
The material and nuclide densities used in the calculation can be checked from the nuclide and material output file ([input].out).
MPI parallelization without MPI mode
MPI scripts such as mpirun allow running Serpent even if the source code was not complied in MPI mode. Instead of starting a single parallel simulation, the result is multiple independent simulations that read and write the same input and output files. If two or more writing operations happen to overlap, identical sections are repeated in the output files. If the tasks are sufficiently off-sync, the writing operations do not overlap, and it may actually seem like everything is OK - the correct number of CPU's are working and the results look reasonable. The only thing that seems to be wrong is that the running time does not reflect the speed-up expected from the parallelization.
When MPI parallelization is executed correctly, the run-time output shows the number of mpi tasks, for example (MPI=10). The number of tasks is also printed in variable MPI_TASKS in the main output file ([input]_res.m). Whether the source code was compiled in MPI mode or not can be checked with sss2 -version.
Unable to start or maintain criticality source simulation
Criticality source simulation requires an initial guess for the fission source distribution. If no source definition is provided, Serpent samples source points uniformly throughout all fissile materials, i.e. materials with fissile isotopes. This creates two potential problems:
- If the fissile material covers only a small volume of the total geometry, the sampling of the initial source may fail completely.
- If the geometry contains both active and inactive fissile zones (e.g. seed and blanket), the calculation may fail after the first generation because the majority of source points are placed in the inactive zone.
The solution to both problems is to use explicit source definition that puts sufficient number of points in the active parts of the fuel. It should be noted that the use of an explicit source definition does not affect the results of the simulations, provided that the fission source is allowed to converge by skipping a sufficient number of inactive neutron generations.
Low production rate of higher actinides in burnup calculation
Serpent forms the transmutation paths for burnup calculation automatically, starting from the initial composition defined in the material input. To avoid including everything available, the procedure applies a cut-off that after a certain chain length discards all neutron reactions. The result is that some higher actinides, in particular berkelium and californium isotopes, are not produced through all possible chains, and some isotopes may not be included in the calculation at all.
Discarding these higher actinides should have a negligible effect on the results of the calculation, but in some cases their concentrations are of particular interest. The transmutation chains can be extended further by adding nuclides at zero concentration in the material compositions. Including isotopes 240Cm to 250Cm, 247Bk to 250Bk and 249Cf to 254Cf Should force Serpent to include the necessary data for the high end of the actinide transmutation chains.
Serpent handles reflective and periodic boundary conditions different from other Monte Carlo codes. Instead of stopping the particle at the boundary surface, reflections and translations are handled by coordinate transformations. This poses some limitations to how repeated boundary conditions can be used. For more information, see detailed description on Boundary conditions.
Debugging the input model
Error and warning messages
Serpent prints out two types of error and two types of warning messages. Input errors, such as:
***** Thu Feb 25 14:53:56 2016 Input error in parameter "cell" on line 8 in file "geometry.inp": Surface s1 is not defined
indicate that there is some identified problem in the input model, and it is up to the user to fix it. The message is often (but not always) accompanied by the name of an input parameter, and the file name and line number where this parameter was defined. Potential problems that do not require immediate termination of the calculation are notified with a warning message, such as:
***** Warning: Nest FUE1 is not used in geometry
These warnings may or may not be related to actual problems, and they can often be ignored.
Fatal errors in the calculation routines produce messages of type:
***** Thu Feb 25 15:05:16 2016: - MPI task = 0 - OpenMP thread = 0 - RNG parent seed = 1456405516 Fatal error in function LevelScattering: Now, I am become Death, the destroyer of worlds! Simulation aborted.
In addition to an ominous (and often unintelligible) error message, the code prints the name of a subroutine and some additional debug information. These errors should not occur at all, and it is important that they are reported to the Serpent developer team (preferably by writing to the Serpent discussion forum). There are also warning messages that include the name of a subroutine, such as:
***** Mon Feb 22 19:34:30 2016 (seed = 1456162439) Warning message from function CheckNuclideData: Stable nuclide 40096.09c has 1 decay modes
These messages are related to suspicious values or other problems in the input data or calculation routines, that may affect the outcome of the simulation, but do not require immediate termination. It is not uncommon that the code prints several warning messages, especially in burnup calculation, and usually they can be ignored. Serpent is still a developing code, and several potential problems, that may not turn out to be problems after all, are checked. This is especially the case when the code is run in the DEBUG mode.
Running the calculation in DEBUG mode
When the calculation crashes or produces completely unrealistic results despite no evident problems in the input, it is advised to repeat the calculation in the DEBUG mode. Since this requires recompiling the source code, it is good practice to keep two separate executables available at all times.
The DEBUG mode switches on several pointer and value checks, which are likely to catch the root cause of the error early on. Performing this check before reporting the error helps tracing the problem. It should be noted, however, that the calculation runs significantly slower when compiled in the DEBUG mode (by a factor of two or more). When compiled in this mode the code prints text "DBG" in the run-time output log.