def __init__(self,
solver,
res_match_obj,
normalize_d_to_u=True,
model_window=IdentityModelWindow(),
data_window=IdentityDataWindow(),
parallel_wrap_shot=ParallelWrapShotNull(),
imaging_period=1):
self.solver = solver
self.modeling_tools = TemporalModeling(solver)
self.parallel_wrap_shot = parallel_wrap_shot
self.W_model = model_window
self.W_data = data_window
TemporalLeastSquares.__init__(self, solver, parallel_wrap_shot,
imaging_period)
self.res_match_obj = res_match_obj #The residual match object that is used for normalizing the data.
self.normalize_d_to_u = normalize_d_to_u
if res_match_obj._synToFld:
raise Exception(
"I'm assuming synToFld should be false. It determines the order of synthetic and true data in the call self.res_match_obj.match in the self._residual function. The covmatch option of the match routine will in this case pass fld as first argument and syn as second. The udmatch array contains the scaling factor for the first argument in self.res_match_obj.match to the second this way"
)
def __init__(self,
solver,
ot_param=None,
parallel_wrap_shot=ParallelWrapShotNull(),
imaging_period=1,
normalize_trace=False):
"""imaging_period: Imaging happens every 'imaging_period' timesteps. Use higher numbers to reduce memory consumption at the cost of lower gradient accuracy.
By assigning this value to the class, it will automatically be used when the gradient function of the temporal objective function is called in an inversion context.
"""
self.solver = solver
self.modeling_tools = TemporalModeling(solver)
self.parallel_wrap_shot = parallel_wrap_shot
self.imaging_period = int(imaging_period) # Needs to be an integer
self.normalize_trace = normalize_trace
self.trans_func = 'id'
self.trans_factor = 1.0
self.filter_op = False
self.noise_factor = None
if ot_param is not None:
self.trans_func = ot_param['trans_func_type']
self.trans_factor = ot_param['trans_func_factor']
self.velocity_bound = ot_param['velocity_bound']
self.filter_op = ot_param['filter_op']
self.freq_band = ot_param['freq_band']
self.noise_factor = ot_param['noise_factor']
def __init__(self,
solver,
filter_op=None,
parallel_wrap_shot=ParallelWrapShotNull(),
transform_mode='linear',
imaging_period=1,
c_ratio=5.0,
exp_a=1.0,
env_p=2.0,
auto_expa=True,
paddata=False,
FlagCnsdNeg=False):
"""imaging_period: Imaging happens every 'imaging_period' timesteps. Use higher numbers to reduce memory consumption at the cost of lower gradient accuracy.
By assigning this value to the class, it will automatically be used when the gradient function of the temporal objective function is called in an inversion context.
"""
self.solver = solver
self.modeling_tools = TemporalModeling(solver)
self.parallel_wrap_shot = parallel_wrap_shot
self.transform_mode = transform_mode
self.imaging_period = int(imaging_period) #Needs to be an integer
self.filter_op = filter_op
self.c_ratio = c_ratio
self.exp_a = exp_a
self.env_p = env_p
self.paddata = paddata
self.auto_expa = auto_expa
self.FlagCnsdNeg = FlagCnsdNeg
def __init__(self,
solver,
h,
filter_op=None,
dm_extend=None,
max_sub_offset=0.0,
weight_matrix=None,
regularization_value=None,
krylov_maxiter=10,
parallel_wrap_shot=ParallelWrapShotNull(),
imaging_period=1):
"""imaging_period: Imaging happens every 'imaging_period' timesteps. Use higher numbers to reduce memory consumption at the cost of lower gradient accuracy.
By assigning this value to the class, it will automatically be used when the gradient function of the temporal objective function is called in an inversion context.
"""
self.solver = solver
self.modeling_tools = TemporalModeling(solver)
self.parallel_wrap_shot = parallel_wrap_shot
self.imaging_period = int(imaging_period) # Needs to be an integer
self.filter_op = filter_op
self.weight_matrix = weight_matrix
self.regularization_value = regularization_value
self.krylov_maxiter = krylov_maxiter
self.max_sub_offset = max_sub_offset
self.h = h
self.dm_extend = dm_extend
def __init__(self,
solver,
parallel_wrap_shot=ParallelWrapShotNull(),
modeling_kwargs={}):
self.solver = solver
self.modeling_tools = HybridModeling(solver, **modeling_kwargs)
self.parallel_wrap_shot = parallel_wrap_shot
def __init__(self,
tomo_obj,
data_obs,
sigma,
parallel_wrap_shot=ParallelWrapShotNull(),
cnn=None):
self.data_obs = data_obs
self.tomo_obj = tomo_obj
self.sigma = sigma
self.cnn = cnn
def __init__(self,
solver,
parallel_wrap_shot=ParallelWrapShotNull(),
imaging_period=1):
"""imaging_period: Imaging happens every 'imaging_period' timesteps. Use higher numbers to reduce memory consumption at the cost of lower gradient accuracy.
By assigning this value to the class, it will automatically be used when the gradient function of the temporal objective function is called in an inversion context.
"""
self.solver = solver
self.modeling_tools = TemporalModeling(solver)
self.parallel_wrap_shot = parallel_wrap_shot
self.imaging_period = int(imaging_period) #Needs to be an integer
def __init__(self,
solver,
shots_d1,
shots_d0,
res_match_obj,
parallel_wrap_shot=ParallelWrapShotNull(),
imaging_period=1,
norm_both_to_d0=False,
normalize_d_to_u=False):
"""imaging_period: Imaging happens every 'imaging_period' timesteps. Use higher numbers to reduce memory consumption at the cost of lower gradient accuracy.
By assigning this value to the class, it will automatically be used when the gradient function of the temporal objective function is called in an inversion context.
"""
TemporalLeastSquares.__init__(self, solver, parallel_wrap_shot,
imaging_period)
self.res_match_obj = res_match_obj #The residual match object that is used for normalizing the data.
self.shots_u0_set = False #When this is set, the next two items will be generated. See _generate_data_on_shots_u0
self.fixed_dt_synthetic = None
self.fixed_ts = None
self.shots_u0 = None
self.shots_d0 = shots_d0
self.shots_d1 = shots_d1
self.norm_both_to_d0 = norm_both_to_d0 #POORLY CHOSEN VARIABLE NAME NOW THAT I ALSO ALLOW D TO BE NORMALIZED TO U. THIS VARIABLE SHOULD MEAN NORMALIZE BOTH TO 0
self.shots_dict = dict(
) #in _residual we will index this to find out which d0 and u0 shot we should use when forming the double difference.
#d0 and d1 may have slightly different positions. I just need their order to be the same
self.normalize_d_to_u = normalize_d_to_u #When I initiall wrote this code I assumed we would always normalize u to d. I just made this modification to see if d to u makes any difference.
for shot in shots_d1:
i = shots_d1.index(shot)
pos = shot.sources.position
self.shots_dict[pos] = i
#I am not normalizing the baseline synthetic here, because I am planning to do the same as in NormalizedAmplitudeTemporalLeastSquares.
#There I interpolate the true data to solver.ts(). This can change if the max velocity changes over the iterations
#To reduce the probability of errors when matching d1 and d0 shots I am going to assume that all shots have increasing x positions.
#Here I will just verify this
self._verify_shots_x_position_increasing(shots_d1)
self._verify_shots_x_position_increasing(shots_d0)
if res_match_obj._synToFld:
raise Exception(
"I'm assuming synToFld should be false. It determines the order of synthetic and true data in the call self.res_match_obj.match in the self._residual function. The covmatch option of the match routine will in this case pass fld as first argument and syn as second. The udmatch array contains the scaling factor for the first argument in self.res_match_obj.match to the second this way"
)
def __init__(self,
solver,
model_window=IdentityModelWindow(),
data_window=IdentityDataWindow(),
parallel_wrap_shot=ParallelWrapShotNull(),
imaging_period=1):
self.solver = solver
self.modeling_tools = TemporalModeling(solver)
self.parallel_wrap_shot = parallel_wrap_shot
self.W_model = model_window
self.W_data = data_window
self.imaging_period = imaging_period
def __init__(self, solver=None, parallel_wrap_shot=ParallelWrapShotNull()):
"""Construct the simple objective class
We construct the following objective function:
f(x) = exp(-0.5 * |x|^2)
The corresponding gradient is
g(x) = - exp(-0.5 * |x|^2) * x
____________________________________________________________________
In this class, the input solver and parallel_wrap_shot are not
necessary. The reason that we keep them is that we want to make this
class consistant with the objective class of pysit. So that, they can
be called in the same way in the Gradient Test.
"""
self.parallel_wrap_shot = parallel_wrap_shot
self.solver = solver
def __init__(self,
solver,
filter_op=None,
parallel_wrap_shot=ParallelWrapShotNull(),
imaging_period=1,
normalize_trace=False,
regularization=None,
normalize_obs=True,
DownSample_op=opI()):
"""imaging_period: Imaging happens every 'imaging_period' timesteps. Use higher numbers to reduce memory consumption at the cost of lower gradient accuracy.
By assigning this value to the class, it will automatically be used when the gradient function of the temporal objective function is called in an inversion context.
"""
self.solver = solver
self.modeling_tools = TemporalModeling(solver)
self.regularization = regularization
self.parallel_wrap_shot = parallel_wrap_shot
self.imaging_period = int(imaging_period) # Needs to be an integer
self.filter_op = filter_op
self.normalize_trace = normalize_trace
self.normalize_obs = normalize_obs
self.DownSample_op = DownSample_op
def __init__(self,
solver,
shots_d1,
shots_d0,
res_match_obj,
parallel_wrap_shot=ParallelWrapShotNull(),
imaging_period=1):
TemporalLeastSquares.__init__(self, solver, parallel_wrap_shot,
imaging_period)
self.res_match_obj = res_match_obj #The residual match object that is used for normalizing the data.
self.shots_u0_set = False #When this is set, the next two items will be generated. See _generate_data_on_shots_u0
self.fixed_dt_synthetic = None
self.fixed_ts = None
self.shots_u0 = None
self.shots_d0 = shots_d0
self.shots_d1 = shots_d1
self.shots_dict = dict(
) #in _residual we will index this to find out which d0 and u0 shot we should use when forming the double difference.
#d0 and d1 may have slightly different positions. I just need their order to be the same
for shot in shots_d1:
i = shots_d1.index(shot)
pos = shot.sources.position
self.shots_dict[pos] = i
#To reduce the probability of errors when matching d1 and d0 shots I am going to assume that all shots have increasing x positions.
#Here I will just verify this
self._verify_shots_x_position_increasing(shots_d1)
self._verify_shots_x_position_increasing(shots_d0)
if res_match_obj._synToFld:
raise Exception(
"I'm assuming synToFld should be false. It determines the order of synthetic and true data in the call self.res_match_obj.match in the self._residual function. The covmatch option of the match routine will in this case pass fld as first argument and syn as second. The udmatch array contains the scaling factor for the first argument in self.res_match_obj.match to the second this way"
)
def equispaced_acquisition(mesh, wavelet,
sources=1,
receivers='max',
source_depth=None,
source_kwargs={},
receiver_depth=None,
receiver_kwargs={},
parallel_shot_wrap=ParallelWrapShotNull()
):
m = mesh
d = mesh.domain
xmin = d.x.lbound
xmax = d.x.rbound
zmin = d.z.lbound
zmax = d.z.rbound
if m.dim == 3:
ymin = d.y.lbound
ymax = d.y.rbound
if source_depth is None:
source_depth = zmin
if receiver_depth is None:
receiver_depth = zmin
shots = list()
max_sources = m.x.n
if m.dim == 2:
if receivers == 'max':
receivers = m.x.n
if sources == 'max':
sources = m.x.n
if receivers > m.x.n:
raise ValueError('Number of receivers exceeds mesh nodes.')
if sources > m.x.n:
raise ValueError('Number of sources exceeds mesh nodes.')
xpos = np.linspace(xmin, xmax, receivers)
receiversbase = ReceiverSet(m, [PointReceiver(m, (x, receiver_depth), **receiver_kwargs) for x in xpos])
local_sources = sources // parallel_shot_wrap.size, 1
if m.dim == 3:
if receivers == 'max':
receivers = (m.x.n, m.y.n) # x, y
if sources == 'max':
sources = (m.x.n, m.y.n) # x, y
if receivers[0] > m.x.n or receivers[1] > m.y.n:
raise ValueError('Number of receivers exceeds mesh nodes.')
if sources[0] > m.x.n or sources[1] > m.y.n:
raise ValueError('Number of sources exceeds mesh nodes.')
xpos = np.linspace(xmin, xmax, receivers[0])
ypos = np.linspace(ymin, ymax, receivers[1])
receiversbase = ReceiverSet(m, [PointReceiver(m, (x, y, receiver_depth), **receiver_kwargs) for x in xpos for y in ypos])
local_sources = sources[0] // parallel_shot_wrap.size, sources[1] // parallel_shot_wrap.size
for i in range(int(local_sources[0])):
for j in range(int(local_sources[1])):
idx = i + local_sources[0]*parallel_shot_wrap.rank
jdx = j + local_sources[1]*parallel_shot_wrap.rank
if m.dim == 2:
srcpos = (xmin + (xmax-xmin)*(idx+1.0)/(sources+1.0), source_depth)
elif m.dim == 3:
srcpos = (xmin + (xmax-xmin)*(idx+1.0)/(sources[0]+1.0), ymin + (ymax-ymin)*(jdx+1.0)/(sources[1]+1.0), source_depth)
# Define source location and type
source = PointSource(m, srcpos, wavelet, **source_kwargs)
# Define set of receivers
receivers = copy.deepcopy(receiversbase)
# Create and store the shot
shot = Shot(source, receivers)
shots.append(shot)
return shots
def equispaced_acquisition_given_data(data, mesh, wavelet,
odata, ddata, ndata,
source_kwargs={},
receiver_kwargs={},
parallel_shot_wrap=ParallelWrapShotNull()
):
source_depth=None,
receiver_depth=None,
m = mesh
d = mesh.domain
xmin = d.x.lbound
xmax = d.x.rbound
zmin = d.z.lbound
zmax = d.z.rbound
if m.dim == 2:
data_time, data_xrec, data_zrec, data_xsrc, data_zsrc = odn2grid_data_2D_time(odata, ddata, ndata)
if m.dim == 3:
data_time, data_xrec, data_yrec, data_zrec, data_xsrc, data_ysrc, data_zsrc = odn2grid_data_3D_time(odata, ddata, ndata)
if m.dim == 3:
ymin = d.y.lbound
ymax = d.y.rbound
source_depth = data_zsrc[0]
receiver_depth = data_zrec[0]
shots = list()
max_sources = m.x.n
if m.dim == 2:
receivers = ndata[1]
sources = ndata[3]
xpos_rec = data_xrec
receiversbase = ReceiverSet(m, [PointReceiver(m, (x, receiver_depth), **receiver_kwargs) for x in xpos_rec])
if np.mod(sources, parallel_shot_wrap.size) != 0:
raise ValueError('Currently, we only support the case that mod(number of sources, number of processes) = 0')
local_sources = sources / parallel_shot_wrap.size
if m.dim == 3:
receivers = (ndata[1], ndata[2])
sources = (ndata[4], ndata[5])
xpos_rec = data_xrec
ypos_rec = data_yrec
receiversbase = ReceiverSet(m, [PointReceiver(m, (x, y, receiver_depth), **receiver_kwargs) for x in xpos_rec for y in ypos_rec])
if np.mod(np.prod(sources), parallel_shot_wrap.size) != 0:
raise('Currently, we only support the case that mod(number of sources, number of processes) = 0')
local_sources = np.prod(sources) / parallel_shot_wrap.size
print(type(local_sources))
local_sources = int(local_sources)
if m.dim == 2:
if parallel_shot_wrap.rank == 0:
data_local = data[:,:,:,0:local_sources,:].squeeze()
for i in range(1, parallel_shot_wrap.size):
data_send = data[:,:,:,i*local_sources:(i+1)*local_sources,:]
parallel_shot_wrap.comm.send(data_send, dest=i, tag=i)
else:
data_receive=parallel_shot_wrap.comm.recv(source=0, tag=parallel_shot_wrap.rank)
print('Receive data from process ', 0)
data_local = data_receive.squeeze()
if m.dim == 3:
if parallel_shot_wrap.rank == 0:
data_local = get_local_data(data, n, local_sources, 0)
for k in range(1, parallel_shot_wrap.size):
data_send = get_local_data(data, n, local_source, k)
parallel_shot_wrap.comm.send(data_send, dest=k, tag=k)
else:
data_local=parallel_shot_wrap.comm.recv(source=0, tag=parallel_shot_wrap.rank)
print('Receive data from process ', 0)
# data_local = np.zeros((data_time, data_xrec*data_yrec, local_sources))
# for k in range(local_sources):
for k in range(int(local_sources)):
index_true = int(local_sources) * parallel_shot_wrap.rank + k
subindex = np.unravel_index(index_true, sources)
if m.dim == 2:
idx = subindex
if m.dim == 3:
idx = subindex[0]
jdx = subindex[1]
if m.dim == 2:
srcpos = (data_xsrc[idx], source_depth)
elif m.dim == 3:
srcpos = (data_xsrc[idx], data_ysrc[jdx], source_depth)
# Define source location and type
source = PointSource(m, srcpos, wavelet, **source_kwargs)
# Define set of receivers
receivers = copy.deepcopy(receiversbase)
receivers.data = data_local[:,:,k]
# Create and store the shot
shot = Shot(source, receivers)
shots.append(shot)
return shots
def __call__(self,
shots,
initial_model,
n_cnn_para,
nsmps,
beta,
noise_sigma=1.0,
isuq=False,
print_interval=10,
save_interval=None,
initial_value_cnn=None,
parallel_wrap=ParallelWrapShotNull(),
verbose=False,
append=False,
write=False,
**kwargs):
"""The main function for executing a number of steps of the descent
algorith.
Most things can be done without directly overriding this function.
Parameters
----------
shots : list of pysit.Shot
List of Shots for which to compute on.
initial_value : solver.WaveParameters
Initial guess for the iteration.
iteration_parameters : int, iterable
Loop iteration parameters, like number of steps or frequency sets.
<blank>_frequency : int, optional kwarg
Frequency with which to store histories. Detailed in reset method.
verbose : bool
Verbosity flag.
linesearch_configuration : dictionary
Possible parameters for linesearch, for more details, please check the introduction of the function set_linesearch_configuration
"""
if initial_value_cnn is None:
m0_cnn = tf.random.uniform([1, n_cnn_para])
else:
m0_cnn = initial_value_cnn
phi0 = self.objective_function.evaluate(shots, initial_model, m0_cnn) / noise_sigma**2.0
Ms = []
A_accept = []
Phi = []
Beta = []
Ms.append(m0_cnn)
if parallel_wrap.use_parallel:
if parallel_wrap.comm.Get_rank() == 0:
r_probs = np.random.uniform(0.0, 1.0, nsmps)
else:
r_probs = None
r_probs = parallel_wrap.comm.bcast(r_probs, root=0)
else:
r_probs = np.random.uniform(0.0, 1.0, nsmps)
m_min_cnn = m0_cnn
phi_min = phi0
for i in range(nsmps):
# mtmp_cnn = tf.random.uniform([1, n_cnn_para])
Beta.append(beta)
if parallel_wrap.use_parallel:
if parallel_wrap.comm.Get_rank() == 0:
mtmp_cnn = tf.random.normal([1, n_cnn_para])
else:
mtmp_cnn = None
mtmp_cnn = parallel_wrap.comm.bcast(mtmp_cnn, root=0)
else:
mtmp_cnn = tf.random.normal([1, n_cnn_para])
m1_cnn = np.sqrt(1-beta**2.0)*m0_cnn + beta*mtmp_cnn
phi1 = self.objective_function.evaluate(shots, initial_model, m1_cnn) / noise_sigma**2.0
if phi1 < phi_min:
phi_min = phi1
m_min_cnn = m1_cnn
a_accept = np.min((np.exp(phi0-phi1), 1))
A_accept.append(a_accept)
Phi.append(phi1)
# print('Accept probability:', a_accept)
if np.mod(i,print_interval) == 0:
if self.use_parallel is True:
if self.objective_function.parallel_wrap_shot.comm.Get_rank() == 0:
print('Iteration:', i)
print('f: ', phi_min)
else:
print('Iteration:', i)
print('f: ', phi_min)
if a_accept > r_probs[i]:
Ms.append(m1_cnn)
m0_cnn = m1_cnn
phi0 = phi1
if a_accept > 0.8:
beta *= 1.2
else:
Ms.append(m0_cnn)
if a_accept < 0.1:
if beta > 1e-4:
beta *= 0.5
if save_interval is not None:
if np.mod(i,save_interval) == 0:
if (parallel_wrap.use_parallel is None) or (parallel_wrap.comm.Get_rank() == 0):
if i == 0:
Snp = np.array(Ms)
else:
Msi = Ms[len(Snp):len(Ms)]
Snpi = np.array(Msi)
nsize = np.shape(Snpi)
Snpi = np.reshape(Snpi, [nsize[0], nsize[-1]])
print(np.shape(Snp))
print(np.shape(Snpi))
Snp = np.concatenate((Snp, Snpi), axis=0)
n_size = np.shape(Snp)
n_size_new = [n_size[0], n_size[-1]]
Snp = np.reshape(Snp, n_size_new)
write_data('./Samples.mat', Snp, [1,1], [1,1], n_size_new)
write_data('./MAP.mat', np.array(m_min_cnn), [1,1], [1,1], np.array(m_min_cnn).shape)
write_data('./probability.mat', A_accept, [1], [1], len(A_accept))
write_data('./objective_function.mat', Phi, [1], [1], len(Phi))
write_data('./betas.mat', Beta, [1], [1], len(Beta))
if parallel_wrap.use_parallel is not None:
parallel_wrap.comm.Barrier()
result = dict()
result['MAP'] = m_min_cnn
result['samples'] = Ms
result['accept_prob'] = A_accept
result['Phi'] = Phi
return result
def __init__(self, solver, parallel_wrap_shot=ParallelWrapShotNull()):
self.solver = solver
self.modeling_tools = FrequencyModeling(solver)
self.parallel_wrap_shot = parallel_wrap_shot
def __init__(self, solver, parallel_wrap_shot=ParallelWrapShotNull()):
self.solver = solver
self.modeling_tools = None
self.parallel_wrap_shot = parallel_wrap_shot
def marine_acquisition(mesh, wavelet, sources_x_locations=None,
sources_y_locations=None,
max_offset_x=None,
max_offset_y=None,
receivers_dx=None,
receivers_dy=None,
source_depth=None,
source_kwargs={},
receiver_depth=None,
receiver_kwargs={},
parallel_shot_wrap=ParallelWrapShotNull()):
if sources_x_locations is None:
raise ValueError(
"The horizontal locations of sources are not defined, please set values to variable 'sources_x_locations' ")
if max_offset_x is None:
raise ValueError(
"The horizontal maximal offset is not defined, please set values to variable 'max_offset_x' ")
if receivers_dx is None:
raise ValueError(
"The horizontal receiver sampling interval is not defined, please set values to variable 'receivers_dx' ")
m = mesh
d = mesh.domain
xmin = d.x.lbound
xmax = d.x.rbound
zmin = d.z.lbound
zmax = d.z.rbound
if m.dim == 3:
raise ValueError(
"3D Marine tow string acquisition has not been implemented")
if source_depth is None:
source_depth = zmin
if receiver_depth is None:
receiver_depth = zmin
shots = list()
max_sources = len(sources_x_locations)
if m.dim == 2:
sources = len(sources_x_locations)
local_sources = sources / parallel_shot_wrap.size
for k in range(int(local_sources)):
index_true = int(local_sources) * parallel_shot_wrap.rank + k
subindex = np.unravel_index(index_true, sources)
idx = subindex[0]
if m.dim == 3:
## 3D marine acquisition has not been implemented
jdx = subindex[1]
if m.dim == 2:
# srcpos = (xmin + (xmax-xmin)*(idx+1.0)/(sources+1.0), source_depth)
srcpos = (sources_x_locations[idx], source_depth)
elif m.dim == 3:
# srcpos = (xmin + (xmax-xmin)*(idx+1.0)/(sources[0]+1.0), ymin + (
# ymax-ymin)*(jdx+1.0)/(sources[1]+1.0), source_depth)
srcpos = (sources_x_locations[idx], sources_y_locations[jdx])
# Define source location and type
source = PointSource(m, srcpos, wavelet, **source_kwargs)
# Define set of receivers
xpos = np.arange(
sources_x_locations[idx], max_offset_x+sources_x_locations[idx], receivers_dx)
receiversbase = ReceiverSet(
m, [PointReceiver(m, (x, receiver_depth), **receiver_kwargs) for x in xpos])
receivers = copy.deepcopy(receiversbase)
# Create and store the shot
shot = Shot(source, receivers)
shots.append(shot)
return shots
def equispaced_acquisition_given_locations(mesh, wavelet,
sources_x_locations=None,
sources_y_locations=None,
receivers_x_locations=None,
receivers_y_locations=None,
source_depth=None,
source_kwargs={},
receiver_depth=None,
receiver_kwargs={},
parallel_shot_wrap=ParallelWrapShotNull()
):
## Define the acquisition geometry for given sources locations and receivers locations
if sources_x_locations is None:
raise ValueError("The horizontal locations of sources are not defined, please set values to variable 'sources_x_locations' ")
if receivers_x_locations is None:
raise ValueError("The horizontal locations of receivers are not defined, please set values to variable 'receivers_x_locations' ")
m = mesh
d = mesh.domain
xmin = d.x.lbound
xmax = d.x.rbound
zmin = d.z.lbound
zmax = d.z.rbound
if m.dim == 3:
ymin = d.y.lbound
ymax = d.y.rbound
if source_depth is None:
source_depth = zmin
if receiver_depth is None:
receiver_depth = zmin
shots = list()
max_sources = len(sources_x_locations)
if m.dim == 2:
receivers = len(receivers_x_locations)
sources = len(sources_x_locations)
xpos = receivers_x_locations
receiversbase = ReceiverSet(m, [PointReceiver(m, (x, receiver_depth), **receiver_kwargs) for x in xpos])
local_sources = sources / parallel_shot_wrap.size
if m.dim == 3:
receivers = (len(receivers_x_locations), len(receivers_y_locations)) # x, y
sources = (len(sources_x_locations), len(sources_y_locations)) # x, y
if receivers[0] > m.x.n or receivers[1] > m.y.n:
raise ValueError('Number of receivers exceeds mesh nodes.')
if sources[0] > m.x.n or sources[1] > m.y.n:
raise ValueError('Number of sources exceeds mesh nodes.')
xpos = receivers_x_locations
ypos = receivers_y_locations
receiversbase = ReceiverSet(m, [PointReceiver(
m, (x, y, receiver_depth), **receiver_kwargs) for x in xpos for y in ypos])
local_sources = np.prod(sources) / parallel_shot_wrap.size
print(type(local_sources))
print(local_sources)
for k in range(int(local_sources)):
index_true = int(local_sources) * parallel_shot_wrap.rank + k
subindex = np.unravel_index(index_true, sources)
idx = subindex[0]
if m.dim == 3:
jdx = subindex[1]
if m.dim == 2:
# srcpos = (xmin + (xmax-xmin)*(idx+1.0)/(sources+1.0), source_depth)
srcpos = (sources_x_locations[idx], source_depth)
elif m.dim == 3:
# srcpos = (xmin + (xmax-xmin)*(idx+1.0)/(sources[0]+1.0), ymin + (
# ymax-ymin)*(jdx+1.0)/(sources[1]+1.0), source_depth)
srcpos = (sources_x_locations[idx], sources_y_locations[jdx])
# Define source location and type
source = PointSource(m, srcpos, wavelet, **source_kwargs)
# Define set of receivers
receivers = copy.deepcopy(receiversbase)
# Create and store the shot
shot = Shot(source, receivers)
shots.append(shot)
return shots