mirror of
https://github.com/openmc-dev/openmc.git
synced 2026-07-27 13:45:36 -04:00
Merge branch 'develop' into heat-photon-kerma
This commit is contained in:
liangjg
commit
ba05630a08
33 changed files with 109 additions and 495 deletions
|
|
@ -1,5 +1,5 @@
|
|||
cmake_minimum_required(VERSION 3.3 FATAL_ERROR)
|
||||
project(openmc CXX)
|
||||
project(openmc C CXX)
|
||||
|
||||
# Setup output directories
|
||||
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
|
||||
|
|
@ -26,7 +26,7 @@ option(dagmc "Enable support for DAGMC (CAD) geometry" OFF)
|
|||
|
||||
set(MPI_ENABLED FALSE)
|
||||
if($ENV{CXX} MATCHES "(mpi[^/]*|CC)$")
|
||||
message("-- Detected MPI wrapper: $ENV{CXX}")
|
||||
message(STATUS "Detected MPI wrapper: $ENV{CXX}")
|
||||
set(MPI_ENABLED TRUE)
|
||||
endif()
|
||||
|
||||
|
|
@ -35,9 +35,6 @@ endif()
|
|||
#===============================================================================
|
||||
if(dagmc)
|
||||
find_package(DAGMC REQUIRED)
|
||||
if(NOT DAGMC_FOUND)
|
||||
message(FATAL_ERROR "Could not find DAGMC installation")
|
||||
endif()
|
||||
link_directories(${DAGMC_LIBRARY_DIRS})
|
||||
endif()
|
||||
|
||||
|
|
@ -63,15 +60,12 @@ if(NOT DEFINED HDF5_PREFER_PARALLEL)
|
|||
endif()
|
||||
endif()
|
||||
|
||||
find_package(HDF5 COMPONENTS HL)
|
||||
if(NOT HDF5_FOUND)
|
||||
message(FATAL_ERROR "Could not find HDF5")
|
||||
endif()
|
||||
find_package(HDF5 REQUIRED COMPONENTS C HL)
|
||||
if(HDF5_IS_PARALLEL)
|
||||
if(NOT MPI_ENABLED)
|
||||
message(FATAL_ERROR "Parallel HDF5 must be used with MPI.")
|
||||
endif()
|
||||
message("-- Using parallel HDF5")
|
||||
message(STATUS "Using parallel HDF5")
|
||||
endif()
|
||||
|
||||
#===============================================================================
|
||||
|
|
@ -95,7 +89,7 @@ if(debug)
|
|||
list(APPEND cxxflags -g -O0)
|
||||
endif()
|
||||
if(profile)
|
||||
list(APPEND cxxflags -pg)
|
||||
list(APPEND cxxflags -g -fno-omit-frame-pointer)
|
||||
endif()
|
||||
if(optimize)
|
||||
list(REMOVE_ITEM cxxflags -O2)
|
||||
|
|
@ -103,8 +97,8 @@ if(optimize)
|
|||
endif()
|
||||
|
||||
# Show flags being used
|
||||
message(STATUS "C++ flags: ${cxxflags}")
|
||||
message(STATUS "Linker flags: ${ldflags}")
|
||||
message(STATUS "OpenMC C++ flags: ${cxxflags}")
|
||||
message(STATUS "OpenMC Linker flags: ${ldflags}")
|
||||
|
||||
#===============================================================================
|
||||
# pugixml library
|
||||
|
|
@ -146,7 +140,7 @@ set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
|
|||
# the RPATH to be used when installing, but only if it's not a system directory
|
||||
list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)
|
||||
if("${isSystemDir}" STREQUAL "-1")
|
||||
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
|
||||
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
|
||||
endif()
|
||||
|
||||
#===============================================================================
|
||||
|
|
@ -276,8 +270,8 @@ endif()
|
|||
|
||||
# target_link_libraries treats any arguments starting with - but not -l as
|
||||
# linker flags. Thus, we can pass both linker flags and libraries together.
|
||||
target_link_libraries(libopenmc ${ldflags} ${HDF5_LIBRARIES} pugixml
|
||||
faddeeva xtensor)
|
||||
target_link_libraries(libopenmc ${ldflags} ${HDF5_LIBRARIES} ${HDF5_HL_LIBRARIES}
|
||||
pugixml faddeeva xtensor)
|
||||
|
||||
if(dagmc)
|
||||
target_compile_definitions(libopenmc PRIVATE DAGMC)
|
||||
|
|
|
|||
|
|
@ -1,399 +0,0 @@
|
|||
#.rst:
|
||||
# FindHDF5
|
||||
# --------
|
||||
#
|
||||
# Find HDF5, a library for reading and writing self describing array data.
|
||||
#
|
||||
#
|
||||
#
|
||||
# This module invokes the HDF5 wrapper compiler that should be installed
|
||||
# alongside HDF5. Depending upon the HDF5 Configuration, the wrapper
|
||||
# compiler is called either h5cc or h5pcc. If this succeeds, the module
|
||||
# will then call the compiler with the -show argument to see what flags
|
||||
# are used when compiling an HDF5 client application.
|
||||
#
|
||||
# The module will optionally accept the COMPONENTS argument. If no
|
||||
# COMPONENTS are specified, then the find module will default to finding
|
||||
# only the HDF5 C library. If one or more COMPONENTS are specified, the
|
||||
# module will attempt to find the language bindings for the specified
|
||||
# components. The only valid components are C, CXX, Fortran, HL, and
|
||||
# Fortran_HL. If the COMPONENTS argument is not given, the module will
|
||||
# attempt to find only the C bindings.
|
||||
#
|
||||
# On UNIX systems, this module will read the variable
|
||||
# HDF5_USE_STATIC_LIBRARIES to determine whether or not to prefer a
|
||||
# static link to a dynamic link for HDF5 and all of it's dependencies.
|
||||
# To use this feature, make sure that the HDF5_USE_STATIC_LIBRARIES
|
||||
# variable is set before the call to find_package.
|
||||
#
|
||||
# To provide the module with a hint about where to find your HDF5
|
||||
# installation, you can set the environment variable HDF5_ROOT. The
|
||||
# Find module will then look in this path when searching for HDF5
|
||||
# executables, paths, and libraries.
|
||||
#
|
||||
# In addition to finding the includes and libraries required to compile
|
||||
# an HDF5 client application, this module also makes an effort to find
|
||||
# tools that come with the HDF5 distribution that may be useful for
|
||||
# regression testing.
|
||||
#
|
||||
# This module will define the following variables:
|
||||
#
|
||||
# ::
|
||||
#
|
||||
# HDF5_INCLUDE_DIRS - Location of the hdf5 includes
|
||||
# HDF5_INCLUDE_DIR - Location of the hdf5 includes (deprecated)
|
||||
# HDF5_DEFINITIONS - Required compiler definitions for HDF5
|
||||
# HDF5_C_LIBRARIES - Required libraries for the HDF5 C bindings.
|
||||
# HDF5_CXX_LIBRARIES - Required libraries for the HDF5 C++ bindings
|
||||
# HDF5_Fortran_LIBRARIES - Required libraries for the HDF5 Fortran bindings
|
||||
# HDF5_HL_LIBRARIES - Required libraries for the HDF5 high level API
|
||||
# HDF5_Fortran_HL_LIBRARIES - Required libraries for the high level Fortran
|
||||
# bindings.
|
||||
# HDF5_LIBRARIES - Required libraries for all requested bindings
|
||||
# HDF5_FOUND - true if HDF5 was found on the system
|
||||
# HDF5_VERSION - HDF5 version in format Major.Minor.Release
|
||||
# HDF5_LIBRARY_DIRS - the full set of library directories
|
||||
# HDF5_IS_PARALLEL - Whether or not HDF5 was found with parallel IO support
|
||||
# HDF5_C_COMPILER_EXECUTABLE - the path to the HDF5 C wrapper compiler
|
||||
# HDF5_CXX_COMPILER_EXECUTABLE - the path to the HDF5 C++ wrapper compiler
|
||||
# HDF5_Fortran_COMPILER_EXECUTABLE - the path to the HDF5 Fortran wrapper compiler
|
||||
# HDF5_DIFF_EXECUTABLE - the path to the HDF5 dataset comparison tool
|
||||
|
||||
#=============================================================================
|
||||
# Copyright 2015 Axel Huebl, Helmholtz-Zentrum Dresden - Rossendorf
|
||||
# Copyright 2009 Kitware, Inc.
|
||||
#
|
||||
# Distributed under the OSI-approved BSD License (the "License");
|
||||
# see accompanying file Copyright.txt for details.
|
||||
#
|
||||
# This software is distributed WITHOUT ANY WARRANTY; without even the
|
||||
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
# See the License for more information.
|
||||
#=============================================================================
|
||||
# (To distribute this file outside of CMake, substitute the full
|
||||
# License text for the above reference.)
|
||||
|
||||
# This module is maintained by Will Dicharry <wdicharry@stellarscience.com>.
|
||||
|
||||
include(SelectLibraryConfigurations)
|
||||
include(FindPackageHandleStandardArgs)
|
||||
|
||||
# List of the valid HDF5 components
|
||||
set( HDF5_VALID_COMPONENTS
|
||||
C
|
||||
CXX
|
||||
Fortran
|
||||
HL
|
||||
Fortran_HL
|
||||
)
|
||||
|
||||
# Validate the list of find components.
|
||||
if( NOT HDF5_FIND_COMPONENTS )
|
||||
set( HDF5_LANGUAGE_BINDINGS "C" )
|
||||
else()
|
||||
# add the extra specified components, ensuring that they are valid.
|
||||
foreach( component ${HDF5_FIND_COMPONENTS} )
|
||||
list( FIND HDF5_VALID_COMPONENTS ${component} component_location )
|
||||
if( ${component_location} EQUAL -1 )
|
||||
message( FATAL_ERROR
|
||||
"\"${component}\" is not a valid HDF5 component." )
|
||||
else()
|
||||
list( APPEND HDF5_LANGUAGE_BINDINGS ${component} )
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
# Determine whether to search for serial or parallel executable first
|
||||
if(HDF5_PREFER_PARALLEL)
|
||||
set(HDF5_C_COMPILER_NAMES h5pcc h5cc)
|
||||
set(HDF5_CXX_COMPILER_NAMES h5pc++ h5c++)
|
||||
set(HDF5_Fortran_COMPILER_NAMES h5pfc h5fc)
|
||||
else()
|
||||
set(HDF5_C_COMPILER_NAMES h5cc h5pcc)
|
||||
set(HDF5_CXX_COMPILER_NAMES h5c++ h5pc++)
|
||||
set(HDF5_Fortran_COMPILER_NAMES h5fc h5pfc)
|
||||
endif()
|
||||
|
||||
# try to find the HDF5 wrapper compilers
|
||||
find_program( HDF5_C_COMPILER_EXECUTABLE
|
||||
NAMES ${HDF5_C_COMPILER_NAMES}
|
||||
HINTS ENV HDF5_ROOT
|
||||
PATH_SUFFIXES bin Bin
|
||||
DOC "HDF5 Wrapper compiler. Used only to detect HDF5 compile flags." )
|
||||
mark_as_advanced( HDF5_C_COMPILER_EXECUTABLE )
|
||||
|
||||
find_program( HDF5_CXX_COMPILER_EXECUTABLE
|
||||
NAMES ${HDF5_CXX_COMPILER_NAMES}
|
||||
HINTS ENV HDF5_ROOT
|
||||
PATH_SUFFIXES bin Bin
|
||||
DOC "HDF5 C++ Wrapper compiler. Used only to detect HDF5 compile flags." )
|
||||
mark_as_advanced( HDF5_CXX_COMPILER_EXECUTABLE )
|
||||
|
||||
find_program( HDF5_Fortran_COMPILER_EXECUTABLE
|
||||
NAMES ${HDF5_Fortran_COMPILER_NAMES}
|
||||
HINTS ENV HDF5_ROOT
|
||||
PATH_SUFFIXES bin Bin
|
||||
DOC "HDF5 Fortran Wrapper compiler. Used only to detect HDF5 compile flags." )
|
||||
mark_as_advanced( HDF5_Fortran_COMPILER_EXECUTABLE )
|
||||
|
||||
unset(HDF5_C_COMPILER_NAMES)
|
||||
unset(HDF5_CXX_COMPILER_NAMES)
|
||||
unset(HDF5_Fortran_COMPILER_NAMES)
|
||||
|
||||
find_program( HDF5_DIFF_EXECUTABLE
|
||||
NAMES h5diff
|
||||
HINTS ENV HDF5_ROOT
|
||||
PATH_SUFFIXES bin Bin
|
||||
DOC "HDF5 file differencing tool." )
|
||||
mark_as_advanced( HDF5_DIFF_EXECUTABLE )
|
||||
|
||||
# Invoke the HDF5 wrapper compiler. The compiler return value is stored to the
|
||||
# return_value argument, the text output is stored to the output variable.
|
||||
macro( _HDF5_invoke_compiler language output return_value )
|
||||
if( HDF5_${language}_COMPILER_EXECUTABLE )
|
||||
exec_program( ${HDF5_${language}_COMPILER_EXECUTABLE}
|
||||
ARGS -show
|
||||
OUTPUT_VARIABLE ${output}
|
||||
RETURN_VALUE ${return_value}
|
||||
)
|
||||
if( ${${return_value}} EQUAL 0 )
|
||||
# do nothing
|
||||
else()
|
||||
message( STATUS
|
||||
"Unable to determine HDF5 ${language} flags from HDF5 wrapper." )
|
||||
endif()
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
# Parse a compile line for definitions, includes, library paths, and libraries.
|
||||
macro( _HDF5_parse_compile_line
|
||||
compile_line_var
|
||||
include_paths
|
||||
definitions
|
||||
library_paths
|
||||
libraries )
|
||||
|
||||
# Match the include paths
|
||||
string( REGEX MATCHALL "-I([^\" ]+)" include_path_flags
|
||||
"${${compile_line_var}}"
|
||||
)
|
||||
foreach( IPATH ${include_path_flags} )
|
||||
string( REGEX REPLACE "^-I" "" IPATH ${IPATH} )
|
||||
string( REPLACE "//" "/" IPATH ${IPATH} )
|
||||
list( APPEND ${include_paths} ${IPATH} )
|
||||
endforeach()
|
||||
|
||||
# Match the definitions
|
||||
string( REGEX MATCHALL "-D[^ ]*" definition_flags "${${compile_line_var}}" )
|
||||
foreach( DEF ${definition_flags} )
|
||||
list( APPEND ${definitions} ${DEF} )
|
||||
endforeach()
|
||||
|
||||
# Match the library paths
|
||||
string( REGEX MATCHALL "-L([^\" ]+|\"[^\"]+\")" library_path_flags
|
||||
"${${compile_line_var}}"
|
||||
)
|
||||
|
||||
foreach( LPATH ${library_path_flags} )
|
||||
string( REGEX REPLACE "^-L" "" LPATH ${LPATH} )
|
||||
string( REPLACE "//" "/" LPATH ${LPATH} )
|
||||
list( APPEND ${library_paths} ${LPATH} )
|
||||
endforeach()
|
||||
|
||||
# now search for the library names specified in the compile line (match -l...)
|
||||
# match only -l's preceded by a space or comma
|
||||
# this is to exclude directory names like xxx-linux/
|
||||
string( REGEX MATCHALL "[, ]-l([^\", ]+)" library_name_flags
|
||||
"${${compile_line_var}}" )
|
||||
# strip the -l from all of the library flags and add to the search list
|
||||
foreach( LIB ${library_name_flags} )
|
||||
string( REGEX REPLACE "^[, ]-l" "" LIB ${LIB} )
|
||||
list( APPEND ${libraries} ${LIB} )
|
||||
endforeach()
|
||||
endmacro()
|
||||
|
||||
# Try to find HDF5 using an installed hdf5-config.cmake
|
||||
if( NOT HDF5_FOUND )
|
||||
find_package( HDF5 QUIET NO_MODULE )
|
||||
if( HDF5_FOUND )
|
||||
set( HDF5_INCLUDE_DIRS ${HDF5_INCLUDE_DIR} )
|
||||
set( HDF5_LIBRARIES )
|
||||
set( HDF5_C_TARGET hdf5 )
|
||||
set( HDF5_CXX_TARGET hdf5_cpp )
|
||||
set( HDF5_HL_TARGET hdf5_hl )
|
||||
set( HDF5_Fortran_TARGET hdf5_fortran )
|
||||
set( HDF5_Fortran_HL_TARGET hdf5_hl_fortran )
|
||||
foreach( _component ${HDF5_LANGUAGE_BINDINGS} )
|
||||
list( FIND HDF5_VALID_COMPONENTS ${_component} _component_location )
|
||||
get_target_property( _comp_location ${HDF5_${_component}_TARGET} LOCATION )
|
||||
if( _comp_location )
|
||||
set( HDF5_${_component}_LIBRARY ${_comp_location} CACHE PATH
|
||||
"HDF5 ${_component} library" )
|
||||
mark_as_advanced( HDF5_${_component}_LIBRARY )
|
||||
list( APPEND HDF5_LIBRARIES ${HDF5_${_component}_LIBRARY} )
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if( NOT HDF5_FOUND )
|
||||
_HDF5_invoke_compiler( C HDF5_C_COMPILE_LINE HDF5_C_RETURN_VALUE )
|
||||
_HDF5_invoke_compiler( CXX HDF5_CXX_COMPILE_LINE HDF5_CXX_RETURN_VALUE )
|
||||
_HDF5_invoke_compiler( Fortran HDF5_Fortran_COMPILE_LINE HDF5_Fortran_RETURN_VALUE )
|
||||
set(HDF5_HL_COMPILE_LINE ${HDF5_C_COMPILE_LINE})
|
||||
set(HDF5_Fortran_HL_COMPILE_LINE ${HDF5_Fortran_COMPILE_LINE})
|
||||
|
||||
# seed the initial lists of libraries to find with items we know we need
|
||||
set( HDF5_C_LIBRARY_NAMES_INIT hdf5 )
|
||||
set( HDF5_HL_LIBRARY_NAMES_INIT hdf5_hl ${HDF5_C_LIBRARY_NAMES_INIT} )
|
||||
set( HDF5_CXX_LIBRARY_NAMES_INIT hdf5_cpp ${HDF5_C_LIBRARY_NAMES_INIT} )
|
||||
set( HDF5_Fortran_LIBRARY_NAMES_INIT hdf5_fortran
|
||||
${HDF5_C_LIBRARY_NAMES_INIT} )
|
||||
set( HDF5_Fortran_HL_LIBRARY_NAMES_INIT hdf5hl_fortran hdf5_hl
|
||||
${HDF5_Fortran_LIBRARY_NAMES_INIT} )
|
||||
|
||||
foreach( LANGUAGE ${HDF5_LANGUAGE_BINDINGS} )
|
||||
if( HDF5_${LANGUAGE}_COMPILE_LINE )
|
||||
_HDF5_parse_compile_line( HDF5_${LANGUAGE}_COMPILE_LINE
|
||||
HDF5_${LANGUAGE}_INCLUDE_FLAGS
|
||||
HDF5_${LANGUAGE}_DEFINITIONS
|
||||
HDF5_${LANGUAGE}_LIBRARY_DIRS
|
||||
HDF5_${LANGUAGE}_LIBRARY_NAMES
|
||||
)
|
||||
|
||||
# take a guess that the includes may be in the 'include' sibling
|
||||
# directory of a library directory.
|
||||
foreach( dir ${HDF5_${LANGUAGE}_LIBRARY_DIRS} )
|
||||
list( APPEND HDF5_${LANGUAGE}_INCLUDE_FLAGS ${dir}/../include )
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
# set the definitions for the language bindings.
|
||||
list( APPEND HDF5_DEFINITIONS ${HDF5_${LANGUAGE}_DEFINITIONS} )
|
||||
|
||||
# find the HDF5 include directories
|
||||
if(${LANGUAGE} MATCHES "Fortran")
|
||||
set(HDF5_INCLUDE_FILENAME hdf5.mod)
|
||||
else()
|
||||
set(HDF5_INCLUDE_FILENAME hdf5.h)
|
||||
endif()
|
||||
|
||||
find_path( HDF5_${LANGUAGE}_INCLUDE_DIR ${HDF5_INCLUDE_FILENAME}
|
||||
HINTS
|
||||
${HDF5_${LANGUAGE}_INCLUDE_FLAGS}
|
||||
ENV
|
||||
HDF5_ROOT
|
||||
PATHS
|
||||
$ENV{HOME}/.local/include
|
||||
PATH_SUFFIXES
|
||||
include
|
||||
Include
|
||||
)
|
||||
mark_as_advanced( HDF5_${LANGUAGE}_INCLUDE_DIR )
|
||||
list( APPEND HDF5_INCLUDE_DIRS ${HDF5_${LANGUAGE}_INCLUDE_DIR} )
|
||||
|
||||
# find the HDF5 libraries
|
||||
foreach( LIB ${HDF5_${LANGUAGE}_LIBRARY_NAMES_INIT} )
|
||||
if( UNIX AND HDF5_USE_STATIC_LIBRARIES )
|
||||
# According to bug 1643 on the CMake bug tracker, this is the
|
||||
# preferred method for searching for a static library.
|
||||
# See http://www.cmake.org/Bug/view.php?id=1643. We search
|
||||
# first for the full static library name, but fall back to a
|
||||
# generic search on the name if the static search fails.
|
||||
set( THIS_LIBRARY_SEARCH_DEBUG lib${LIB}d.a ${LIB}d )
|
||||
set( THIS_LIBRARY_SEARCH_RELEASE lib${LIB}.a ${LIB} )
|
||||
else()
|
||||
set( THIS_LIBRARY_SEARCH_DEBUG ${LIB}d )
|
||||
set( THIS_LIBRARY_SEARCH_RELEASE ${LIB} )
|
||||
endif()
|
||||
find_library( HDF5_${LIB}_LIBRARY_DEBUG
|
||||
NAMES ${THIS_LIBRARY_SEARCH_DEBUG}
|
||||
HINTS ${HDF5_${LANGUAGE}_LIBRARY_DIRS}
|
||||
ENV HDF5_ROOT
|
||||
PATH_SUFFIXES lib Lib )
|
||||
find_library( HDF5_${LIB}_LIBRARY_RELEASE
|
||||
NAMES ${THIS_LIBRARY_SEARCH_RELEASE}
|
||||
HINTS ${HDF5_${LANGUAGE}_LIBRARY_DIRS}
|
||||
ENV HDF5_ROOT
|
||||
PATH_SUFFIXES lib Lib )
|
||||
select_library_configurations( HDF5_${LIB} )
|
||||
list(APPEND HDF5_${LANGUAGE}_LIBRARIES ${HDF5_${LIB}_LIBRARY})
|
||||
endforeach()
|
||||
list( APPEND HDF5_LIBRARY_DIRS ${HDF5_${LANGUAGE}_LIBRARY_DIRS} )
|
||||
|
||||
# When the wrapper lists a library with -l, e.g. -lz, simply use it as
|
||||
# is. If find_library is called for these libraries, you end up with
|
||||
# local libraries that will not be suitable when cross-compiling for the
|
||||
# Intel Xeon Phi.
|
||||
foreach(LIBNAME ${HDF5_${LANGUAGE}_LIBRARY_NAMES})
|
||||
list(APPEND HDF5_${LANGUAGE}_LIBRARIES "-l${LIBNAME}")
|
||||
endforeach()
|
||||
|
||||
# Append the libraries for this language binding to the list of all
|
||||
# required libraries.
|
||||
list(APPEND HDF5_LIBRARIES ${HDF5_${LANGUAGE}_LIBRARIES})
|
||||
endforeach()
|
||||
|
||||
# We may have picked up some duplicates in various lists during the above
|
||||
# process for the language bindings (both the C and C++ bindings depend on
|
||||
# libz for example). Remove the duplicates. It appears that the default
|
||||
# CMake behavior is to remove duplicates from the end of a list. However,
|
||||
# for link lines, this is incorrect since unresolved symbols are searched
|
||||
# for down the link line. Therefore, we reverse the list, remove the
|
||||
# duplicates, and then reverse it again to get the duplicates removed from
|
||||
# the beginning.
|
||||
macro( _remove_duplicates_from_beginning _list_name )
|
||||
list( REVERSE ${_list_name} )
|
||||
list( REMOVE_DUPLICATES ${_list_name} )
|
||||
list( REVERSE ${_list_name} )
|
||||
endmacro()
|
||||
|
||||
if( HDF5_INCLUDE_DIRS )
|
||||
_remove_duplicates_from_beginning( HDF5_INCLUDE_DIRS )
|
||||
endif()
|
||||
if( HDF5_LIBRARY_DIRS )
|
||||
_remove_duplicates_from_beginning( HDF5_LIBRARY_DIRS )
|
||||
endif()
|
||||
|
||||
# If the HDF5 include directory was found, open H5pubconf.h to determine if
|
||||
# HDF5 was compiled with parallel IO support
|
||||
set( HDF5_IS_PARALLEL FALSE )
|
||||
set( HDF5_VERSION "" )
|
||||
foreach( _dir IN LISTS HDF5_INCLUDE_DIRS )
|
||||
foreach(_hdr "${_dir}/H5pubconf.h" "${_dir}/H5pubconf-64.h" "${_dir}/H5pubconf-32.h")
|
||||
if( EXISTS "${_hdr}" )
|
||||
file( STRINGS "${_hdr}"
|
||||
HDF5_HAVE_PARALLEL_DEFINE
|
||||
REGEX "HAVE_PARALLEL 1" )
|
||||
if( HDF5_HAVE_PARALLEL_DEFINE )
|
||||
set( HDF5_IS_PARALLEL TRUE )
|
||||
endif()
|
||||
unset(HDF5_HAVE_PARALLEL_DEFINE)
|
||||
|
||||
file( STRINGS "${_hdr}"
|
||||
HDF5_VERSION_DEFINE
|
||||
REGEX "^[ \t]*#[ \t]*define[ \t]+H5_VERSION[ \t]+" )
|
||||
if( "${HDF5_VERSION_DEFINE}" MATCHES
|
||||
"H5_VERSION[ \t]+\"([0-9]+\\.[0-9]+\\.[0-9]+).*\"" )
|
||||
set( HDF5_VERSION "${CMAKE_MATCH_1}" )
|
||||
endif()
|
||||
unset(HDF5_VERSION_DEFINE)
|
||||
endif()
|
||||
endforeach()
|
||||
endforeach()
|
||||
set( HDF5_IS_PARALLEL ${HDF5_IS_PARALLEL} CACHE BOOL
|
||||
"HDF5 library compiled with parallel IO support" )
|
||||
mark_as_advanced( HDF5_IS_PARALLEL )
|
||||
|
||||
# For backwards compatibility we set HDF5_INCLUDE_DIR to the value of
|
||||
# HDF5_INCLUDE_DIRS
|
||||
if( HDF5_INCLUDE_DIRS )
|
||||
set( HDF5_INCLUDE_DIR "${HDF5_INCLUDE_DIRS}" )
|
||||
endif()
|
||||
|
||||
endif()
|
||||
|
||||
find_package_handle_standard_args( HDF5
|
||||
REQUIRED_VARS HDF5_LIBRARIES HDF5_INCLUDE_DIRS
|
||||
VERSION_VAR HDF5_VERSION
|
||||
)
|
||||
|
|
@ -59,7 +59,7 @@ Coupling and Multi-physics
|
|||
|
||||
- Ze-Long Zhao, Yongwei Yang, and Shuang Hong, "`Application of FLUKA and OpenMC
|
||||
in coupled physics calculation of target and subcritical reactor for ADS
|
||||
<https://doi.org/10.1007/s41365-018-0539-1>`_," *Nucl. Sci. Tech.*, **30**
|
||||
<https://doi.org/10.1007/s41365-018-0539-1>`_," *Nucl. Sci. Tech.*, **30**: 10
|
||||
(2019).
|
||||
|
||||
- April Novak, Paul Romano, Brycen Wendt, Ron Rahaman, Elia Merzari, Leslie
|
||||
|
|
@ -134,6 +134,11 @@ Geometry and Visualization
|
|||
Miscellaneous
|
||||
-------------
|
||||
|
||||
- Faisal Qayyum, Muhammad R. Ali, Awais Zahur, and R. Khan, "`Improvements in
|
||||
methodology to determine feedback reactivity coefficients
|
||||
<https://doi.org/10.1007/s41365-019-0588-0>`_," *Nucl. Sci. Tech.*, **30**: 63
|
||||
(2019).
|
||||
|
||||
- Amanda L. Lund and Paul K. Romano, "`Implementation and Validation of Photon
|
||||
Transport in OpenMC <https://doi.org/10.2172/1490825>`_", Argonne National
|
||||
Laboratory, Technical Report ANL/MCS-TM-381 (2018).
|
||||
|
|
@ -464,6 +469,11 @@ Parallelism
|
|||
Depletion
|
||||
---------
|
||||
|
||||
- Zhao-Qing Liu, Ze-Long Zhao, Yong-Wei Yang, Yu-Cui Gao, Hai-Yan Meng, and
|
||||
Qing-Yu Gao, "`Development and validation of depletion code system IMPC-Burnup
|
||||
for ADS <https://doi.org/10.1007/s41365-019-0560-z>`_," *Nucl. Sci. Tech.*,
|
||||
**30**: 44 (2019).
|
||||
|
||||
- Colin Josey, Benoit Forget, and Kord Smith, "`High order methods for the
|
||||
integration of the Bateman equations and other problems of the form of y' =
|
||||
F(y,t)y <https://doi.org/10.1016/j.jcp.2017.08.025>`_," *J. Comput. Phys.*,
|
||||
|
|
|
|||
|
|
@ -7,6 +7,12 @@
|
|||
|
||||
#include "openmc/capi.h"
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define UNREACHABLE() __builtin_unreachable()
|
||||
#else
|
||||
#define UNREACHABLE() (void)0
|
||||
#endif
|
||||
|
||||
namespace openmc {
|
||||
|
||||
inline void
|
||||
|
|
@ -29,13 +35,13 @@ set_errmsg(const std::stringstream& message)
|
|||
|
||||
[[noreturn]] void fatal_error(const std::string& message, int err=-1);
|
||||
|
||||
inline
|
||||
[[noreturn]] inline
|
||||
void fatal_error(const std::stringstream& message)
|
||||
{
|
||||
fatal_error(message.str());
|
||||
}
|
||||
|
||||
inline
|
||||
[[noreturn]] inline
|
||||
void fatal_error(const char* message)
|
||||
{
|
||||
fatal_error({message, std::strlen(message)});
|
||||
|
|
|
|||
|
|
@ -138,6 +138,10 @@ T PlotBase::get_map() const {
|
|||
in_i = 1;
|
||||
out_i = 2;
|
||||
break;
|
||||
#ifdef __GNUC__
|
||||
default:
|
||||
__builtin_unreachable();
|
||||
#endif
|
||||
}
|
||||
|
||||
// set initial position
|
||||
|
|
@ -168,7 +172,6 @@ T PlotBase::get_map() const {
|
|||
if (level >=0) {j = level + 1;}
|
||||
if (found_cell) {
|
||||
data.set_value(y, x, p, j);
|
||||
Cell* c = model::cells[p.coord_[j].cell].get();
|
||||
}
|
||||
} // inner for
|
||||
} // outer for
|
||||
|
|
|
|||
|
|
@ -571,7 +571,10 @@ class Cell(IDManagerMixin):
|
|||
# Check for other attributes
|
||||
t = get_text(elem, 'temperature')
|
||||
if t is not None:
|
||||
c.temperature = float(t)
|
||||
if ' ' in t:
|
||||
c.temperature = [float(t_i) for t_i in t.split()]
|
||||
else:
|
||||
c.temperature = float(t)
|
||||
for key in ('temperature', 'rotation', 'translation'):
|
||||
value = get_text(elem, key)
|
||||
if value is not None:
|
||||
|
|
|
|||
|
|
@ -529,7 +529,7 @@ class IncidentNeutron(EqualityMixin):
|
|||
# Read energy grid
|
||||
e_group = group['energy']
|
||||
for temperature, dset in e_group.items():
|
||||
data.energy[temperature] = dset.value
|
||||
data.energy[temperature] = dset[()]
|
||||
|
||||
# Read reaction data
|
||||
rxs_group = group['reactions']
|
||||
|
|
|
|||
|
|
@ -280,7 +280,7 @@ class Material(IDManagerMixin):
|
|||
name = group['name'][()].decode() if 'name' in group else ''
|
||||
density = group['atom_density'][()]
|
||||
if 'nuclide_densities' in group:
|
||||
nuc_densities = group['nuclide_densities'][...]
|
||||
nuc_densities = group['nuclide_densities'][()]
|
||||
|
||||
# Create the Material
|
||||
material = cls(mat_id, name)
|
||||
|
|
|
|||
|
|
@ -147,17 +147,17 @@ class Summary(object):
|
|||
|
||||
if fill_type == 'universe':
|
||||
if 'translation' in group:
|
||||
translation = group['translation'][...]
|
||||
translation = group['translation'][()]
|
||||
translation = np.asarray(translation, dtype=np.float64)
|
||||
cell.translation = translation
|
||||
|
||||
if 'rotation' in group:
|
||||
rotation = group['rotation'][...]
|
||||
rotation = group['rotation'][()]
|
||||
rotation = np.asarray(rotation, dtype=np.int)
|
||||
cell._rotation = rotation
|
||||
|
||||
elif fill_type == 'material':
|
||||
cell.temperature = group['temperature'][...]
|
||||
cell.temperature = group['temperature'][()]
|
||||
|
||||
# Store Cell fill information for after Universe/Lattice creation
|
||||
cell_fills[cell.id] = (fill_type, fill)
|
||||
|
|
|
|||
|
|
@ -217,7 +217,7 @@ class Tally(IDManagerMixin):
|
|||
f = h5py.File(self._sp_filename, 'r')
|
||||
|
||||
# Extract Tally data from the file
|
||||
data = f['tallies/tally {0}/results'.format(self.id)][()]
|
||||
data = f['tallies/tally {0}/results'.format(self.id)]
|
||||
sum = data[:, :, 0]
|
||||
sum_sq = data[:, :, 1]
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ void thick_target_bremsstrahlung(Particle& p, double* E_lost)
|
|||
auto n_e = data::ttb_e_grid.size();
|
||||
|
||||
// Find the lower bounding index of the incident electron energy
|
||||
int j = lower_bound_index(data::ttb_e_grid.cbegin(),
|
||||
size_t j = lower_bound_index(data::ttb_e_grid.cbegin(),
|
||||
data::ttb_e_grid.cend(), e);
|
||||
if (j == n_e - 1) --j;
|
||||
|
||||
|
|
|
|||
40
src/cell.cpp
40
src/cell.cpp
|
|
@ -325,7 +325,6 @@ CSGCell::CSGCell(pugi::xml_node cell_node)
|
|||
|
||||
// Convert the infix region spec to RPN.
|
||||
rpn_ = generate_rpn(id_, region_);
|
||||
rpn_.shrink_to_fit();
|
||||
|
||||
// Check if this is a simple cell.
|
||||
simple_ = true;
|
||||
|
|
@ -336,6 +335,21 @@ CSGCell::CSGCell(pugi::xml_node cell_node)
|
|||
}
|
||||
}
|
||||
|
||||
// If this cell is simple, remove all the superfluous operator tokens.
|
||||
if (simple_) {
|
||||
size_t i0 = 0;
|
||||
size_t i1 = 0;
|
||||
while (i1 < rpn_.size()) {
|
||||
if (rpn_[i1] < OP_UNION) {
|
||||
rpn_[i0] = rpn_[i1];
|
||||
++i0;
|
||||
}
|
||||
++i1;
|
||||
}
|
||||
rpn_.resize(i0);
|
||||
}
|
||||
rpn_.shrink_to_fit();
|
||||
|
||||
// Read the translation vector.
|
||||
if (check_for_node(cell_node, "translation")) {
|
||||
if (fill_ == C_NONE) {
|
||||
|
|
@ -522,19 +536,17 @@ bool
|
|||
CSGCell::contains_simple(Position r, Direction u, int32_t on_surface) const
|
||||
{
|
||||
for (int32_t token : rpn_) {
|
||||
if (token < OP_UNION) {
|
||||
// If the token is not an operator, evaluate the sense of particle with
|
||||
// respect to the surface and see if the token matches the sense. If the
|
||||
// particle's surface attribute is set and matches the token, that
|
||||
// overrides the determination based on sense().
|
||||
if (token == on_surface) {
|
||||
} else if (-token == on_surface) {
|
||||
return false;
|
||||
} else {
|
||||
// Note the off-by-one indexing
|
||||
bool sense = model::surfaces[abs(token)-1]->sense(r, u);
|
||||
if (sense != (token > 0)) {return false;}
|
||||
}
|
||||
// Assume that no tokens are operators. Evaluate the sense of particle with
|
||||
// respect to the surface and see if the token matches the sense. If the
|
||||
// particle's surface attribute is set and matches the token, that
|
||||
// overrides the determination based on sense().
|
||||
if (token == on_surface) {
|
||||
} else if (-token == on_surface) {
|
||||
return false;
|
||||
} else {
|
||||
// Note the off-by-one indexing
|
||||
bool sense = model::surfaces[abs(token)-1]->sense(r, u);
|
||||
if (sense != (token > 0)) {return false;}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -247,7 +247,6 @@ read_ce_cross_sections(const std::vector<std::vector<double>>& nuc_temps,
|
|||
LibraryKey key {Library::Type::photon, element};
|
||||
int idx = data::library_map[key];
|
||||
std::string& filename = data::libraries[idx].path_;
|
||||
int i_element = data::element_map[element];
|
||||
write_message("Reading " + element + " from " + filename, 6);
|
||||
|
||||
// Open file and make sure version is sufficient
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ void load_dagmc_geometry()
|
|||
model::DAG = new moab::DagMC();
|
||||
}
|
||||
|
||||
/// Materials \\\
|
||||
// --- Materials ---
|
||||
|
||||
// create uwuw instance
|
||||
UWUW uwuw(DAGMC_FILENAME.c_str());
|
||||
|
|
@ -176,7 +176,7 @@ void load_dagmc_geometry()
|
|||
rval = model::DAG->parse_properties(keywords, dum, delimiters.c_str());
|
||||
MB_CHK_ERR_CONT(rval);
|
||||
|
||||
/// Cells (Volumes) \\\
|
||||
// --- Cells (Volumes) ---
|
||||
|
||||
// initialize cell objects
|
||||
int n_cells = model::DAG->num_entities(3);
|
||||
|
|
@ -298,7 +298,7 @@ void load_dagmc_geometry()
|
|||
"This may result in lost particles and rapid simulation failure.");
|
||||
}
|
||||
|
||||
/// Surfaces \\\
|
||||
// --- Surfaces ---
|
||||
|
||||
// initialize surface objects
|
||||
int n_surfaces = model::DAG->num_entities(2);
|
||||
|
|
|
|||
|
|
@ -245,6 +245,9 @@ double ContinuousTabular::sample(double E) const
|
|||
E_out = E_l_k + (std::sqrt(std::max(0.0, p_l_k*p_l_k +
|
||||
2.0*frac*(r1 - c_k))) - p_l_k)/frac;
|
||||
}
|
||||
} else {
|
||||
throw std::runtime_error{"Unexpected interpolation for continuous energy "
|
||||
"distribution."};
|
||||
}
|
||||
|
||||
// Now interpolate between incident energy bins i and i + 1
|
||||
|
|
|
|||
|
|
@ -164,9 +164,8 @@ double Tabulated1D::operator()(double x) const
|
|||
Interpolation interp;
|
||||
if (n_regions_ == 0) {
|
||||
interp = Interpolation::lin_lin;
|
||||
} else if (n_regions_ == 1) {
|
||||
} else {
|
||||
interp = int_[0];
|
||||
} else if (n_regions_ > 1) {
|
||||
for (int j = 0; j < n_regions_; ++j) {
|
||||
if (i < nbt_[j]) {
|
||||
interp = int_[j];
|
||||
|
|
|
|||
|
|
@ -39,7 +39,6 @@ bool check_cell_overlap(Particle* p)
|
|||
// Loop through each coordinate level
|
||||
for (int j = 0; j < n_coord; j++) {
|
||||
Universe& univ = *model::universes[p->coord_[j].universe];
|
||||
int n = univ.cells_.size();
|
||||
|
||||
// Loop through each cell on this level
|
||||
for (auto index_cell : univ.cells_) {
|
||||
|
|
@ -351,7 +350,7 @@ BoundaryInfo distance_to_boundary(Particle* p)
|
|||
double d_lat = INFINITY;
|
||||
double d_surf = INFINITY;
|
||||
int32_t level_surf_cross;
|
||||
std::array<int, 3> level_lat_trans;
|
||||
std::array<int, 3> level_lat_trans {};
|
||||
|
||||
// Loop over each coordinate level.
|
||||
for (int i = 0; i < p->n_coord_; i++) {
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
#include <array>
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
#include "xtensor/xtensor.hpp"
|
||||
|
|
@ -47,6 +48,8 @@ get_shape(hid_t obj_id, hsize_t* dims)
|
|||
dspace = H5Dget_space(obj_id);
|
||||
} else if (type == H5I_ATTR) {
|
||||
dspace = H5Aget_space(obj_id);
|
||||
} else {
|
||||
throw std::runtime_error{"Expected dataset or attribute in call to get_shape."};
|
||||
}
|
||||
H5Sget_simple_extent_dims(dspace, dims, nullptr);
|
||||
H5Sclose(dspace);
|
||||
|
|
@ -70,6 +73,8 @@ std::vector<hsize_t> object_shape(hid_t obj_id)
|
|||
dspace = H5Dget_space(obj_id);
|
||||
} else if (type == H5I_ATTR) {
|
||||
dspace = H5Aget_space(obj_id);
|
||||
} else {
|
||||
throw std::runtime_error{"Expected dataset or attribute in call to object_shape."};
|
||||
}
|
||||
int n = H5Sget_simple_extent_ndims(dspace);
|
||||
|
||||
|
|
|
|||
|
|
@ -121,7 +121,6 @@ void initialize_mpi(MPI_Comm intracomm)
|
|||
int
|
||||
parse_command_line(int argc, char* argv[])
|
||||
{
|
||||
char buffer[256]; // buffer for reading attribute
|
||||
int last_flag = 0;
|
||||
for (int i=1; i < argc; ++i) {
|
||||
std::string arg {argv[i]};
|
||||
|
|
|
|||
|
|
@ -800,7 +800,6 @@ HexLattice::is_valid_index(int indx) const
|
|||
{
|
||||
int nx {2*n_rings_ - 1};
|
||||
int ny {2*n_rings_ - 1};
|
||||
int nz {n_axial_};
|
||||
int iz = indx / (nx * ny);
|
||||
int iy = (indx - nx*ny*iz) / nx;
|
||||
int ix = indx - nx*ny*iz - nx*iy;
|
||||
|
|
|
|||
|
|
@ -1283,12 +1283,11 @@ openmc_material_set_densities(int32_t index, int n, const char** name, const dou
|
|||
}
|
||||
|
||||
// Set total density to the sum of the vector
|
||||
|
||||
int err = mat->set_density(sum_density, "atom/b-cm");
|
||||
|
||||
// Assign S(a,b) tables
|
||||
mat->init_thermal();
|
||||
return 0;
|
||||
return err;
|
||||
} else {
|
||||
set_errmsg("Index in materials array is out of bounds.");
|
||||
return OPENMC_E_OUT_OF_BOUNDS;
|
||||
|
|
|
|||
|
|
@ -329,8 +329,6 @@ Mgxs::Mgxs(const std::string& in_name, const std::vector<double>& mat_kTs,
|
|||
// Force all of the following data to be the same; these will be verified
|
||||
// to be true later
|
||||
int in_scatter_format = micros[0]->scatter_format;
|
||||
int in_num_groups = micros[0]->num_groups;
|
||||
int in_num_delayed_groups = micros[0]->num_delayed_groups;
|
||||
bool in_is_isotropic = micros[0]->is_isotropic;
|
||||
std::vector<double> in_polar = micros[0]->polar;
|
||||
std::vector<double> in_azimuthal = micros[0]->azimuthal;
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ Nuclide::Nuclide(hid_t group, const std::vector<double>& temperature, int i_nucl
|
|||
|
||||
// Determine closest temperature
|
||||
double min_delta_T = INFTY;
|
||||
double T_actual;
|
||||
double T_actual = 0.0;
|
||||
for (auto T : temps_available) {
|
||||
double delta_T = std::abs(T - T_desired);
|
||||
if (delta_T < min_delta_T) {
|
||||
|
|
@ -454,9 +454,7 @@ double Nuclide::nu(double E, EmissionMode mode, int group) const
|
|||
return (*fission_rx_[0]->products_[0].yield_)(E);
|
||||
}
|
||||
}
|
||||
#ifdef __GNUC__
|
||||
__builtin_unreachable();
|
||||
#endif
|
||||
UNREACHABLE();
|
||||
}
|
||||
|
||||
void Nuclide::calculate_elastic_xs(Particle& p) const
|
||||
|
|
|
|||
|
|
@ -283,9 +283,9 @@ print_overlap_check()
|
|||
{
|
||||
#ifdef OPENMC_MPI
|
||||
std::vector<int64_t> temp(model::overlap_check_count);
|
||||
int err = MPI_Reduce(temp.data(), model::overlap_check_count.data(),
|
||||
model::overlap_check_count.size(), MPI_INT64_T,
|
||||
MPI_SUM, 0, mpi::intracomm);
|
||||
MPI_Reduce(temp.data(), model::overlap_check_count.data(),
|
||||
model::overlap_check_count.size(), MPI_INT64_T,
|
||||
MPI_SUM, 0, mpi::intracomm);
|
||||
#endif
|
||||
|
||||
if (mpi::master) {
|
||||
|
|
@ -482,7 +482,7 @@ void print_runtime()
|
|||
|
||||
// Calculate particle rate in active/inactive batches
|
||||
int n_active = simulation::current_batch - settings::n_inactive;
|
||||
double speed_inactive;
|
||||
double speed_inactive = 0.0;
|
||||
double speed_active;
|
||||
if (settings::restart_run) {
|
||||
if (simulation::restart_batch < settings::n_inactive) {
|
||||
|
|
@ -492,7 +492,6 @@ void print_runtime()
|
|||
speed_active = (settings::n_particles * n_active
|
||||
* settings::gen_per_batch) / time_active.elapsed();
|
||||
} else {
|
||||
speed_inactive = 0.0;
|
||||
speed_active = (settings::n_particles * (settings::n_batches
|
||||
- simulation::restart_batch) * settings::gen_per_batch)
|
||||
/ time_active.elapsed();
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@
|
|||
|
||||
#include <algorithm> // for copy
|
||||
#include <array>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
namespace openmc {
|
||||
|
|
@ -90,6 +91,9 @@ void run_particle_restart()
|
|||
case RUN_MODE_FIXEDSOURCE:
|
||||
particle_seed = p.id_;
|
||||
break;
|
||||
default:
|
||||
throw std::runtime_error{"Unexpected run mode: " +
|
||||
std::to_string(previous_run_mode)};
|
||||
}
|
||||
set_particle_seed(particle_seed);
|
||||
|
||||
|
|
|
|||
|
|
@ -560,11 +560,6 @@ void PhotonInteraction::pair_production(double alpha, double* E_electron,
|
|||
// "PENELOPE-2011: A Code System for Monte Carlo Simulation of Electron and
|
||||
// Photon Transport," OECD-NEA, Issy-les-Moulineaux, France (2011).
|
||||
|
||||
// Compute the minimum and maximum values of the electron reduced energy,
|
||||
// i.e. the fraction of the photon energy that is given to the electron
|
||||
double e_min = 1.0/alpha;
|
||||
double e_max = 1.0 - 1.0/alpha;
|
||||
|
||||
// Compute the high-energy Coulomb correction
|
||||
double a = Z_ / FINE_STRUCTURE;
|
||||
double c = a*a*(1.0/(1.0 + a*a) + 0.202059 + a*a*(-0.03693 + a*a*(0.00835 +
|
||||
|
|
|
|||
|
|
@ -420,20 +420,11 @@ int sample_element(Particle* p)
|
|||
|
||||
// Get pointers to elements, densities
|
||||
const auto& mat {model::materials[p->material_]};
|
||||
int n = mat->nuclide_.size();
|
||||
|
||||
int i = 0;
|
||||
double prob = 0.0;
|
||||
int i_element;
|
||||
while (prob < cutoff) {
|
||||
// Check to make sure that a nuclide was sampled
|
||||
if (i >= n) {
|
||||
p->write_restart();
|
||||
fatal_error("Did not sample any element during collision.");
|
||||
}
|
||||
|
||||
for (int i = 0; i < mat->element_.size(); ++i) {
|
||||
// Find atom density
|
||||
i_element = mat->element_[i];
|
||||
int i_element = mat->element_[i];
|
||||
double atom_density = mat->atom_density_[i];
|
||||
|
||||
// Determine microscopic cross section
|
||||
|
|
@ -441,10 +432,12 @@ int sample_element(Particle* p)
|
|||
|
||||
// Increment probability to compare to cutoff
|
||||
prob += sigma;
|
||||
++i;
|
||||
if (prob > cutoff) return i_element;
|
||||
}
|
||||
|
||||
return i_element;
|
||||
// If we made it here, no element was sampled
|
||||
p->write_restart();
|
||||
fatal_error("Did not sample any element during collision.");
|
||||
}
|
||||
|
||||
Reaction* sample_fission(int i_nuclide, const Particle* p)
|
||||
|
|
@ -613,7 +606,7 @@ void scatter(Particle* p, int i_nuclide)
|
|||
// INELASTIC SCATTERING
|
||||
|
||||
int j = 0;
|
||||
int i;
|
||||
int i = 0;
|
||||
while (prob < cutoff) {
|
||||
i = nuc->index_inelastic_scatter_[j];
|
||||
++j;
|
||||
|
|
@ -889,9 +882,7 @@ Direction sample_target_velocity(const Nuclide* nuc, double E, Direction u,
|
|||
} // case RVS, DBRC
|
||||
} // switch (sampling_method)
|
||||
|
||||
#ifdef __GNUC__
|
||||
__builtin_unreachable();
|
||||
#endif
|
||||
UNREACHABLE();
|
||||
}
|
||||
|
||||
Direction
|
||||
|
|
|
|||
|
|
@ -80,8 +80,6 @@ std::unordered_map<int, int> plot_map;
|
|||
extern "C"
|
||||
int openmc_plot_geometry()
|
||||
{
|
||||
int err;
|
||||
|
||||
for (auto pl : model::plots) {
|
||||
std::stringstream ss;
|
||||
ss << "Processing plot " << pl.id_ << ": "
|
||||
|
|
@ -695,6 +693,8 @@ void draw_mesh_lines(Plot pl, ImageData& data)
|
|||
outer = 1;
|
||||
inner = 2;
|
||||
break;
|
||||
default:
|
||||
UNREACHABLE();
|
||||
}
|
||||
|
||||
Position ll_plot {pl.origin_};
|
||||
|
|
@ -806,7 +806,6 @@ void create_voxel(Plot pl)
|
|||
|
||||
// Write current date and time
|
||||
write_attribute(file_id, "date_and_time", time_stamp().c_str());
|
||||
hsize_t three = 3;
|
||||
std::array<int, 3> pixels;
|
||||
std::copy(pl.pixels_.begin(), pl.pixels_.end(), pixels.begin());
|
||||
write_attribute(file_id, "num_voxels", pixels);
|
||||
|
|
|
|||
|
|
@ -199,7 +199,7 @@ void KalbachMann::sample(double E_in, double& E_out, double& mu) const
|
|||
km_r = distribution_[l].r[k];
|
||||
km_a = distribution_[l].a[k];
|
||||
|
||||
} else if (distribution_[l].interpolation == Interpolation::lin_lin) {
|
||||
} else {
|
||||
// Linear-linear interpolation
|
||||
double E_l_k1 = distribution_[l].e_out[k+1];
|
||||
double p_l_k1 = distribution_[l].p[k+1];
|
||||
|
|
|
|||
|
|
@ -55,6 +55,8 @@ void NBodyPhaseSpace::sample(double E_in, double& E_out, double& mu) const
|
|||
r6 = prn();
|
||||
y = -std::log(r1*r2*r3*r4) - std::log(r5) * std::pow(std::cos(PI/2.0*r6), 2);
|
||||
break;
|
||||
default:
|
||||
throw std::runtime_error{"N-body phase space with >5 bodies."};
|
||||
}
|
||||
|
||||
// Now determine v and E_out
|
||||
|
|
|
|||
|
|
@ -50,9 +50,7 @@ ParticleFilter::text_label(int bin) const
|
|||
case Particle::Type::positron:
|
||||
return "Particle: positron";
|
||||
}
|
||||
#ifdef __GNUC__
|
||||
__builtin_unreachable();
|
||||
#endif
|
||||
UNREACHABLE();
|
||||
}
|
||||
|
||||
} // namespace openmc
|
||||
|
|
|
|||
|
|
@ -329,7 +329,6 @@ Tally::set_scores(std::vector<std::string> scores)
|
|||
// Iterate over the given scores.
|
||||
for (auto score_str : scores) {
|
||||
// Make sure a delayed group filter wasn't used with an incompatible score.
|
||||
bool has_delayedgroup = delayedgroup_filter_ != C_NONE;
|
||||
if (delayedgroup_filter_ != C_NONE) {
|
||||
if (score_str != "delayed-nu-fission" && score_str != "decay-rate")
|
||||
fatal_error("Cannot tally " + score_str + "with a delayedgroup filter");
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ check_keff_trigger()
|
|||
if (settings::run_mode != RUN_MODE_EIGENVALUE) return 0.;
|
||||
|
||||
double k_combined[2];
|
||||
int err = openmc_get_keff(k_combined);
|
||||
openmc_get_keff(k_combined);
|
||||
|
||||
double uncertainty = 0.;
|
||||
switch (settings::keff_trigger.metric) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue