openmc-dev / openmc / 30082591782

#include "openmc/random_ray/flat_source_domain.h"

#include "openmc/cell.h"

#include "openmc/constants.h"

#include "openmc/eigenvalue.h"

#include "openmc/geometry.h"

#include "openmc/material.h"

#include "openmc/message_passing.h"

#include "openmc/mgxs_interface.h"

#include "openmc/output.h"

#include "openmc/plot.h"

#include "openmc/random_ray/decomposition_map.h"

#include "openmc/random_ray/random_ray.h"

#include "openmc/simulation.h"

#include "openmc/tallies/filter.h"

#include "openmc/tallies/tally.h"

#include "openmc/tallies/tally_scoring.h"

#include "openmc/timer.h"

#include "openmc/weight_windows.h"

#include <cstdio>

#include <numeric>

namespace openmc {

//==============================================================================

// FlatSourceDomain implementation

//==============================================================================

// Static Variable Declarations

RandomRayVolumeEstimator FlatSourceDomain::volume_estimator_ {

  RandomRayVolumeEstimator::HYBRID};

bool FlatSourceDomain::volume_normalized_flux_tallies_ {false};

bool FlatSourceDomain::adjoint_requested_ {false};

RandomRaySolve FlatSourceDomain::solve_ {RandomRaySolve::FORWARD};

bool FlatSourceDomain::fw_cadis_local_ {false};

double FlatSourceDomain::diagonal_stabilization_rho_ {1.0};

std::unordered_map<int, vector<std::pair<Source::DomainType, int>>>

  FlatSourceDomain::mesh_domain_map_;

std::vector<size_t> FlatSourceDomain::fw_cadis_local_targets_;

{

  // Count the number of source regions, compute the cell offset

  // indices, and store the material type The reason for the offsets is that

  // some cell types may not have material fills, and therefore do not

  // produce FSRs. Thus, we cannot index into the global arrays directly

    } else {

    }

  }

  // Initialize source regions.

  // Initialize tally volumes

      //  Get the shape of the 3D result tensor

      // Create a new 2D tensor with the same size as the first

      // two dimensions of the 3D tensor

  }

  // Compute simulation domain volume based on ray source

{

// Reset scalar fluxes and iteration volume tallies to zero

  }

  }

{

  }

{

  // Reset all source regions to zero (important for void regions)

  }

  // Add scattering + fission source

      (material * ntemperature_ + temp) * negroups_ * negroups_;

        }

      }

    }

  }

  // Add external source if in fixed source mode

    }

  }

// Compute new estimate of scattering + fission sources in each source region

// based on the flux estimate from the previous iteration.

{

  }

// Normalizes flux and updates simulation-averaged volume estimate

  double total_active_distance_per_iteration)

{

// Normalize scalar flux to total distance travelled by all rays this

// iteration

  }

// Accumulate cell-wise ray length tallies collected this iteration, then

// update the simulation-averaged cell-wise volume estimates

    }

  }

  int64_t sr, double volume, int g)

{

    }

  } else {

  }

{

{

// Combine transport flux contributions and flat source contributions from the

// previous iteration to generate this iteration's estimate of scalar flux.

{

    // Increment the number of hits if cell was hit this iteration

    }

    // Set the SR to small status if its expected number of hits

    // per iteration is less than 1.5

    } else {

    }

    // The volume treatment depends on the volume estimator type

    // and whether or not an external source is present in the cell.

    case RandomRayVolumeEstimator::NAIVE:

      volume = volume_iteration;

      break;

        volume = volume_iteration;

      } else {

        volume = volume_simulation_avg;

      }

      break;

    default:

      fatal_error("Invalid volume estimator type");

    }

      // There are three scenarios we need to consider:

        // 1. If the FSR was hit this iteration, then the new flux is equal to

        // the flat source from the previous iteration plus the contributions

        // from rays passing through the source region (computed during the

        // transport sweep)

        // 2. If the FSR was not hit this iteration, but has been hit some

        // previous iteration, then we need to make a choice about what

        // to do. Naively we will usually want to set the flux to be equal

        // to the reduced source. However, in fixed source problems where

        // there is a strong external source present in the cell, and where

        // the cell has a very low cross section, this approximation will

        // cause a huge upward bias in the flux estimate of the cell (in these

        // conditions, the flux estimate can be orders of magnitude too large).

        // Thus, to avoid this bias, if any external source is present

        // in the cell we will use the previous iteration's flux estimate. This

        // injects a small degree of correlation into the simulation, but this

        // is going to be trivial when the miss rate is a few percent or less.

        } else {

        }

      }

      // Halt if NaN implosion is detected

        fatal_error("A source region scalar flux is not finite. "

                    "This indicates a numerical instability in the "

                    "simulation. Consider increasing ray density or adjusting "

                    "the source region mesh.");

      }

    }

  }

  // Return the number of source regions that were hit this iteration

}

// Generates new estimate of k_eff based on the differences between this

// iteration's estimate of the scalar flux and the last iteration's estimate.

{

  // Vector for gathering fission source terms for Shannon entropy calculation

    // If simulation averaged volume is zero, don't include this cell

      continue;

    }

      continue;

    }

    double sr_fission_source_old = 0;

    double sr_fission_source_new = 0;

    }

    // Compute total fission rates in FSR

    // Accumulate totals

    // Store total fission rate in the FSR for Shannon calculation

  }

  // Sum up fission rates across all ranks

#ifdef OPENMC_MPI

      MPI_IN_PLACE, &fission_rate_old, 1, MPI_DOUBLE, MPI_SUM, mpi::intracomm);

      MPI_IN_PLACE, &fission_rate_new, 1, MPI_DOUBLE, MPI_SUM, mpi::intracomm);

  }

#endif

  // defining an inverse sum for better performance

    // Only if FSR has non-negative and non-zero fission source

      // Normalize to total weight of bank sites. p_i for better performance

      // Sum values to obtain Shannon entropy.

    }

  }

#ifdef OPENMC_MPI

    } else {

    }

  }

#endif

  // Adds entropy value to shared entropy vector in openmc namespace.

// This function is responsible for generating a mapping between random

// ray flat source regions (cell instances) and tally bins. The mapping

// takes the form of a "TallyTask" object, which accounts for one single

// score being applied to a single tally. Thus, a single source region

// may have anywhere from zero to many tally tasks associated with it ---

// meaning that the global "tally_task" data structure is in 2D. The outer

// dimension corresponds to the source element (i.e., each entry corresponds

// to a specific energy group within a specific source region), and the

// inner dimension corresponds to the tallying task itself. Mechanically,

// the mapping between FSRs and spatial filters is done by considering

// the location of a single known ray midpoint that passed through the

// FSR. I.e., during transport, the first ray to pass through a given FSR

// will write down its midpoint for use with this function. This is a cheap

// and easy way of mapping FSRs to spatial tally filters, but comes with

// the downside of adding the restriction that spatial tally filters must

// share boundaries with the physical geometry of the simulation (so as

// not to subdivide any FSR). It is acceptable for a spatial tally region

// to contain multiple FSRs, but not the other way around.

// TODO: In future work, it would be preferable to offer a more general

// (but perhaps slightly more expensive) option for handling arbitrary

// spatial tallies that would be allowed to subdivide FSRs.

// Besides generating the mapping structure, this function also keeps track

// of whether or not all flat source regions have been hit yet. This is

// required, as there is no guarantee that all flat source regions will

// be hit every iteration, such that in the first few iterations some FSRs

// may not have a known position within them yet to facilitate mapping to

// spatial tally filters. However, after several iterations, if all FSRs

// have been hit and have had a tally map generated, then this status will

// be passed back to the caller to alert them that this function doesn't

// need to be called for the remainder of the simulation.

// It takes as an argument the starting index in the source region array,

// and it will operate from that index until the end of the array. This

// is useful as it can be called for both explicit user source regions or

// when a source region mesh is overlaid.

{

  // Tracks if we've generated a mapping yet for all source regions.

// Attempt to generate mapping for all source regions

    // If this source region has not been hit by a ray yet, then

    // we aren't going to be able to map it, so skip it.

      all_source_regions_mapped = false;

      continue;

    }

    // A particle located at the recorded midpoint of a ray

    // crossing through this source region is used to estabilish

    // the spatial location of the source region

    // Loop over energy groups (so as to support energy filters)

      // Set particle to the current energy

      // If this task has already been populated, we don't need to do

      // it again.

        continue;

      }

      // Loop over all active tallies. This logic is essentially identical

      // to what happens when scanning for applicable tallies during

      // MC transport.

        // Initialize an iterator over valid filter bin combinations.

        // If there are no valid combinations, use a continue statement

        // to ensure we skip the assume_separate break below.

        // Loop over filter bins.

          auto filter_index = filter_iter.index_;

          // Loop over scores

            // If a valid tally, filter, and score combination has been found,

            // then add it to the list of tally tasks for this source element.

            // Also add this task to the list of volume tasks for this source

            // region.

          }

        }

      }

      // Reset all the filter matches for the next tally event.

    }

// Set the volume accumulators to zero for all tallies

{

    }

  }

// In fixed source mode, due to the way that volumetric fixed sources are

// converted and applied as volumetric sources in one or more source regions,

// we need to perform an additional normalization step to ensure that the

// reported scalar fluxes are in units per source neutron. This allows for

// direct comparison of reported tallies to Monte Carlo flux results.

// This factor needs to be computed at each iteration, as it is based on the

// volume estimate of each FSR, which improves over the course of the

// simulation

{

  // Eigenvalue mode normalization

    // Normalize fluxes by total number of fission neutrons produced. This

    // ensures consistent scaling of the eigenvector such that its magnitude is

    // comparable to the eigenvector produced by the Monte Carlo solver.

    // Multiplying by the eigenvalue is unintuitive, but it is necessary.

    // If the eigenvalue is 1.2, per starting source neutron, you will

    // generate 1.2 neutrons. Thus if we normalize to generating only ONE

    // neutron in total for the whole domain, then we don't actually have enough

    // flux to generate the required 1.2 neutrons. We only know the flux

    // required to generate 1 neutron (which would have required less than one

    // starting neutron). Thus, you have to scale the flux up by the eigenvalue

    // such that 1.2 neutrons are generated, so as to be consistent with the

    // bookkeeping in MC which is all done per starting source neutron (not per

    // neutron produced).

  }

  // If we are in adjoint mode of a fixed source problem, the external

  // source is already normalized, such that all resulting fluxes are

  // also normalized.

    return 1.0;

  }

  // Fixed source mode normalization

  // Step 1 is to sum over all source regions and energy groups to get the

  // total external source strength in the simulation.

      // For non-void regions, we store the external source pre-divided by

      // sigma_t. We need to multiply non-void regions back up by sigma_t

      // to get the total source strength in the expected units.

      }

    }

  }

#ifdef OPENMC_MPI

      MPI_DOUBLE, MPI_SUM, mpi::intracomm);

  }

#endif

  // Step 2 is to determine the total user-specified external source strength

  }

  // The correction factor is the ratio of the user-specified external source

  // strength to the simulation external source strength.

}

// Tallying in random ray is not done directly during transport, rather,

// it is done only once after each power iteration. This is made possible

// by way of a mapping data structure that relates spatial source regions

// (FSRs) to tally/filter/score combinations. The mechanism by which the

// mapping is done (and the limitations incurred) is documented in the

// "convert_source_regions_to_tallies()" function comments above. The present

// tally function simply traverses the mapping data structure and executes

// the scoring operations to OpenMC's native tally result arrays.

{

  // Reset our tally volumes to zero

// We loop over all source regions and energy groups. For each

// element, we check if there are any scores needed and apply

// them.

    // The fsr.volume_ is the unitless fractional simulation averaged volume

    // (i.e., it is the FSR's fraction of the overall simulation volume). The

    // simulation_volume_ is the total 3D physical volume in cm^3 of the

    // entire global simulation domain (as defined by the ray source box).

    // Thus, the FSR's true 3D spatial volume in cm^3 is found by multiplying

    // its fraction of the total volume by the total volume. Not important in

    // eigenvalue solves, but useful in fixed source solves for returning the

    // flux shape with a magnitude that makes sense relative to the fixed

    // source strength.

      // Determine numerical score value

        case SCORE_TOTAL:

            score =

              flux * volume *

              sigma_t_[(material * ntemperature_ + temp) * negroups_ + g] *

              density_mult;

          }

          break;

              density_mult;

          }

          break;

              density_mult;

          }

          break;

        case SCORE_EVENTS:

          score = 1.0;

          break;

            density_mult;

        default:

          fatal_error("Invalid score specified in tallies.xml. Only flux, "

                      "total, fission, nu-fission, kappa-fission, and events "

                      "are supported in random ray mode.");

        }

        // Apply score to the appropriate tally bin

#pragma omp atomic

          score;

      }

    }

    // For flux tallies, the total volume of the spatial region is needed

    // for normalizing the flux. We store this volume in a separate tensor.

    // We only contribute to each volume tally bin once per FSR.

#pragma omp atomic

            volume;

        }

      }

    }

  } // end FSR loop

  // Normalize any flux scores by the total volume of the FSRs scoring to that

  // bin. To do this, we loop over all tallies, and then all filter bins,

  // and then scores. For each score, we check the tally data structure to

  // see what index that score corresponds to. If that score is a flux score,

  // then we divide it by volume.

#ifdef OPENMC_MPI

          mpi::intracomm);

      }

    }

#endif

            }

          }

        }

      }

    }

  }

  Position r, int64_t sr, int g) const

{

}

// Outputs all basic material, FSR ID, multigroup flux, and

// fission source data to .vtk file that can be directly

// loaded and displayed by Paraview. Note that .vtk binary

// files require big endian byte ordering, so endianness

// is checked and flipped if necessary.

{

  // Rename .h5 plot filename(s) to .vtk filenames

  }

  // Print header information

  // Outer loop over plots

    // Get handle to OpenMC plot object and extract params

    // Random ray plots only support voxel plots

                          "is allowed in random ray mode.",

        plt));

                          "is allowed in random ray mode.",

        plt));

    }

    // Tag plots written during the forward solve of an adjoint run

    }

    // Perform sanity checks on file size

              "slow.");

    }

    // Relate voxel spatial locations to random ray source regions

#pragma omp parallel for collapse(3) reduction(min : min_weight)

          Position sample;

          sample.z = ll.z + z_delta / 2.0 + z * z_delta;

          sample.y = ll.y + y_delta / 2.0 + y * y_delta;

          sample.x = ll.x + x_delta / 2.0 + x * x_delta;

          p.r_last() = sample;

          p.E() = 1.0;

          p.E_last() = 1.0;

            voxel_indices_key[z * Ny * Nx + y * Nx + x] = {-1, -1};

            voxel_indices[z * Ny * Nx + y * Nx + x] = -1;

            voxel_positions[z * Ny * Nx + y * Nx + x] = sample;

            weight_windows[z * Ny * Nx + y * Nx + x] = 0.0;

            continue;

          }

          int64_t sr = -1;

            sr = it->second;

          }

          voxel_indices[z * Ny * Nx + y * Nx + x] = sr;

          voxel_positions[z * Ny * Nx + y * Nx + x] = sample;

            auto [ww_found, ww] =

            float weight = ww.lower_weight;

              min_weight = weight;

          }

        }

      }

    }

    // Open file for writing

    // Write vtk metadata