def test_create_from_data(self):
data = np.random.random_sample((50, 49, 31))
test = PFData(data)
self.assertEqual(31, test.getNX())
self.assertEqual(49, test.getNY())
self.assertEqual(50, test.getNZ())
self.assertEqual(1, test.getP())
self.assertEqual(1, test.getQ())
self.assertEqual(1, test.getR())
self.assertEqual(0, test.getX())
self.assertEqual(0, test.getY())
self.assertEqual(0, test.getZ())
test.writeFile(('test_write_raw.pfb'))
test_read = PFData(('test_write_raw.pfb'))
test_read.loadHeader()
test_read.loadData()
self.assertEqual(0, test_read.getX())
self.assertEqual(0, test_read.getY())
self.assertEqual(0, test_read.getZ())
self.assertEqual(31, test_read.getNX())
self.assertEqual(49, test_read.getNY())
self.assertEqual(50, test_read.getNZ())
self.assertEqual(1, test_read.getP())
self.assertEqual(1, test_read.getQ())
self.assertEqual(1, test_read.getR())
test_data = test_read.getDataAsArray()
self.assertIsNone(
np.testing.assert_array_equal(data, test_data),
'Data written to array should exist in '
'written PFB file.')
del data
test.close()
test_read.close()
os.remove(('test_write_raw.pfb'))
def write_pfb(data, outfile, x0=0, y0=0, z0=0, dx=1000, dz=1000):
"""Write a 3d numpy array to a PFB output file
Parameters
----------
data : ndarray
3d numpy data array to write to pfb !(x,y,z)!
outfile : str
filename and path to write output
x0 : int, optional
initial x location (Default value = 0)
y0 : int, optional
initial y location (Default value = 0)
z0 : int, optional
initial z location (Default value = 0)
dx : int, optional
horizontal resolution (Default value = 1000)
dz : int, optional
vertical resolution (Default value = 1000)
Returns
-------
None
"""
logging.info(f'wrote pfb file {outfile}, (z,y,x)={data.shape}')
pf_data = PFData()
pf_data.setDataArray(data)
pf_data.setDX(dx)
pf_data.setDY(dx)
pf_data.setDZ(dz)
pf_data.setX(x0)
pf_data.setY(y0)
pf_data.setZ(z0)
pf_data.writeFile(outfile)
def write_pfb_output(forcings_data, num_days, out_dir, dx, start_day_num=0):
varnames = ['APCP', 'DLWR', 'DSWR', 'Press', 'SPFH', 'Temp', 'UGRD', 'VGRD']
hours_in_file = 24
for var in tqdm(varnames):
file_time_start = start_day_num * hours_in_file
file_time_stop = file_time_start + hours_in_file
start = 0 # start hour (inclusive)
stop = hours_in_file # end hour (exclusive)
# start hour and stop hour for a day
# range is number of days contained in forcings file
for bulk_collect_times in range(0, num_days):
data_obj = PFData(np.nan_to_num(forcings_data[var].values[start:stop, :, :], nan=-9999.0))
data_obj.setDX(dx)
data_obj.setDY(dx)
data_obj.setDZ(dx)
data_obj.writeFile(os.path.join(out_dir, f'WRF.{var}.{file_time_start+1:06d}_to_{file_time_stop:06d}.pfb'))
del data_obj
start = stop
stop = stop + hours_in_file # size of day in hours
file_time_start = file_time_stop
file_time_stop = file_time_stop + hours_in_file
def pfwrite(arr, pfbfile, dx=1, dy=1, dz=1, overwrite=False):
"""
Save an ndarray to a pfb file
:param arr: ndarray to save (must be 3-dimensional)
:param pfbfile: path to pfb file
:param overwrite: whether to overwrite the file if it exists
:return: None on success. Raises Exception on failure.
"""
if os.path.exists(pfbfile) and not overwrite:
raise RuntimeError(f'{pfbfile} already exists')
assert arr.ndim == 3, 'Only 3D arrays are supported'
pfb_data = PFData()
pfb_data.setDataArray(arr)
pfb_data.setDX(dx)
pfb_data.setDY(dy)
pfb_data.setDZ(dz)
pfb_data.writeFile(pfbfile)
pfb_data.close()
def write_array_pfb(file_name, array):
# Ensure this is 3 dimensions, since parflowio requires 3 dimensions.
while array.ndim < 3:
array = array[np.newaxis, :]
if array.ndim > 3:
raise Exception(f'Too many dimensions: {array.ndim}')
from parflowio.pyParflowio import PFData
data = PFData()
data.setDataArray(array)
return data.writeFile(file_name)
def test_read_write_data(self):
test = PFData(('press.init.pfb'))
retval = test.loadHeader()
self.assertEqual(0, retval, 'should load header of file that exists')
retval = test.loadPQR()
self.assertEqual(0, retval, 'should load PQR of file that exists')
retval = test.loadData()
self.assertEqual(0, retval, 'should load data from valid file')
retval = test.writeFile(('press.init.pfb.tmp'))
self.assertEqual(0, retval,
'should write data from previously loaded file')
data2 = PFData(('press.init.pfb.tmp'))
data2.loadHeader()
data2.loadData()
data2.loadPQR()
self.assertIsNone(
np.testing.assert_array_equal(
test.viewDataArray(), data2.viewDataArray(),
'should read back same values we wrote'))
in_file_hash = calculate_sha1_hash(('press.init.pfb'))
out_file_hash = calculate_sha1_hash(('press.init.pfb.tmp'))
# This assertion (that the files are identical) is failing in Python and in C++
# because the original test input file was written by a tool that incorrectly set the value
self.assertNotEqual(
in_file_hash, out_file_hash,
'sha1 hash of input and output files should not match')
same, byte_diff = byte_compare_files(('press.init.pfb'),
('press.init.pfb.tmp'))
self.assertFalse(
same, 'press.init.pfb should differ from version just written')
self.assertEqual(92, byte_diff, 'first byte difference at byte 92')
test.close()
data2.close()
os.remove(('press.init.pfb.tmp'))
def test_manipulate_data(self):
test = PFData(('press.init.pfb'))
retval = test.loadHeader()
self.assertEqual(0, retval, 'should load header of file that exists')
retval = test.loadData()
self.assertEqual(0, retval, 'should load data from valid file')
test_data = test.getDataAsArray()
self.assertSequenceEqual(
(50, 41, 41), test_data.shape,
'test file array should have shape (50,41,41)')
self.assertAlmostEqual(98.003604098773, test(0, 0, 0), 12,
'valid data in cell (0,0,0)')
test_data[0, 0, 0] = 1
test_data[0, 0, 40] = 1
test_data[2, 1, 21] = 1
self.assertEqual(1, test(0, 0, 0),
'data update affects underlying array')
self.assertEqual(1, test(40, 0, 0),
'data update affects underlying array')
self.assertEqual(1, test(21, 1, 2),
'data update affects underlying array')
retval = test.writeFile(('press.init.pfb.tmp'))
self.assertEqual(0, retval,
'able to write updated data to output file')
test_read = PFData(('press.init.pfb.tmp'))
test_read.loadHeader()
test_read.loadData()
self.assertEqual(1, test_read(0, 0, 0),
'updates to data written to file can be read back')
self.assertEqual(1, test_read(40, 0, 0),
'updates to data written to file can be read back')
self.assertEqual(1, test_read(21, 1, 2),
'updates to data written to file can be read back')
test.close()
test_read.close()
os.remove(('press.init.pfb.tmp'))
#---------------------------------------------------------
rich_fbx.Solver.Nonlinear.FlowBarrierX = True
rich_fbx.FBx.Type = 'PFBFile'
rich_fbx.Geom.domain.FBx.FileName = 'Flow_Barrier_X.pfb'
## write flow boundary file
FBx_data = np.full((20, 20, 20), 1.0)
for i in range(20):
for j in range(20):
# from cell 10 (index 9) to cell 11
# reduction of 1E-3
FBx_data[i, j, 9] = 0.001
FBx_data_pfb = PFData(FBx_data)
FBx_data_pfb.writeFile(get_absolute_path('Flow_Barrier_X.pfb'))
FBx_data_pfb.close()
rich_fbx.dist('Flow_Barrier_X.pfb')
#-----------------------------------------------------------------------------
# Wells
#-----------------------------------------------------------------------------
rich_fbx.Wells.Names = ''
#-----------------------------------------------------------------------------
# Time Cycles
#-----------------------------------------------------------------------------
rich_fbx.Cycle.Names = 'constant'
def test_set_index_order(self):
test = PFData(('press.init.pfb'))
self.assertEqual(test.getIndexOrder(), 'zyx',
'indexOrder should equal \'zyx\'')
test.setIndexOrder('xyz')
self.assertEqual(test.getIndexOrder(), 'xyz',
'indexOrder should equal \'xyz\'')
test.setIndexOrder('xYz')
self.assertEqual(test.getIndexOrder(), 'xyz',
'indexOrder should equal \'xyz\'')
test.setIndexOrder('xYZ')
self.assertEqual(test.getIndexOrder(), 'xyz',
'indexOrder should equal \'xyz\'')
test.setIndexOrder('XYZ')
self.assertEqual(test.getIndexOrder(), 'xyz',
'indexOrder should equal \'xyz\'')
test.setIndexOrder('XYZZZZ')
self.assertEqual(test.getIndexOrder(), 'xyz',
'indexOrder should equal \'xyz\'')
# Should not work, should still equal 'xyz'
test.setIndexOrder('abc')
self.assertEqual(test.getIndexOrder(), 'xyz',
'indexOrder should equal \'xyz\'')
# Should not be able to write to file when indexOrder == 'xyz'
self.assertEqual(
test.writeFile(('test_write_index_order.pfb')), 1,
'Should not be able to write to file when indexOrder == \'xyz\'')
# Should equal 'zyx'
test.setIndexOrder('ZYX')
self.assertEqual(test.getIndexOrder(), 'zyx',
'indexOrder should equal \'zyx\'')
# Should equal 'zyx'
test.setIndexOrder('zYx')
self.assertEqual(test.getIndexOrder(), 'zyx',
'indexOrder should equal \'zyx\'')
# Should be able to write to file
self.assertEqual(
test.writeFile(('test_write_index_order.pfb')), 0,
'Should be able to write to file when indexOrder == \'zyx\'')
# Read file, indexOrder should equal 'zyx'
test_read = PFData(('test_write_index_order.pfb'))
test_read.loadHeader()
test_read.loadData()
self.assertEqual(test.getIndexOrder(), 'zyx',
'indexOrder should equal \'zyx\'')
test.close()
test_read.close()
os.remove(('test_write_index_order.pfb'))
nz = sandtank.ComputationalGrid.NZ
## write flow boundary file
flux_file_names = ['dry', 'rainflux_all', 'rainflux_left', 'rainflux_right']
for name in flux_file_names:
array = np.full((nz, ny, nx), 0.0)
if name == 'rainflux_all':
array[(nz - 1), :, :] = rain_flux * 2
if name == 'rainflux_left':
array[(nz - 1), :, 0:49] = rain_flux
if name == 'rainflux_right':
array[(nz - 1), :, 50:nx] = rain_flux
pfb = PFData(array)
pfb.writeFile(get_absolute_path(f'{name}.pfb'))
pfb.close()
sandtank.dist(f'{name}.pfb')
# -----------------------------------------------------------------------------
# Boundary Condition definitions
# -----------------------------------------------------------------------------
sandtank.BCPressure.PatchNames = sandtank.Geom.domain.Patches
sandtank.Patch.x_lower.BCPressure.Type = 'DirEquilRefPatch'
sandtank.Patch.x_lower.BCPressure.Cycle = 'constant'
sandtank.Patch.x_lower.BCPressure.RefGeom = 'domain'
sandtank.Patch.x_lower.BCPressure.RefPatch = 'z_lower'
sandtank.Patch.x_lower.BCPressure.alltime.Value = hleft