In general, to fix this kind of problem you must ensure that at least one operand of the multiplication is explicitly cast to the larger integer type before the multiplication, so the operation is carried out in that larger type and cannot overflow a smaller intermediate type.

Here, the problematic expression is on line 94:

const size_t nTotalDonors = (nSpanDonor + 1) * size; // Number of donor spans across all ranks

Assuming nSpanDonor and size are of (possibly signed) integer type smaller than or equal to int, the best fix is to cast one operand to size_t before the multiplication. This promotes the entire expression to size_t arithmetic and avoids intermediate int overflow without changing semantics for in‑range values.

The minimal, non‑intrusive change is to rewrite line 94 as:

const size_t nTotalDonors = static_cast<size_t>(nSpanDonor + 1) * static_cast<size_t>(size);

or, more compactly (and still safe):

const size_t nTotalDonors = static_cast<size_t>(nSpanDonor + 1) * size;

Since size is already used in other multiplications with size_t (e.g., indexing with static_cast<size_t>(iSize) * nSpanDonorVars), promoting the (nSpanDonor + 1) side is sufficient. No new headers or helper functions are needed.

Similarly, for consistency and to avoid the same class of issue, we should also ensure that other multiplications that feed into size_t or unsigned long are performed in a wide type. In the snippet, line 95:

const size_t nSpanDonorVars = (nSpanDonor + 1) * nMixingVars;

also multiplies two small integer types (likely unsigned short/int) and stores the result in size_t. It should be updated to ensure the multiplication is done in size_t:

const size_t nSpanDonorVars = static_cast<size_t>(nSpanDonor + 1) * static_cast<size_t>(nMixingVars);

No additional methods, imports, or definitions are required; we only add static_cast<size_t> in the existing lines.

In general, to fix this class of problems you must ensure that at least one operand of the multiplication is explicitly converted to the larger integer type before the multiplication occurs. That forces the entire arithmetic operation to be performed in the wider type, preventing overflow that would otherwise happen in the narrower type.

In this specific case, nSpanDonorVars is declared as const size_t, but the RHS (nSpanDonor + 1) * nMixingVars is computed using the usual integer promotions (likely int). To fix it without changing functionality, we cast one operand to size_t, e.g. static_cast<size_t>(nSpanDonor + 1) or static_cast<size_t>(nMixingVars), so that the multiplication is performed in size_t. This keeps the logical meaning identical for all values that already fit in int, but makes the code safe and well‑defined for larger values.

Concretely, in SU2_CFD/src/interfaces/cfd/CMixingPlaneInterface.cpp, at the line where nSpanDonorVars is defined (line 95 in your snippet), change:

const size_t nSpanDonorVars = (nSpanDonor + 1) * nMixingVars;

to:

const size_t nSpanDonorVars = static_cast<size_t>(nSpanDonor + 1) * nMixingVars;

This does not require any new includes or other structural changes. The rest of the code that uses nSpanDonorVars (e.g., in the Allgather call and indexing into buffDonorVar) already expects a size_t, so no further modifications are necessary.