def _read_model_data(self): """ read in the files to get appropriate information """ # --> read in model file if self.model_fn is not None and os.path.isfile(self.model_fn): md_model = Model() md_model.read_model_file(self.model_fn) self.res_model = md_model.res_model self.grid_east = md_model.grid_east / self.dscale self.grid_north = md_model.grid_north / self.dscale self.grid_z = md_model.grid_z / self.dscale self.nodes_east = md_model.nodes_east / self.dscale self.nodes_north = md_model.nodes_north / self.dscale self.nodes_z = md_model.nodes_z / self.dscale else: raise Exception('Error with the Model file: %s. Please check.' % (self.model_fn)) # --> Optionally: read in data file to get station locations if self.data_fn is not None and os.path.isfile(self.data_fn): md_data = Data() md_data.read_data_file(self.data_fn) self.station_east = md_data.station_locations[ 'rel_east'] / self.dscale # convert meters self.station_north = md_data.station_locations[ 'rel_north'] / self.dscale self.station_names = md_data.station_locations['station'] else: print(('Problem with the optional Data file: %s. Please check.' % self.data_fn)) total_horizontal_slices = self.grid_z.shape[0] print(("Total Number of H-slices=", total_horizontal_slices)) return total_horizontal_slices
def test_read_gocad_sgrid_file(self): if not os.path.isdir(self._model_dir): self._model_dir = None output_fn = os.path.basename(self._model_fn) # read data file to get centre position dObj = Data() dObj.read_data_file(data_fn=self._data_fn) # create a model object using the data object and read in gocad sgrid file mObj = Model(data_obj=dObj, save_path=self._output_dir) mObj.read_gocad_sgrid_file(self._sgrid_fn) mObj.write_model_file() output_data_file = os.path.normpath( os.path.join(self._output_dir, output_fn)) self.assertTrue(os.path.isfile(output_data_file), "output data file not found") expected_data_file = os.path.normpath(self._model_fn_old_z_mesh) self.assertTrue( os.path.isfile(expected_data_file), "Ref output data file does not exist, nothing to compare with") is_identical, msg = diff_files(output_data_file, expected_data_file) print(msg) self.assertTrue( is_identical, "The output file is not the same with the baseline file.")
def read_files(self): """ read in the files to get appropriate information """ # --> read in model file if self.model_fn is not None: if os.path.isfile(self.model_fn) == True: md_model = Model() md_model.read_model_file(self.model_fn) self.res_model = md_model.res_model self.grid_east = md_model.grid_east / self.dscale self.grid_north = md_model.grid_north / self.dscale self.grid_z = md_model.grid_z / self.dscale self.nodes_east = md_model.nodes_east / self.dscale self.nodes_north = md_model.nodes_north / self.dscale self.nodes_z = md_model.nodes_z / self.dscale else: raise mtex.MTpyError_file_handling( '{0} does not exist, check path'.format(self.model_fn)) # --> read in data file to get station locations if self.data_fn is not None: if os.path.isfile(self.data_fn) == True: md_data = Data() md_data.read_data_file(self.data_fn) self.station_east = md_data.station_locations.rel_east / self.dscale self.station_north = md_data.station_locations.rel_north / self.dscale self.station_elev = md_data.station_locations.elev / self.dscale self.station_names = md_data.station_locations.station else: print 'Could not find data file {0}'.format(self.data_fn)
def main(data_file, model_file, output_file, source_proj=None): """ Generate an output netcdf file from data_file and model_file :param data_file: modem.dat :param model_file: modem.rho :param output_file: output.nc :param source_proj: None by defult. The UTM zone infered from the input non-uniform grid parameters :return: """ # Define Data and Model Paths data = Data() data.read_data_file(data_fn=data_file) # create a model object using the data object and read in model data model = Model(data_obj=data) model.read_model_file(model_fn=model_file) center = data.center_point if source_proj is None: zone_number, is_northern, utm_zone = gis_tools.get_utm_zone( center.lat.item(), center.lon.item()) #source_proj = Proj('+proj=utm +zone=%d +%s +datum=%s' % (zone_number, 'north' if is_northern else 'south', 'WGS84')) epsg_code = gis_tools.get_epsg(center.lat.item(), center.lon.item()) print("Input data epsg code is infered as ", epsg_code) else: epsg_code = source_proj # integer source_proj = Proj(init='epsg:' + str(epsg_code)) resistivity_data = { 'x': center.east.item() + (model.grid_east[1:] + model.grid_east[:-1]) / 2, 'y': center.north.item() + (model.grid_north[1:] + model.grid_north[:-1]) / 2, 'z': (model.grid_z[1:] + model.grid_z[:-1]) / 2, 'resistivity': np.transpose(model.res_model, axes=(2, 0, 1)) } grid_proj = Proj( init='epsg:4326') # output grid Coordinate systems: 4326, 4283, 3112 grid_proj = Proj( init='epsg:4283') # output grid Coordinate system 4326, 4283, 3112 grid_proj = Proj( init='epsg:3112') # output grid Coordinate system 4326, 4283, 3112 result = interpolate(resistivity_data, source_proj, grid_proj, center, median_spacing(model.grid_east), median_spacing(model.grid_north)) nc.write_resistivity_grid(output_file, grid_proj, result['latitude'], result['longitude'], result['depth'], result['resistivity'], z_label='depth')
def process_phase_tensors(dat_file, output_dir): print("Input path/datfile ---------> {}".format(dat_file)) print("Output directory ---------> {}".format(output_dir)) if not os.path.exists(output_dir): os.makedirs(output_dir) if os.path.isfile(dat_file): obj = Data() obj.compute_phase_tensor(dat_file, output_dir) else: print("Please provide an input dat file !")
def _read_files(self): """ get information from files """ # --> read in data file self.data_obj = Data() self.data_obj.read_data_file(self.data_fn) # --> read response file if self.resp_fn is not None: self.resp_obj = Data() self.resp_obj.read_data_file(self.resp_fn) # --> read mode file if self.model_fn is not None: self.model_obj = Model() self.model_obj.read_model_file(self.model_fn) self._get_plot_period_list() self._get_pt()
def _test_func(self): if not os.path.isdir(edi_path): # input file does not exist, skip test after remove the output dir os.rmdir(self._output_dir) self.skipTest("edi path does not exist: {}".format(edi_path)) # generate data edi_list = glob.glob(edi_path + '/*.edi') period_list = EdiCollection(edi_list).select_periods() datob = Data(edi_list=edi_list, inv_mode='1', period_list=period_list, epsg=epsg_code, error_type_tipper='abs', error_type_z='egbert', comp_error_type=None, error_floor=10) datob.write_data_file(save_path=self._output_dir) # create mesh grid model object model = Model( stations_object=datob.station_locations, Data=datob, epsg=epsg_code, cell_size_east=10000, cell_size_north=10000, # GA_VIC pad_north= 8, # number of padding cells in each of the north and south directions pad_east=8, # number of east and west padding cells pad_z=8, # number of vertical padding cells pad_stretch_v= 1.5, # factor to increase by in padding cells (vertical) pad_stretch_h= 1.5, # factor to increase by in padding cells (horizontal) n_air_layers= 0, # number of air layers 0, 10, 20, depend on topo elev height res_model= 100, # halfspace resistivity value for initial reference model n_layers=50, # total number of z layers, including air and pad_z z1_layer=50, # first layer thickness metres, depend z_target_depth=500000) model.make_mesh( ) # the data file will be re-write in this method. No topo elev file used yet model.plot_mesh() model.plot_mesh_xy() model.plot_mesh_xz() # write a model file and initialise a resistivity model model.write_model_file(save_path=self._output_dir)
def test_func(self): if not os.path.isdir(edi_path): # input file does not exist, skip test after remove the output dir os.rmdir(self._output_dir) self.skipTest("edi path does not exist: {}".format(edi_path)) edi_list = glob.glob(edi_path + '/*.edi') period_list = EdiCollection(edi_list).select_periods() datob = Data(edi_list=edi_list, inv_mode='1', period_list=period_list, epsg=epsg_code, error_type_tipper=error_type_tipper, error_type_z=error_type_z, comp_error_type=comp_error_type, error_floor=10) datob.write_data_file(save_path=self._output_dir) # check the output if self._expected_output_dir: output_data_file = os.path.normpath(os.path.join(self._output_dir, "ModEM_Data.dat")) self.assertTrue(os.path.isfile(output_data_file), "output data file does not exist") expected_data_file = os.path.normpath(os.path.join(self._expected_output_dir, "ModEM_Data.dat")) self.assertTrue( os.path.isfile(expected_data_file), "expected output data file does not exist, nothing to compare" ) print("\ncomparing", output_data_file, "and", expected_data_file) with open(output_data_file, 'r') as output: with open(expected_data_file, 'r') as expected: diff = difflib.unified_diff( expected.readlines(), output.readlines(), fromfile='expected', tofile='output' ) count = 0 for line in diff: sys.stdout.write(line) count += 1 self.assertTrue(count == 0, "output different!") else: print("no expected output exist, nothing to compare")
def _read_model_data(self): self.datObj = Data() self.datObj.read_data_file(data_fn=self.datfile) self.modObj = Model(model_fn=self.rhofile) self.modObj.read_model_file() self.ew_lim = (self.modObj.grid_east[self.modObj.pad_east], self.modObj.grid_east[-self.modObj.pad_east - 1]) self.ns_lim = (self.modObj.grid_north[self.modObj.pad_north], self.modObj.grid_north[-self.modObj.pad_north - 1]) # logger.debug("ns-limit %s", self.ns_lim) # logger.debug("ew-limit %s", self.ew_lim) # logger.info("station name list %s", self.datObj.station_locations['station']) # logger.info("station Lat list %s", self.datObj.station_locations['lat']) return
def test_write_gocad_sgrid_file(self): if not os.path.exists(self._sgrid_fn): self._sgrid_fn = None output_fn = os.path.basename(self._sgrid_fn) # read data file to get centre position dObj = Data() dObj.read_data_file(data_fn=self._data_fn) # get centre coordinates centre = np.array([0., 0., 0.]) centre[0] = dObj.center_point['east'] centre[1] = dObj.center_point['north'] # create a model object using the data object and read in gocad sgrid file mObj = Model(data_obj=dObj) mObj.read_model_file(model_fn=self._model_fn) mObj.save_path = self._output_dir mObj.write_gocad_sgrid_file(origin=centre, fn=os.path.join(self._output_dir, output_fn[:-3])) output_data_file = os.path.normpath( os.path.join(self._output_dir, output_fn)) self.assertTrue(os.path.isfile(output_data_file), "output data file not found") expected_data_file = os.path.normpath(self._sgrid_fn) self.assertTrue( os.path.isfile(expected_data_file), "Ref output data file does not exist, nothing to compare with") is_identical, msg = diff_files(output_data_file, expected_data_file) print(msg) self.assertTrue( is_identical, "The output file is not the same with the baseline file.")
def test_fun(self): edipath = EDI_DATA_DIR # path where edi files are located # period list (will not include periods outside of the range of the edi file) start_period = -2 stop_period = 3 n_periods = 17 period_list = np.logspace(start_period, stop_period, n_periods) # list of edi files, search for all files ending with '.edi' edi_list = [ os.path.join(edipath, ff) for ff in os.listdir(edipath) if (ff.endswith('.edi')) ] do = Data( edi_list=edi_list, inv_mode='1', save_path=self._output_dir, period_list=period_list, error_type_z='floor_egbert', error_value_z=5, error_type_tipper='floor_abs', error_value_tipper=.03, model_epsg=28354 # model epsg, currently set to utm zone 54 ) do.write_data_file() do.data_array['elev'] = 0. do.write_data_file(fill=False) # create model file mo = Model( station_locations=do.station_locations, cell_size_east=500, cell_size_north=500, pad_north= 7, # number of padding cells in each of the north and south directions pad_east=7, # number of east and west padding cells pad_z=6, # number of vertical padding cells pad_stretch_v= 1.6, # factor to increase by in padding cells (vertical) pad_stretch_h= 1.4, # factor to increase by in padding cells (horizontal) n_air_layers=10, # number of air layers res_model=100, # halfspace resistivity value for reference model n_layers=90, # total number of z layers, including air z1_layer=10, # first layer thickness pad_method='stretch', z_target_depth=120000) mo.make_mesh() mo.write_model_file(save_path=self._output_dir) # add topography to res model mo.add_topography_to_model2(AUS_TOPO_FILE) # mo.add_topography_to_model2(r'E:/Data/MT_Datasets/concurry_topo/AussieContinent_etopo1.asc') mo.write_model_file(save_path=self._output_dir) do.project_stations_on_topography(mo) co = Covariance() co.write_covariance_file(model_fn=mo.model_fn) for afile in ("ModEM_Data.dat", "covariance.cov", "ModEM_Model_File.rho"): output_data_file = os.path.normpath( os.path.join(self._output_dir, afile)) self.assertTrue(os.path.isfile(output_data_file), "output data file not found") expected_data_file = os.path.normpath( os.path.join(self._expected_output_dir, afile)) self.assertTrue( os.path.isfile(expected_data_file), "Ref output data file does not exist, nothing to compare with") # print ("Comparing", output_data_file, "and", expected_data_file) is_identical, msg = diff_files(output_data_file, expected_data_file) print msg self.assertTrue( is_identical, "The output file is not the same with the baseline file.")
""" import sys, os from mtpy.modeling.modem import Data from mtpy.mtpy_globals import NEW_TEMP_DIR import click if __name__ == "__main__old": file_dat = sys.argv[1] if len(sys.argv) > 2: outdir = sys.argv[2] else: outdir = NEW_TEMP_DIR obj = Data() obj.compute_phase_tensor(file_dat, outdir) # ============================================================================================= # Command line wrapper for processing phase tensors and output to csv file # ============================================================================================= @click.command() @click.option('-i','--dat_file',type=str, default='examples/data/ModEM_files/Modular_MPI_NLCG_028.dat', \ help='input path/datafile') @click.option('-o', '--output_dir', type=str,
def build_modem_inputfiles(edi_path, output_path): """ For a given se to edi files in edi_path, build the ModEM input files into output_path :param edi_path: # path where edi files are located r'C:\mtpywin\mtpy\examples\data\edi_files_2' :param output_path: # path to save to r'C:\test\ModEM' :return: """ # not nece os.chdir(r'C:\mtpywin\mtpy') # change this path to the path where mtpy is installed ## period list (won't include periods outside of the range of the edi file) ### ## comment/uncomment your desired method ###################################### ############################################################################### ## example to specify start, stop and total number of periods # start_period = 0.001 # stop_period = 1000 # n_periods = 25 # period_list = np.logspace(np.log10(start_period), # np.log10(stop_period), # n_periods) # example to specify a number of periods per decade start_period = 0.002 stop_period = 2000 periods_per_decade = 4 period_list = get_period_list(start_period, stop_period, periods_per_decade, include_outside_range=True) ## an example to use the periods from a particular edi file # edifile_periods = op.join(edipath,'Synth00.edi') # eobj = Edi(edifile_periods) # period_list = 1./eobj.freq ############################################################################### workdir = output_path edipath = edi_path # list of edi files, search for all files ending with '.edi' edi_list = [ op.join(edipath, ff) for ff in os.listdir(edipath) if (ff.endswith('.edi')) ] # make the save path if it doesn't exist if not op.exists(workdir): os.mkdir(workdir) do = Data( edi_list=edi_list, inv_mode='1', save_path=workdir, period_list=period_list, period_buffer= 2, # factor to stretch interpolation by. For example: if period_buffer=2 # then interpolated data points will only be included if they are # within a factor of 2 of a true data point error_type_z=np.array([ ['floor_percent', 'floor_egbert'], # error type, options are 'egbert', 'percent', 'mean_od', 'eigen', 'median', 'off_diagonals' ['floor_egbert', 'percent'] ]), # add floor to apply it as an error floor # can supply a 2 x 2 array for each component or a single value error_value_z=np.array([ [20., 5.], # error floor value in percent [5., 20.] ]), # can supply a 2 x 2 array for each component or a single value error_type_tipper='floor_abs', # type of error to set in tipper, # floor_abs is an absolute value set as a floor error_value_tipper=.03, model_epsg=28354 # model epsg, currently set to utm zone 54. # See http://spatialreference.org/ to find the epsg code for your projection ) do.write_data_file() # set elevations to zero as we need to ensure the stations are on the topography do.data_array['elev'] = 0. do.write_data_file(fill=False) # create model file mo = Model( station_locations=do.station_locations, cell_size_east=8000, cell_size_north=8000, pad_north= 7, # number of padding cells in each of the north and south directions pad_east=7, # number of east and west padding cells pad_z=6, # number of vertical padding cells pad_stretch_v=1.6, # factor to increase by in padding cells (vertical) pad_stretch_h=1.4, # factor to increase by in padding cells (horizontal) pad_num= 3, # number of constant-width cells to add to outside of model before padding cells start # this number is currently multiplied by 1.5 internally n_air_layers= 10, # number of air layers, set to 0 to incorporate bathymetry only res_model=100, # halfspace resistivity value for reference model n_layers=100, # total number of z layers, including air z1_layer=10, # first layer thickness pad_method='stretch', # method for calculating padding z_mesh_method='new', z_target_depth= 120000 # depth to bottom of core model (padding after this depth) ) mo.make_mesh() mo.write_model_file(save_path=workdir) # add topography to res model # if the number of air layers is zero - bathymetry only will be added. # if the number of air layers is nonzero - topography will be added, discretised into that number of cells # mo.add_topography_to_model2(r'C:\mtpywin\mtpy\examples\data\AussieContinent_etopo1.asc') mo.add_topography_to_model2( r'C:\Githubz\mtpy\examples\data\AussieContinent_etopo1.asc') mo.write_model_file(save_path=workdir) # update data elevations do.project_stations_on_topography(mo) # show the mesh mo.plot_sealevel_resistivity() co = Covariance() co.smoothing_east = 0.4 co.smoothing_north = 0.4 co.smoothing_z = 0.4 co.write_covariance_file(model_fn=mo.model_fn)
def create_geogrid(data_file, model_file, out_dir, x_pad=None, y_pad=None, z_pad=None, x_res=None, y_res=None, center_lat=None, center_lon=None, epsg_code=None, depths=None, angle=None, rotate_origin=False, log_scale=False): """Generate an output geotiff file and ASCII grid file. Args: data_file (str): Path to the ModEM .dat file. Used to get the grid center point. model_file (str): Path to the ModEM .rho file. out_dir (str): Path to directory for storing output data. Will be created if it does not exist. x_pad (int, optional): Number of east-west padding cells. This number of cells will be cropped from the east and west sides of the grid. If None, pad_east attribute of model will be used. y_pad (int, optional): Number of north-south padding cells. This number of cells will be cropped from the north and south sides of the grid. If None, pad_north attribute of model will be used. z_pad (int, optional): Number of depth padding cells. This number of cells (i.e. slices) will be cropped from the bottom of the grid. If None, pad_z attribute of model will be used. x_res (int, optional): East-west cell size in meters. If None, cell_size_east attribute of model will be used. y_res (int, optional): North-south cell size in meters. If None, cell_size_north of model will be used. epsg_code (int, optional): EPSG code of the model CRS. If None, is inferred from the grid center point. depths (list of int, optional): A list of integers, eg, [0, 100, 500], of the depth in metres of the slice to retrieve. Will find the closes slice to each depth specified. If None, all slices are selected. center_lat (float, optional): Grid center latitude in degrees. If None, the model's center point will be used. center_lon (float, optional): Grid center longitude in degrees. If None, the model's center point will be used. angle (float, optional): Angle in degrees to rotate image by. If None, no rotation is performed. rotate_origin (bool, optional): If True, image will be rotated around the origin (upper left point). If False, the image will be rotated around the center point. log_scale (bool, optional): If True, the data will be scaled using log10. """ if not os.path.exists(out_dir): os.mkdir(out_dir) model = Model() model.read_model_file(model_fn=model_file) data = Data() data.read_data_file(data_fn=data_file) center = data.center_point center_lat = center.lat.item() if center_lat is None else center_lat center_lon = center.lon.item() if center_lon is None else center_lon if epsg_code is None: zone_number, is_northern, utm_zone = gis_tools.get_utm_zone( center_lat, center_lon) epsg_code = gis_tools.get_epsg(center_lat, center_lon) _logger.info( "Input data epsg code has been inferred as {}".format(epsg_code)) print("Loaded model") # Get the center point of the model grid cells to use as points # in a resistivity grid. ce = _get_centers(model.grid_east) cn = _get_centers(model.grid_north) cz = _get_centers(model.grid_z) print("Grid shape with padding: E = {}, N = {}, Z = {}".format( ce.shape, cn.shape, cz.shape)) # Get X, Y, Z paddings x_pad = model.pad_east if x_pad is None else x_pad y_pad = model.pad_north if y_pad is None else y_pad z_pad = model.pad_z if z_pad is None else z_pad print("Stripping padding...") # Remove padding cells from the grid ce = _strip_padding(ce, x_pad) cn = _strip_padding(cn, y_pad) cz = _strip_padding(cz, z_pad, keep_start=True) print("Grid shape without padding: E = {}, N = {}, Z = {}".format( ce.shape, cn.shape, cz.shape)) x_res = model.cell_size_east if x_res is None else x_res y_res = model.cell_size_north if y_res is None else y_res # BM: The cells have been defined by their center point for making # our grid and interpolating the resistivity model over it. For # display purposes, GDAL expects the origin to be the upper-left # corner of the image. So take the upper left-cell and shift it # half a cell west and north so we get the upper-left corner of # the grid as GDAL origin. origin = _get_gdal_origin(ce, x_res, center.east, cn, y_res, center.north) target_gridx, target_gridy = _build_target_grid(ce, x_res, cn, y_res) resgrid_nopad = _strip_resgrid(model.res_model, y_pad, x_pad, z_pad) indicies = _get_depth_indicies(cz, depths) for di in indicies: print("Writing out slice {:.0f}m...".format(cz[di])) data = _interpolate_slice(ce, cn, resgrid_nopad, di, target_gridx, target_gridy, log_scale) if log_scale: output_file = 'DepthSlice{:.0f}m_log10.tif'.format(cz[di]) else: output_file = 'DepthSlice{:.0f}m.tif'.format(cz[di]) output_file = os.path.join(out_dir, output_file) array2geotiff_writer(output_file, origin, x_res, -y_res, data[::-1], epsg_code=epsg_code, angle=angle, center=center, rotate_origin=rotate_origin) print("Complete!") print("Geotiffs are located in '{}'".format(os.path.dirname(output_file))) return output_file
# list of edi files, search for all files ending with '.edi' edi_list = [op.join(edipath,ff) for ff in os.listdir(edipath) if (ff.endswith('.edi'))] # make the save path if it doesn't exist if not op.exists(workdir): os.mkdir(workdir) do = Data(edi_list=edi_list, inv_mode = '1', save_path=workdir, period_list=period_list, period_buffer = 2, # factor to stretch interpolation by. For example: if period_buffer=2 # then interpolated data points will only be included if they are # within a factor of 2 of a true data point error_type_z='floor_egbert', # error type (egbert is % of sqrt(zxy*zyx)) # floor means apply it as an error floor error_value_z=5, # error floor (or value) in percent error_type_tipper = 'floor_abs', # type of error to set in tipper, # floor_abs is an absolute value set as a floor error_value_tipper =.03, model_epsg=28354 # model epsg, currently set to utm zone 54. # See http://spatialreference.org/ to find the epsg code for your projection ) do.write_data_file() do.data_array['elev'] = 0. do.write_data_file(fill=False) # create model file mo = Model(stations_object=do.stations_obj, cell_size_east=8000, cell_size_north=8000,
import numpy as np import os from scipy.interpolate import RegularGridInterpolator # wd = r'M:\AusLAMP\AusLAMP_NSW\Release\Model_release\MT075_DepthSlice_ArcGIS_ascii_grids' # wdmod = r'C:\Users\u64125\OneDrive - Geoscience Australia\AusLAMP_NSW\Modelling\ModEM\NSWinv141' wd = r'C:\Data\Alison_201910\MyOutput' wdmod = r'C:\Data\Alison_201910\Alison_ModEM_Grid\MT075_ModEM_files' filestem = 'Modular_MPI_NLCG_004' mObj = Model() mObj.read_model_file(os.path.join(wdmod,filestem+'.rho')) dObj = Data() dObj.read_data_file(os.path.join(wdmod,'ModEM_Data.dat')) gce,gcn,gcz = [np.mean([arr[:-1],arr[1:]],axis=0) for arr in [mObj.grid_east,mObj.grid_north,mObj.grid_z]] gce,gcn = gce[6:-6],gcn[6:-6] # padding big-sized edge cells # ge,gn = mObj.grid_east[6:-6],mObj.grid_north[6:-6] print(gce) print(gcn) print(gcz) print("Shapes E, N Z =", gce.shape, gcn.shape, gcz.shape) fileext = '.asc' ascfilelist = [ff for ff in os.listdir(wd) if ff.endswith(fileext)]
period_list = np.logspace(start_period, stop_period, n_periods) # list of edi files, search for all files ending with '.edi' edi_list = [ op.join(edipath, ff) for ff in os.listdir(edipath) if (ff.endswith('.edi')) ] if not op.exists(workdir): os.mkdir(workdir) do = Data( edi_list=edi_list, inv_mode='1', save_path=workdir, period_list=period_list, error_type_z='floor_egbert', error_value_z=5, error_type_tipper='floor_abs', error_value_tipper=.03, model_epsg=28354 # model epsg, currently set to utm zone 54 ) do.write_data_file() do.data_array['elev'] = 0. do.write_data_file(fill=False) # create model file mo = Model( station_locations=do.station_locations, cell_size_east=500, cell_size_north=500, pad_north=
# list of edi files, search for all files ending with '.edi' edi_list = [ op.join(edipath, ff) for ff in os.listdir(edipath) if (ff.endswith('.edi')) ] # make the save path if it doesn't exist if not op.exists(workdir): os.mkdir(workdir) do = Data( edi_list=edi_list, inv_mode='1', save_path=workdir, period_list=period_list, error_type_z='floor_egbert', # error type (egbert is % of sqrt(zxy*zyx)) # floor means apply it as an error floor error_value_z=5, # error floor (or value) in percent error_type_tipper='floor_abs', # type of error to set in tipper, # floor_abs is an absolute value set as a floor error_value_tipper=.03, model_epsg=28354 # model epsg, currently set to utm zone 54. # See http://spatialreference.org/ to find the epsg code for your projection ) do.write_data_file() do.data_array['elev'] = 0. do.write_data_file(fill=False) # create model file mo = Model( stations_object=do.stations_obj, cell_size_east=8000, cell_size_north=8000,
def test_fun_rotate(self): # set the dir to the output from the previously correct run self._expected_output_dir = os.path.join(SAMPLE_DIR, 'ModEM_rotate40') edipath = EDI_DATA_DIR2 # example to specify a number of periods per decade start_period = 0.002 stop_period = 2000 periods_per_decade = 4 period_list = get_period_list(start_period, stop_period, periods_per_decade, include_outside_range=True) # list of edi files, search for all files ending with '.edi' edi_list = [ os.path.join(edipath, ff) for ff in os.listdir(edipath) if (ff.endswith('.edi')) ] do = Data( edi_list=edi_list, inv_mode='1', save_path=self._output_dir, period_list=period_list, period_buffer= 2, # factor to stretch interpolation by. For example: if period_buffer=2 # then interpolated data points will only be included if they are # within a factor of 2 of a true data point error_type_z= 'floor_egbert', # error type (egbert is % of sqrt(zxy*zyx)) # floor means apply it as an error floor error_value_z=5, # error floor (or value) in percent error_type_tipper='floor_abs', # type of error to set in tipper, # floor_abs is an absolute value set as a floor error_value_tipper=.03, rotation_angle=40, model_epsg=28354 # model epsg, currently set to utm zone 54. # See http://spatialreference.org/ to find the epsg code for your projection ) do.write_data_file() do.data_array['elev'] = 0. do.write_data_file(fill=False) # mesh rotation angle is the opposite direction to the rotation of the stations if do.rotation_angle == 0: mesh_rotation_angle = 0 else: mesh_rotation_angle = -do.rotation_angle # create model file mo = Model( stations_object=do.station_locations, cell_size_east=8000, cell_size_north=8000, pad_north= 7, # number of padding cells in each of the north and south directions pad_east=7, # number of east and west padding cells pad_z=6, # number of vertical padding cells pad_stretch_v= 1.6, # factor to increase by in padding cells (vertical) pad_stretch_h= 1.4, # factor to increase by in padding cells (horizontal) n_air_layers=10, #number of air layers res_model=100, # halfspace resistivity value for reference model n_layers=100, # total number of z layers, including air z1_layer=10, # first layer thickness pad_method='stretch', # method for calculating padding z_mesh_method='new', z_target_depth= 120000, # depth to bottom of core model (padding after this depth) mesh_rotation_angle=mesh_rotation_angle) mo.make_mesh() mo.write_model_file(save_path=self._output_dir) # add topography to res model mo.add_topography_to_model2(AUS_TOPO_FILE) mo.write_model_file(save_path=self._output_dir) co = Covariance() co.smoothing_east = 0.4 co.smoothing_north = 0.4 co.smoothing_z = 0.4 co.write_covariance_file(model_fn=mo.model_fn) for afile in ("ModEM_Data.dat", "covariance.cov", "ModEM_Model_File.rho"): output_data_file = os.path.normpath( os.path.join(self._output_dir, afile)) self.assertTrue(os.path.isfile(output_data_file), "output data file not found") expected_data_file = os.path.normpath( os.path.join(self._expected_output_dir, afile)) self.assertTrue( os.path.isfile(expected_data_file), "Ref output data file does not exist, nothing to compare with") # print ("Comparing", output_data_file, "and", expected_data_file) is_identical, msg = diff_files(output_data_file, expected_data_file) print(msg) self.assertTrue( is_identical, "The output file is not the same with the baseline file.")
######## inputs ############## wd = r'C:\mtpywin\mtpy\examples\model_files\ModEM_2' savepath = r'C:\test' model_fn = op.join(wd, 'Modular_MPI_NLCG_004.rho') data_fn = op.join(wd, 'ModEM_Data.dat') location_type = 'LL' # 'EN' to save eastings/northings, 'LL' to save longitude/latitude, need to provide model_epsg if using 'LL' model_epsg = 28355 # epsg number model was projected in. common epsg numbers: # 28351 (GDA94, mga zone 51), 28352 (mga zone 52), 28353 (mga zone 53), # 28354 (mga zone 54), 28355 (mga zone 55), 28356 (mga zone 56) # 3112 (Geoscience Australia Lambert) # go to http://spatialreference.org/ref/epsg/?search=&srtext=Search for more info model_utm_zone = '55S' # alternative to epsg, can provide utm zone depth_indices = [44, 45, 46] # indices that define depth ############################## # get the real-world origin from the data file dataObj = Data(data_fn=data_fn, model_epsg=model_epsg) dataObj.read_data_file() origin = [dataObj.center_point['east'][0], dataObj.center_point['north'][0]] modObj = Model() modObj.read_model_file(model_fn=op.join(wd, model_fn)) modObj.write_xyres(origin=origin, savepath=savepath, location_type=location_type, model_epsg=model_epsg, model_utm_zone=None, log_res=True, outfile_basename='GMTtest', depth_index=depth_indices)
def run(self): # monkey patch plt.show() so the plot is not displayed in worker thread true_plt_show = plt.show plt.show = _fake_plt_show self._figures = [] try: if not os.path.exists(self.output_dir): os.mkdir(self.output_dir) # get period_list list self.status_updated.emit("Selecting Periods...") period_list = EdiCollection(self._edi_list).select_periods(**self._select_period_kwargs) # save period plot for reference figure = plt.gcf() figure.savefig(os.path.join(self.output_dir, self._period_image_name)) if self.show: self.figure_updated.emit('Period Distribution', figure) # data object self.status_updated.emit("Creating ModEM Data Object...") self._data_kwargs['period_list'] = period_list data = Data(edi_list=self._edi_list, **self._data_kwargs) # write data file self.status_updated.emit("Writing Initial ModEM Data File...") data.write_data_file() # create model self.status_updated.emit("Creating Mesh Model...") model = Model(data_object=data, **self._mesh_kwagrs) model.make_mesh() # plot mesh model.plot_mesh(fig_num=plt.gcf().number + 1) figure = plt.gcf() figure.savefig(os.path.join(self.output_dir, self._mesh_image_name)) if self.show: self.figure_updated.emit("Mesh", figure) # model.plot_mesh_xy() # self.figure_updated.emit("Mesh XY", plt.gcf()) # model.plot_mesh_xz() # self.figure_updated.emit("Mesh XZ", plt.gcf()) model.write_model_file() # add topography self.status_updated.emit("Adding Topography...") model.add_topography_to_mesh(**self._topo_args) if self.show: model.plot_topograph() # this is too slow so only plot and save image when asked figure = plt.gcf() figure.savefig(os.path.join(self.output_dir, self._topo_image_name)) self.figure_updated.emit("Topography", figure) self.status_updated.emit("Updating Mesh Model...") model.write_model_file() # covariance self.status_updated.emit("Creating Covariance File...") self._covariance_kwargs['mask_arr'] = model.covariance_mask cov = Covariance(**self._covariance_kwargs) self.status_updated.emit("Writing Covariance File...") cov.write_covariance_file(model_fn=model.model_fn, sea_water=self._topo_args['sea_resistivity'], air=self._topo_args['air_resistivity']) self.status_updated.emit("Creating README File...") self.write_readme(os.path.join(self.output_dir, self._readme_name)) # done self.status_updated.emit("Finishing...") except Exception as e: frm = inspect.trace()[-1] mod = inspect.getmodule(frm[0]) self.export_error.emit("{}: {}".format(mod.__name__, e.message)) # restore plt.show() plt.show = true_plt_show
if edi_list is None or (edi_list) < 1: print("Error: No edi files found in the dir %s" % edipath) sys.exit(2) # period list (can take periods from one of the edi files, or just specify # periods directly using the logspace function (commented out)) # eo = mtedi.Edi(edi_list[0]) # this may miss some periods? # period_list = 1. / eo.Z.freq # period_list = np.logspace(-3,3) print("edi_list = {}".format(edi_list)) period_list = EdiCollection(edi_list).select_periods() datob = Data(edi_list=edi_list, inv_mode='1', period_list=period_list, epsg=epsg_code, error_type='floor', error_floor=10) # period_buffer=0.000001) datob.write_data_file(save_path=outputdir) # create mesh grid model object # model = Model(Data=datob, model = Model( station_object=datob.station_locations, epsg=epsg_code, # epsg # cell_size_east=500, cell_size_north=500, # concurry cell_size_east=10000, cell_size_north=10000, #GA_VIC # cell_size_east=1000, cell_size_north=1000, # Concurry
import matplotlib.pyplot as plt import numpy as np from mtpy.modeling.modem import Data, Model if __name__ == "__main__": #workdir = r'C:\Git\mtpy\examples\data' workdir = r'E:\Githubz\mtpy\examples\data' modeldir = op.join(workdir, 'ModEM_files') # folder where *.rho files exist read_data = True iterfn = max([ff for ff in os.listdir(modeldir) if ff.endswith('.rho')]) if read_data: doo = Data() doo.read_data_file(op.join(modeldir, 'ModEM_Data.dat')) moo = Model(model_fn=op.join(modeldir, iterfn)) moo.read_model_file() snoew = 10 snons = 10 snoz = np.where(moo.grid_z > 80000)[0][0] gcz = np.mean([moo.grid_z[:-1], moo.grid_z[1:]], axis=0) plotdir = 'ew' if plotdir == 'ew': X, Y, res = moo.grid_east, moo.grid_z, np.log10( moo.res_model[snoew, :, :].T) xlim = (-25000, 25000) ylim = (1e4, 0)
gocad_sgrid_file = r'C:\mtpywin\mtpy\examples\model_files\gocad\ModEM_Model_File.sg' ## Define some other parameters ## epsg = 28354 # epsg code your model was projected to. See http://spatialreference.org/ # to find the epsg code for your projection # workdir (path to save to) workdir = r'C:\tmp' ## Create or define data file ## # two options here. If we are modifying an old model, can provide the old data # file to get the locations. Alternatively, provide an array of x,y locations # (longitude and latitude) in the case of a new forward model #### option 1 #### data_fn = r'C:\mtpywin\mtpy\examples\model_files\ModEM\ModEM_Data.dat' dObj = Data() dObj.read_data_file(data_fn=data_fn) ### option 2 #### stationxyfile = r'C:\mtpywin\mtpy\examples\model_files\gocad\stationxy.txt' xy = np.loadtxt(stationxyfile, usecols=(1, 2)) station_names = np.loadtxt(stationxyfile, usecols=(0, ), dtype='S10') period_list = np.logspace(1, 4, 19) # change to your period list # create data file dObj = Data(epsg=epsg) dObj._initialise_empty_data_array(xy, period_list, location_type='LL', station_names=station_names) dObj.write_data_file(fill=False, save_path=workdir)
# Inputs # ============================================================================= inv_path = Path( r"c:\Users\jpeacock\OneDrive - DOI\Geothermal\GreatBasin\modem_inv\gb_01") basename = "gb_z03_t02_c02_046" metadata_path = inv_path.joinpath("netcdf_metadata.json") pad = 12 model_epsg = 32611 # ============================================================================= m = Model() m.read_model_file(inv_path.joinpath(f"{basename}.rho")) d = Data() d.read_data_file(inv_path.joinpath(f"{basename}.dat")) center = d.center_point with open(metadata_path, "r") as fid: metadata = json.load(fid) # need to project points onto a lat/lon grid model_crs = pyproj.CRS(f"epsg:{model_epsg}") x_crs = pyproj.CRS("epsg:4326") translator = pyproj.Transformer.from_crs(model_crs, x_crs) east, north = np.broadcast_arrays( m.grid_north[pad:-(pad + 1), None] + center.north, m.grid_east[None, pad:-(pad + 1)] + center.east,
if not op.exists(workdir): os.mkdir(workdir) do = Data( edi_list=edi_list, inv_mode='1', save_path=workdir, period_list=period_list, period_buffer= 2, # factor to stretch interpolation by. For example: if period_buffer=2 # then interpolated data points will only be included if they are # within a factor of 2 of a true data point error_type_z=np.array([ [ 'floor_percent', 'floor_egbert' ], # error type, options are 'egbert', 'percent', 'mean_od', 'eigen', 'median', 'off_diagonals' ['floor_egbert', 'percent'] ]), # add floor to apply it as an error floor # can supply a 2 x 2 array for each component or a single value error_value_z=np.array([ [20., 5.], # error floor value in percent [5., 20.] ]), # can supply a 2 x 2 array for each component or a single value error_type_tipper='floor_abs', # type of error to set in tipper, # floor_abs is an absolute value set as a floor error_value_tipper=.03, model_epsg=28354 # model epsg, currently set to utm zone 54. # See http://spatialreference.org/ to find the epsg code for your projection ) # Unlike when writing topography from a file, don't modify the # elevation of the Data object as we need the station elevations
def read_residual_fn(self): if self.residual is None: self.residual = Data() self.residual.read_data_file(self.residual_fn) else: pass
def modem2geotiff(data_file, model_file, output_file, source_proj=None): """ Generate an output geotiff file from a modems.dat file and related modems.rho model file :param data_file: modem.dat :param model_file: modem.rho :param output_file: output.tif :param source_proj: None by defult. The UTM zone infered from the input non-uniform grid parameters :return: """ # Define Data and Model Paths data = Data() data.read_data_file(data_fn=data_file) # create a model object using the data object and read in model data model = Model(data_obj=data) model.read_model_file(model_fn=model_file) center = data.center_point if source_proj is None: zone_number, is_northern, utm_zone = gis_tools.get_utm_zone( center.lat.item(), center.lon.item()) #source_proj = Proj('+proj=utm +zone=%d +%s +datum=%s' % (zone_number, 'north' if is_northern else 'south', 'WGS84')) epsg_code = gis_tools.get_epsg(center.lat.item(), center.lon.item()) print("Input data epsg code is infered as ", epsg_code) else: epsg_code = source_proj # integer source_proj = Proj(init='epsg:' + str(epsg_code)) resistivity_data = { 'x': center.east.item() + (model.grid_east[1:] + model.grid_east[:-1]) / 2, 'y': center.north.item() + (model.grid_north[1:] + model.grid_north[:-1]) / 2, 'z': (model.grid_z[1:] + model.grid_z[:-1]) / 2, 'resistivity': np.transpose(model.res_model, axes=(2, 0, 1)) } grid_proj = Proj( init='epsg:4326') # output grid Coordinate systems: 4326, 4283, 3112 # grid_proj = Proj(init='epsg:4283') # output grid Coordinate system 4326, 4283, 3112 # grid_proj = Proj(init='epsg:3112') # output grid Coordinate system 4326, 4283, 3112 result = modem2nc.interpolate(resistivity_data, source_proj, grid_proj, center, modem2nc.median_spacing(model.grid_east), modem2nc.median_spacing(model.grid_north)) # nc.write_resistivity_grid(output_file, grid_proj, # result['latitude'], result['longitude'], result['depth'], # result['resistivity'], z_label='depth') print("result['latitude'] ==", result['latitude']) print("result['longitude'] ==", result['longitude']) print("result['depth'] ==", result['depth']) origin = (result['latitude'][0], result['longitude'][0]) pixel_width = result['longitude'][1] - result['longitude'][0] pixel_height = result['latitude'][1] - result['latitude'][0] # write the depth_index depth_index = 1 resis_data = result['resistivity'][depth_index, :, :] resis_data2 = resis_data[:: -1] # flipped upside down to get geotiff mapped correctly. array2geotiff_writer(output_file, origin, pixel_width, pixel_height, resis_data2) return output_file
def test_fun_edi_elevation(self): edipath = EDI_DATA_DIR # path where edi files are located # set the dir to the output from the previously correct run self._expected_output_dir = os.path.join(SAMPLE_DIR, 'ModEM') # period list (will not include periods outside of the range of the edi file) start_period = -2 stop_period = 3 n_periods = 17 period_list = np.logspace(start_period, stop_period, n_periods) # list of edi files, search for all files ending with '.edi' edi_list = [ os.path.join(edipath, ff) for ff in os.listdir(edipath) if (ff.endswith('.edi')) ] do = Data( edi_list=edi_list, inv_mode='1', save_path=self._output_dir, period_list=period_list, error_type_z='floor_egbert', error_value_z=5, error_type_tipper='floor_abs', error_value_tipper=.03, model_epsg=28354 # model epsg, currently set to utm zone 54 ) do.write_data_file() # create model file mo = Model( station_locations=do.station_locations, cell_size_east=500, cell_size_north=500, pad_north= 7, # number of padding cells in each of the north and south directions pad_east=7, # number of east and west padding cells pad_z=6, # number of vertical padding cells pad_stretch_v= 1.6, # factor to increase by in padding cells (vertical) pad_stretch_h= 1.4, # factor to increase by in padding cells (horizontal) n_air_layers=10, # number of air layers res_model=100, # halfspace resistivity value for reference model n_layers=90, # total number of z layers, including air z1_layer=10, # first layer thickness pad_method='stretch', z_target_depth=120000) mo.make_mesh() mo.write_model_file(save_path=self._output_dir) # Add topography from EDI data mo.add_topography_from_data(do) mo.write_model_file(save_path=self._output_dir) # BM: note this function makes a call to `write_data_file` and this is the datafile being # compared! do.project_stations_on_topography(mo) co = Covariance() co.write_covariance_file(model_fn=mo.model_fn) # BM: if this test is failing check that the correct filenames are being selected # for comparison for test_output, expected_output in ( ("ModEM_Data_topo.dat", "ModEM_Data_EDI_elev.dat"), ("covariance.cov", "covariance_EDI_elev.cov"), ("ModEM_Model_File.rho", "ModEM_Model_File_EDI_elev.rho")): output_data_file = os.path.normpath( os.path.join(self._output_dir, test_output)) self.assertTrue(os.path.isfile(output_data_file), "output data file not found") expected_data_file = os.path.normpath( os.path.join(self._expected_output_dir, expected_output)) self.assertTrue( os.path.isfile(expected_data_file), "Ref output data file '{}' does not exist, nothing to compare with" .format(expected_data_file)) is_identical, msg = diff_files(output_data_file, expected_data_file) print(msg) self.assertTrue( is_identical, "The output file '{}' is not the same with the baseline file '{}'." .format(output_data_file, expected_data_file))