Code formatting cleanups.

gprMax/config.py

@@ -29,7 +29,7 @@ from .utilities import get_host_info
 # Impedance of free space (Ohms)
 z0 = np.sqrt(m0 / e0)
 
-# General setting for the simulation
+# General setting for the simulation
 #   inputfilepath: path to inputfile location
 #   outputfilepath: path to outputfile location
 #   messages: whether to print all messages as output to stdout or not

gprMax/gprMax.py

@@ -40,6 +40,7 @@ from .utilities import logo
 from .utilities import open_path_file
 from .utilities import timer
 
+
 def main():
     """This is the main function for gprMax."""
 
@@ -358,8 +359,6 @@ def run_mpi_sim(args, inputfile, usernamespace):
             workobj = dict()
             workobj['currentmodelrun'] = model
             workobj['mpicommname'] = comm.name
-            if optparams:
-                workobj['optparams'] = optparams
             worklist.append(workobj)
         # Add stop sentinels
         worklist += ([StopIteration] * numworkers)

gprMax/input_cmds_file.py

@@ -20,6 +20,7 @@ import os
 import sys
 from io import StringIO
 
+import gprMax.config as config
 from .exceptions import CmdInputError
 
 
@@ -162,7 +163,7 @@ def write_processed_file(processedlines, appendmodelnumber):
         appendmodelnumber (str): Text to append to filename.
     """
 
-    processedfile = os.path.join(outputfilepath, os.path.splitext(inputfilepath)[0] + appendmodelnumber + '_processed.in')
+    processedfile = os.path.join(config.general['outputfilepath'], os.path.splitext(config.general['inputfilepath'])[0] + appendmodelnumber + '_processed.in')
 
     with open(processedfile, 'w') as f:
         for item in processedlines:

gprMax/input_cmds_multiuse.py

@@ -316,7 +316,7 @@ def process_multicmds(multicmds, G):
                 raise CmdInputError("'" + cmdname + ': ' + ' '.join(tmp) + "'" + ' requires at least six parameters')
 
             # Warn about using a transmission line on GPU
-            if gpus is not None:
+            if config.cuda['gpus'] is not None:
                 raise CmdInputError("'" + cmdname + ': ' + ' '.join(tmp) + "'" + ' A #transmission_line cannot currently be used with GPU solving. Consider using a #voltage_source instead.')
 
             # Check polarity & position parameters

gprMax/model_build_run.py

@@ -33,6 +33,7 @@ from tqdm import tqdm
 
 import gprMax.config as config
 from .cuda.fields_updates import kernel_template_fields
+from .cuda.snapshots import kernel_template_store_snapshot
 from .cuda.source_updates import kernel_template_sources
 from .cython.fields_updates_normal import update_electric
 from .cython.fields_updates_normal import update_magnetic
@@ -495,19 +496,19 @@ def solve_gpu(currentmodelrun, modelend, G):
 
     # Electric and magnetic field updates - prepare kernels, get kernel functions, and initialise arrays on GPU
     if config.materials['maxpoles'] == 0:
-        kernels_fields = SourceModule(kernels_template_fields.substitute(REAL=config.dtypes['C_float_or_double'], REAL_OR_COMPLEX=config.dtypes['C_complex'], N_updatecoeffsE=G.updatecoeffsE.size, N_updatecoeffsH=G.updatecoeffsH.size, NY_MATCOEFFS=G.updatecoeffsE.shape[1], NY_MATDISPCOEFFS=1, NX_FIELDS=G.Ex.shape[0], NY_FIELDS=G.Ex.shape[1], NZ_FIELDS=G.Ex.shape[2], NX_ID=G.ID.shape[1], NY_ID=G.ID.shape[2], NZ_ID=G.ID.shape[3], NX_T=1, NY_T=1, NZ_T=1), options=compiler_opts)
+        kernel_fields = SourceModule(kernel_template_fields.substitute(REAL=config.dtypes['C_float_or_double'], REAL_OR_COMPLEX=config.dtypes['C_complex'], N_updatecoeffsE=G.updatecoeffsE.size, N_updatecoeffsH=G.updatecoeffsH.size, NY_MATCOEFFS=G.updatecoeffsE.shape[1], NY_MATDISPCOEFFS=1, NX_FIELDS=G.Ex.shape[0], NY_FIELDS=G.Ex.shape[1], NZ_FIELDS=G.Ex.shape[2], NX_ID=G.ID.shape[1], NY_ID=G.ID.shape[2], NZ_ID=G.ID.shape[3], NX_T=1, NY_T=1, NZ_T=1), options=compiler_opts)
 
     else:   # # If there are any dispersive materials (updates are split into two parts as they require present and updated electric field values).
-        kernels_fields = SourceModule(kernels_template_fields.substitute(REAL=config.dtypes['C_float_or_double'], REAL_OR_COMPLEX=config.dtypes['C_complex'], N_updatecoeffsE=G.updatecoeffsE.size, N_updatecoeffsH=G.updatecoeffsH.size, NY_MATCOEFFS=G.updatecoeffsE.shape[1], NY_MATDISPCOEFFS=G.updatecoeffsdispersive.shape[1], NX_FIELDS=G.Ex.shape[0], NY_FIELDS=G.Ex.shape[1], NZ_FIELDS=G.Ex.shape[2], NX_ID=G.ID.shape[1], NY_ID=G.ID.shape[2], NZ_ID=G.ID.shape[3], NX_T=G.Tx.shape[1], NY_T=G.Tx.shape[2], NZ_T=G.Tx.shape[3]), options=compiler_opts)
-        update_e_dispersive_A_gpu = kernels_fields.get_function("update_e_dispersive_A")
-        update_e_dispersive_B_gpu = kernels_fields.get_function("update_e_dispersive_B")
+        kernel_fields = SourceModule(kernel_template_fields.substitute(REAL=config.dtypes['C_float_or_double'], REAL_OR_COMPLEX=config.dtypes['C_complex'], N_updatecoeffsE=G.updatecoeffsE.size, N_updatecoeffsH=G.updatecoeffsH.size, NY_MATCOEFFS=G.updatecoeffsE.shape[1], NY_MATDISPCOEFFS=G.updatecoeffsdispersive.shape[1], NX_FIELDS=G.Ex.shape[0], NY_FIELDS=G.Ex.shape[1], NZ_FIELDS=G.Ex.shape[2], NX_ID=G.ID.shape[1], NY_ID=G.ID.shape[2], NZ_ID=G.ID.shape[3], NX_T=G.Tx.shape[1], NY_T=G.Tx.shape[2], NZ_T=G.Tx.shape[3]), options=compiler_opts)
+        update_e_dispersive_A_gpu = kernel_fields.get_function("update_e_dispersive_A")
+        update_e_dispersive_B_gpu = kernel_fields.get_function("update_e_dispersive_B")
         G.gpu_initialise_dispersive_arrays()
-    update_e_gpu = kernels_fields.get_function("update_e")
-    update_h_gpu = kernels_fields.get_function("update_h")
+    update_e_gpu = kernel_fields.get_function("update_e")
+    update_h_gpu = kernel_fields.get_function("update_h")
 
     # Copy material coefficient arrays to constant memory of GPU (must be <64KB) for fields kernels
-    updatecoeffsE = kernels_fields.get_global('updatecoeffsE')[0]
-    updatecoeffsH = kernels_fields.get_global('updatecoeffsH')[0]
+    updatecoeffsE = kernel_fields.get_global('updatecoeffsE')[0]
+    updatecoeffsH = kernel_fields.get_global('updatecoeffsH')[0]
     if G.updatecoeffsE.nbytes + G.updatecoeffsH.nbytes > config.cuda['gpus'].constmem:
         raise GeneralError('Too many materials in the model to fit onto constant memory of size {} on {} - {} GPU'.format(human_size(config.cuda['gpus'].constmem), config.cuda['gpus'].deviceID, config.cuda['gpus'].name))
     else:
@@ -547,21 +548,21 @@ def solve_gpu(currentmodelrun, modelend, G):
 
     # Sources - initialise arrays on GPU, prepare kernel and get kernel functions
     if G.voltagesources + G.hertziandipoles + G.magneticdipoles:
-        kernels_sources = SourceModule(kernels_template_sources.substitute(REAL=config.dtypes['C_float_or_double'], N_updatecoeffsE=G.updatecoeffsE.size, N_updatecoeffsH=G.updatecoeffsH.size, NY_MATCOEFFS=G.updatecoeffsE.shape[1], NY_SRCINFO=4, NY_SRCWAVES=G.iterations, NX_FIELDS=G.Ex.shape[0], NY_FIELDS=G.Ex.shape[1], NZ_FIELDS=G.Ex.shape[2], NX_ID=G.ID.shape[1], NY_ID=G.ID.shape[2], NZ_ID=G.ID.shape[3]), options=compiler_opts)
+        kernel_sources = SourceModule(kernel_template_sources.substitute(REAL=config.dtypes['C_float_or_double'], N_updatecoeffsE=G.updatecoeffsE.size, N_updatecoeffsH=G.updatecoeffsH.size, NY_MATCOEFFS=G.updatecoeffsE.shape[1], NY_SRCINFO=4, NY_SRCWAVES=G.iterations, NX_FIELDS=G.Ex.shape[0], NY_FIELDS=G.Ex.shape[1], NZ_FIELDS=G.Ex.shape[2], NX_ID=G.ID.shape[1], NY_ID=G.ID.shape[2], NZ_ID=G.ID.shape[3]), options=compiler_opts)
         # Copy material coefficient arrays to constant memory of GPU (must be <64KB) for source kernels
-        updatecoeffsE = kernels_sources.get_global('updatecoeffsE')[0]
-        updatecoeffsH = kernels_sources.get_global('updatecoeffsH')[0]
+        updatecoeffsE = kernel_sources.get_global('updatecoeffsE')[0]
+        updatecoeffsH = kernel_sources.get_global('updatecoeffsH')[0]
         drv.memcpy_htod(updatecoeffsE, G.updatecoeffsE)
         drv.memcpy_htod(updatecoeffsH, G.updatecoeffsH)
         if G.hertziandipoles:
             srcinfo1_hertzian_gpu, srcinfo2_hertzian_gpu, srcwaves_hertzian_gpu = gpu_initialise_src_arrays(G.hertziandipoles, G)
-            update_hertzian_dipole_gpu = kernels_sources.get_function("update_hertzian_dipole")
+            update_hertzian_dipole_gpu = kernel_sources.get_function("update_hertzian_dipole")
         if G.magneticdipoles:
             srcinfo1_magnetic_gpu, srcinfo2_magnetic_gpu, srcwaves_magnetic_gpu = gpu_initialise_src_arrays(G.magneticdipoles, G)
-            update_magnetic_dipole_gpu = kernels_sources.get_function("update_magnetic_dipole")
+            update_magnetic_dipole_gpu = kernel_sources.get_function("update_magnetic_dipole")
         if G.voltagesources:
             srcinfo1_voltage_gpu, srcinfo2_voltage_gpu, srcwaves_voltage_gpu = gpu_initialise_src_arrays(G.voltagesources, G)
-            update_voltage_source_gpu = kernels_sources.get_function("update_voltage_source")
+            update_voltage_source_gpu = kernel_sources.get_function("update_voltage_source")
 
     # Snapshots - initialise arrays on GPU, prepare kernel and get kernel functions
     if G.snapshots:

gprMax/pml.py

@@ -163,7 +163,7 @@ class PML(object):
 
     # Available PML formulations:
     # Higher Order RIPML (HORIPML) see: https://doi.org/10.1109/TAP.2011.2180344
-    # Multipole RIPML (MRIPML) see: https://doi.org/10.1109/TAP.2018.2823864
+    # Multipole RIPML (MRIPML) see: https://doi.org/10.1109/TAP.2018.2823864
     formulations = ['HORIPML', 'MRIPML']
 
     # PML slabs IDs at boundaries of domain.

gprMax/receivers.py

@@ -89,5 +89,5 @@ def gpu_get_rx_array(rxs_gpu, rxcoords_gpu, G):
             if rx.xcoord == rxcoords_gpu[rxgpu, 0] and \
                rx.ycoord == rxcoords_gpu[rxgpu, 1] and \
                rx.zcoord == rxcoords_gpu[rxgpu, 2]:
-                for k, v in rx.outputs.items():
-                    v = rxs_gpu[Rx.gpu_allowableoutputs.index(k), :, rxgpu]
+                for k in rx.outputs.items():
+                    rx.outputs[k] = rxs_gpu[Rx.gpu_allowableoutputs.index(k), :, rxgpu]

gprMax/snapshots.py

@@ -224,7 +224,7 @@ def gpu_initialise_snapshot_array(G):
 
     # 4D arrays to store snapshots on GPU, e.g. snapEx(time, x, y, z);
     # if snapshots are not being stored on the GPU during the simulation then
-    # they are copied back to the host after each iteration, hence numsnaps = 1
+    # they are copied back to the host after each iteration, hence numsnaps = 1
     numsnaps = 1 if config.cuda['snapsgpu2cpu'] else len(G.snapshots)
     snapEx = np.zeros((numsnaps, Snapshot.nx_max, Snapshot.ny_max, Snapshot.nz_max),
                       dtype=config.dtypes['float_or_double'])

gprMax/utilities.py

@@ -414,6 +414,7 @@ def detect_check_gpus(deviceIDs):
 
     return gpus, allgpustext
 
+
 def timer():
     """Function to return the current process wide time in fractional seconds."""
     return perf_counter()