def _parse_statepoint(self, statepoint, tally_id=1): """Parses a statepoint file and reads in the relevant fluxes, assigns them to the DataSources or the XSCache, and returns k, phi_g, and E_g. Parameters ---------- statepoint : xsgen.statepoint.StatePoint An OpenMC StatePoint. tally_id : int The tally id we wish to read group flux from. Returns ------- k : float Neutron multiplication factor. phi_g : list of floats Group flux. e_g : list of floats Group structure. """ sp = StatePoint(statepoint) sp.read_results() # compute group fluxes for data sources for tally, ds in zip(sp.tallies[1:3], (self.eafds, self.omcds)): ds.src_phi_g = tally.results[::-1, :, 0].flatten() ds.src_phi_g /= ds.src_phi_g.sum() # compute return values k, kerr = sp.k_combined tally = sp.tallies[tally_id - 1] phi_g = tally.results[::-1, :, 0].flatten() phi_g /= phi_g.sum() e_g = tally.filters["energyin"].bins return k, phi_g, e_g
def _parse_statepoint(self, statepoint): """Parses a statepoint file and reads in the relevant fluxes, assigns them to the DataSources or the XSCache, and returns k and phi_g. """ sp = StatePoint(statepoint) sp.read_results() # compute group fluxes for data sources for tally, ds in zip(sp.tallies[1:4], (self.cinderds, self.eafds, self.omcds)): ds.src_phi_g = tally.results[::-1, :, 0].flatten() ds.src_phi_g /= ds.src_phi_g.sum() # compute return values k, kerr = sp.k_combined t_flux = sp.tallies[0] phi_g = t_flux.results[::-1, :, 0].flatten() phi_g /= phi_g.sum() return k, phi_g
import numpy as np import scipy.stats import matplotlib.pyplot as plt from statepoint import StatePoint # Get filename filename = argv[1] # Determine axial level axial_level = int(argv[2]) if len(argv) > 2 else 1 score = int(argv[3]) if len(argv) > 3 else 1 # Create StatePoint object sp = StatePoint(filename) # Read number of realizations for global tallies sp.n_realizations = sp._get_int()[0] # Read global tallies n_global_tallies = sp._get_int()[0] sp.global_tallies = np.array(sp._get_double(2 * n_global_tallies)) sp.global_tallies.shape = (n_global_tallies, 2) # Flag indicating if tallies are present tallies_present = sp._get_int()[0] # Check if tallies are present if not tallies_present: raise Exception("No tally data in state point!")
import numpy as np import scipy.stats import matplotlib.pyplot as plt from statepoint import StatePoint # Get filename filename = argv[1] # Determine axial level axial_level = int(argv[2]) if len(argv) > 2 else 1 score = int(argv[3]) if len(argv) > 3 else 1 # Create StatePoint object sp = StatePoint(filename) # Read number of realizations for global tallies sp.n_realizations = sp._get_int()[0] # Read global tallies n_global_tallies = sp._get_int()[0] sp.global_tallies = np.array(sp._get_double(2*n_global_tallies)) sp.global_tallies.shape = (n_global_tallies, 2) # Flag indicating if tallies are present tallies_present = sp._get_int()[0] # Check if tallies are present if not tallies_present: raise Exception("No tally data in state point!")
assemblies = ['Fuel-1.6wo-CRD', \ 'Fuel-2.4wo-16BA-grid-56', \ 'Fuel-3.1wo-instr-16BA-grid-17'] # Loop over assemblies for assembly in assemblies: print 'Exporting ' + assembly # Create an HDF5 group for this assembly in our 'targets.h5' file assembly_group = f.create_group(assembly) high_energy = assembly_group.create_group('High Energy') low_energy = assembly_group.create_group('Low Energy') # Import the OpenMC results for this assembly sp = StatePoint('../openmc-input/'+assembly+'/pinwise/statepoint.1250.h5') sp.read_results() # Extract 2D numpy arrays of the batch means for each type of tally flux = sp.extract_results(1, 'flux')['mean'] tot_rxn_rate = sp.extract_results(1, 'total')['mean'] abs_rxn_rate = sp.extract_results(1, 'absorption')['mean'] fiss_rxn_rate = sp.extract_results(1, 'fission')['mean'] nufiss_rxn_rate = sp.extract_results(1, 'nu-fission')['mean'] # Reshape to grid with energy group as third index flux = np.reshape(flux, (x, y, groups)) tot_rxn_rate = np.reshape(tot_rxn_rate, (x, y, groups)) abs_rxn_rate = np.reshape(abs_rxn_rate, (x, y, groups)) fiss_rxn_rate = np.reshape(fiss_rxn_rate, (x, y, groups)) nufiss_rxn_rate = np.reshape(nufiss_rxn_rate, (x, y, groups))
def main(file_, o): """Main program""" sp = StatePoint(file_) sp.read_results() validate_options(sp, o) if o.list: print_available(sp) return if o.vtk: if not o.output[-4:] == ".vtm": o.output += ".vtm" else: if not o.output[-5:] == ".silo": o.output += ".silo" if o.vtk: try: import vtk except: print('The vtk python bindings do not appear to be installed properly.\n' 'On Ubuntu: sudo apt-get install python-vtk\n' 'See: http://www.vtk.org/') return else: try: import silomesh except: print('The silomesh package does not appear to be installed properly.\n' 'See: https://github.com/nhorelik/silomesh/') return if o.vtk: blocks = vtk.vtkMultiBlockDataSet() blocks.SetNumberOfBlocks(5) block_idx = 0 else: silomesh.init_silo(o.output) # Tally loop ################################################################# for tally in sp.tallies: # skip non-mesh tallies or non-user-specified tallies if o.tallies and not tally.id in o.tallies: continue if not 'mesh' in tally.filters: continue print("Processing Tally {}...".format(tally.id)) # extract filter options and mesh parameters for this tally filtercombos = get_filter_combos(tally) meshparms = get_mesh_parms(sp, tally) nx,ny,nz = meshparms[:3] ll = meshparms[3:6] ur = meshparms[6:9] if o.vtk: ww = [(u-l)/n for u,l,n in zip(ur,ll,(nx,ny,nz))] grid = grid = vtk.vtkImageData() grid.SetDimensions(nx+1,ny+1,nz+1) grid.SetOrigin(*ll) grid.SetSpacing(*ww) else: silomesh.init_mesh('Tally_{}'.format(tally.id), *meshparms) # Score loop ############################################################### for sid,score in enumerate(tally.scores): # skip non-user-specified scrores for this tally if o.scores and tally.id in o.scores and not sid in o.scores[tally.id]: continue # Filter loop ############################################################ for filterspec in filtercombos: # skip non-user-specified filter bins skip = False if o.filters and tally.id in o.filters: for filter_,bin in filterspec[1:]: if filter_ in o.filters[tally.id] and \ not bin in o.filters[tally.id][filter_]: skip = True break if skip: continue # find and sanitize the variable name for this score varname = get_sanitized_filterspec_name(tally, score, filterspec) if o.vtk: vtkdata = vtk.vtkDoubleArray() vtkdata.SetName(varname) dataforvtk = {} else: silomesh.init_var(varname) lbl = "\t Score {}.{} {}:\t\t{}".format(tally.id, sid+1, score, varname) # Mesh fill loop ####################################################### for x in range(1,nx+1): sys.stdout.write(lbl+" {0}%\r".format(int(x/nx*100))) sys.stdout.flush() for y in range(1,ny+1): for z in range(1,nz+1): filterspec[0][1] = (x,y,z) val = sp.get_value(tally.id-1, filterspec, sid)[o.valerr] if o.vtk: # vtk cells go z, y, x, so we store it now and enter it later i = (z-1)*nx*ny + (y-1)*nx + x-1 dataforvtk[i] = float(val) else: silomesh.set_value(float(val), x, y, z) # end mesh fill loop print() if o.vtk: for i in range(nx*ny*nz): vtkdata.InsertNextValue(dataforvtk[i]) grid.GetCellData().AddArray(vtkdata) del vtkdata else: silomesh.finalize_var() # end filter loop # end score loop if o.vtk: blocks.SetBlock(block_idx, grid) block_idx += 1 else: silomesh.finalize_mesh() # end tally loop if o.vtk: writer = vtk.vtkXMLMultiBlockDataWriter() writer.SetFileName(o.output) writer.SetInput(blocks) writer.Write() else: silomesh.finalize_silo()
#!/usr/bin/env python from sys import argv from math import sqrt import numpy as np import scipy.stats import matplotlib import matplotlib.pyplot as plt from statepoint import StatePoint # Create StatePoint object sp1 = StatePoint('without-ufs.state') sp2 = StatePoint('with-ufs.state') sp1._get_int() sp2._get_int() # Calculate t-value for 95% two-sided CI n = sp1.current_batch - sp1.n_inactive t_value = scipy.stats.t.ppf(0.975, n - 1) ################################ WITHOUT UFS ################################### for t in sp1.tallies: n_bins = t.n_score_bins * t.n_filter_bins i_mesh = [f.type for f in t.filters].index('mesh') # Get Mesh object m = sp1.meshes[t.filters[i_mesh].bins[0] - 1] nx, ny, nz = m.dimension
#!/usr/bin/env python from sys import argv from math import sqrt import scipy.stats import matplotlib.pyplot as plt import numpy as np from statepoint import StatePoint # Create StatePoint object sp1 = StatePoint('without-ufs.state') sp2 = StatePoint('with-ufs.state') # Calculate t-value for 95% two-sided CI n = sp1.current_batch - sp1.n_inactive t_value = scipy.stats.t.ppf(0.975, n - 1) # Get uncertainties for without UFS sp1.read_values() unc1 = [] for s, s2 in sp1.tallies[0].values[:,0,:]: s /= n if s != 0.0: relative_error = t_value*sqrt((s2/n - s*s)/(n-1))/s unc1.append(relative_error) # Get uncertainties for with UFS sp2.read_values() unc2 = []
def main(file_, o): """Main program""" sp = StatePoint(file_) sp.read_results() validate_options(sp, o) if o.list: print_available(sp) return silomesh.init_silo(o.output) # Tally loop ################################################################# for tally in sp.tallies: # skip non-mesh tallies or non-user-specified tallies if o.tallies and not tally.id in o.tallies: continue if not 'mesh' in tally.filters: continue print "Processing Tally {}...".format(tally.id) # extract filter options and mesh parameters for this tally filtercombos = get_filter_combos(tally) meshparms = get_mesh_parms(sp, tally) nx, ny, nz = meshparms[0], meshparms[1], meshparms[2] silomesh.init_mesh('Tally_{}'.format(tally.id), *meshparms) # Score loop ############################################################### for sid, score in enumerate(tally.scores): # skip non-user-specified scrores for this tally if o.scores and tally.id in o.scores and not sid in o.scores[ tally.id]: continue # Filter loop ############################################################ for filterspec in filtercombos: # skip non-user-specified filter bins skip = False if o.filters and tally.id in o.filters: for filter_, bin in filterspec[1:]: if filter_ in o.filters[tally.id] and \ not bin in o.filters[tally.id][filter_]: skip = True break if skip: continue # find and sanitize the variable name for this score varname = get_sanitized_filterspec_name( tally, score, filterspec) silomesh.init_var(varname) print "\t Score {}.{} {}:\t\t{}".format( tally.id, sid + 1, score, varname) # Mesh fill loop ####################################################### for x in range(1, nx + 1): for y in range(1, ny + 1): for z in range(1, nz + 1): filterspec[0][1] = (x, y, z) val = sp.get_value(tally.id - 1, filterspec, sid)[o.valerr] silomesh.set_value(float(val), x, y, z) # end mesh fill loop silomesh.finalize_var() # end filter loop # end score loop silomesh.finalize_mesh() # end tally loop silomesh.finalize_silo()
#!/usr/bin/env python import sys from numpy.testing import assert_allclose, assert_equal from statepoint import StatePoint if len(sys.argv) > 2: path1 = sys.argv[1] path2 = sys.argv[2] else: raise # Create StatePoint objects sp1 = StatePoint(path1) sp2 = StatePoint(path2) # Read tally results sp1.read_results() sp2.read_results() # Compare header information assert sp1.revision == sp2.revision assert sp1.version == sp2.version assert sp1.seed == sp2.seed assert sp1.run_mode == sp2.run_mode assert sp1.n_particles == sp2.n_particles assert sp1.n_batches == sp2.n_batches if sp1.run_mode == 2:
def main(file_, o): """Main program""" sp = StatePoint(file_) sp.read_results() validate_options(sp, o) if o.list: print_available(sp) return silomesh.init_silo(o.output) # Tally loop ################################################################# for tally in sp.tallies: # skip non-mesh tallies or non-user-specified tallies if o.tallies and not tally.id in o.tallies: continue if not 'mesh' in tally.filters: continue print "Processing Tally {}...".format(tally.id) # extract filter options and mesh parameters for this tally filtercombos = get_filter_combos(tally) meshparms = get_mesh_parms(sp, tally) nx,ny,nz = meshparms[0], meshparms[1], meshparms[2] silomesh.init_mesh('Tally_{}'.format(tally.id), *meshparms) # Score loop ############################################################### for sid,score in enumerate(tally.scores): # skip non-user-specified scrores for this tally if o.scores and tally.id in o.scores and not sid in o.scores[tally.id]: continue # Filter loop ############################################################ for filterspec in filtercombos: # skip non-user-specified filter bins skip = False if o.filters and tally.id in o.filters: for filter_,bin in filterspec[1:]: if filter_ in o.filters[tally.id] and \ not bin in o.filters[tally.id][filter_]: skip = True break if skip: continue # find and sanitize the variable name for this score varname = get_sanitized_filterspec_name(tally, score, filterspec) silomesh.init_var(varname) print "\t Score {}.{} {}:\t\t{}".format(tally.id, sid+1, score, varname) # Mesh fill loop ####################################################### for x in range(1,nx+1): for y in range(1,ny+1): for z in range(1,nz+1): filterspec[0][1] = (x,y,z) val = sp.get_value(tally.id-1, filterspec, sid)[o.valerr] silomesh.set_value(float(val), x, y, z) # end mesh fill loop silomesh.finalize_var() # end filter loop # end score loop silomesh.finalize_mesh() # end tally loop silomesh.finalize_silo()
# energy options are 1 or 2 energy = 2 num_groups = 2 # Mesh is 17x17 or 51x51 mesh_x_dim = 17 mesh_y_dim = 17 ################################################################################ # Create plot of initial data to start animation ################################################################################ # Instantiate statepoint for the first batch of tally data print directory + 'statepoint.' + str(batch_start) + '.h5' sp = StatePoint(directory + 'statepoint.' + str(batch_start) + '.h5') sp.read_results() tallyid = 1 tally1_data = sp.extract_results(tallyid, score1) tally2_data = sp.extract_results(tallyid, score2) tally1_means = tally1_data['mean'] tally1_std_dev = np.nan_to_num(tally1_data['CI95']) tally2_means = tally2_data['mean'] tally2_std_dev = np.nan_to_num(tally2_data['CI95']) # Reshape to grid with energy as third index tally1_means = np.reshape(tally1_means,(mesh_x_dim, mesh_y_dim, num_groups)) tally1_std_dev = np.reshape(tally1_std_dev,(mesh_x_dim, mesh_y_dim, num_groups)) tally2_means = np.reshape(tally2_means,(mesh_x_dim, mesh_y_dim, num_groups)) tally2_std_dev = np.reshape(tally2_std_dev,(mesh_x_dim, mesh_y_dim, num_groups))
#!/usr/bin/env python from sys import argv from math import sqrt import scipy.stats import matplotlib.pyplot as plt import numpy as np from statepoint import StatePoint # Create StatePoint object sp1 = StatePoint('without-ufs.state') sp2 = StatePoint('with-ufs.state') # Calculate t-value for 95% two-sided CI n = sp1.current_batch - sp1.n_inactive t_value = scipy.stats.t.ppf(0.975, n - 1) # Get uncertainties for without UFS sp1.read_values() unc1 = [] for s, s2 in sp1.tallies[0].values[:, 0, :]: s /= n if s != 0.0: relative_error = t_value * sqrt((s2 / n - s * s) / (n - 1)) / s unc1.append(relative_error) # Get uncertainties for with UFS sp2.read_values() unc2 = []