def createLocalProb(meshLocal, local_survey, global_weights, ind):
"""
CreateLocalProb(rxLoc, global_weights, lims, ind)
Generate a problem, calculate/store sensitivities for
given data points
"""
# Need to find a way to compute sensitivities only for intersecting cells
activeCells_t = np.ones(
meshLocal.nC,
dtype='bool') # meshUtils.modelutils.activeTopoLayer(meshLocal, topo)
# Create reduced identity map
if input_dict["inversion_type"].lower() in ['mvi', 'mvis']:
nBlock = 3
else:
nBlock = 1
tileMap = Maps.Tile((mesh, activeCells), (meshLocal, activeCells_t),
nBlock=nBlock)
activeCells_t = tileMap.activeLocal
if "adjust_clearance" in list(input_dict.keys()):
print("Setting Z values of data to respect clearance height")
r, c_ind = tree.query(local_survey.rxLoc)
dz = input_dict["adjust_clearance"]
z = mesh.gridCC[activeCells,
2][c_ind] + mesh.h_gridded[activeCells,
2][c_ind] / 2 + dz
local_survey.srcField.rxList[0].locs[:, 2] = z
if input_dict["inversion_type"].lower() == 'grav':
prob = PF.Gravity.GravityIntegral(meshLocal,
rhoMap=tileMap,
actInd=activeCells_t,
parallelized=parallelized,
Jpath=outDir + "Tile" + str(ind) +
".zarr",
maxRAM=max_ram,
n_cpu=n_cpu,
max_chunk_size=max_chunk_size)
elif input_dict["inversion_type"].lower() == 'mag':
prob = PF.Magnetics.MagneticIntegral(meshLocal,
chiMap=tileMap,
actInd=activeCells_t,
parallelized=parallelized,
Jpath=outDir + "Tile" + str(ind) +
".zarr",
maxRAM=max_ram,
n_cpu=n_cpu,
max_chunk_size=max_chunk_size)
elif input_dict["inversion_type"].lower() in ['mvi', 'mvis']:
prob = PF.Magnetics.MagneticIntegral(meshLocal,
chiMap=tileMap,
actInd=activeCells_t,
parallelized=parallelized,
Jpath=outDir + "Tile" + str(ind) +
".zarr",
maxRAM=max_ram,
modelType='vector',
n_cpu=n_cpu,
max_chunk_size=max_chunk_size)
local_survey.pair(prob)
# Data misfit function
local_misfit = DataMisfit.l2_DataMisfit(local_survey)
local_misfit.W = 1. / local_survey.std
wr = prob.getJtJdiag(np.ones(tileMap.shape[1]), W=local_misfit.W)
activeCellsTemp = Maps.InjectActiveCells(mesh, activeCells, 1e-8)
global_weights += wr
del meshLocal
if output_tile_files:
if input_dict["inversion_type"].lower() == 'grav':
Utils.io_utils.writeUBCgravityObservations(
outDir + 'Survey_Tile' + str(ind) + '.dat', local_survey,
local_survey.dobs)
elif input_dict["inversion_type"].lower() == 'mag':
Utils.io_utils.writeUBCmagneticsObservations(
outDir + 'Survey_Tile' + str(ind) + '.dat', local_survey,
local_survey.dobs)
Mesh.TreeMesh.writeUBC(mesh,
outDir + 'Octree_Tile' + str(ind) + '.msh',
models={
outDir + 'JtJ_Tile' + str(ind) + ' .act':
activeCellsTemp * wr[:nC]
})
return local_misfit, global_weights
def createLocalProb(rxLoc, wrGlobal, lims, ind):
# createLocalProb(rxLoc, wrGlobal, lims, ind)
# Generate a problem, calculate/store sensitivities for
# given data points
# Grab the data for current tile
ind_t = np.all([
rxLoc[:, 0] >= lims[0], rxLoc[:, 0] <= lims[1],
rxLoc[:, 1] >= lims[2], rxLoc[:, 1] <= lims[3], surveyMask
],
axis=0)
# Remember selected data in case of tile overlap
surveyMask[ind_t] = False
# Create new survey
if driver["dataFile"][0] == 'GRAV':
rxLoc_t = PF.BaseGrav.RxObs(rxLoc[ind_t, :])
srcField = PF.BaseGrav.SrcField([rxLoc_t])
survey_t = PF.BaseGrav.LinearSurvey(srcField)
survey_t.dobs = survey.dobs[ind_t]
survey_t.std = survey.std[ind_t]
survey_t.ind = ind_t
Utils.io_utils.writeUBCgravityObservations(
workDir + dsep + outDir + "Tile" + str(ind) + '.dat', survey_t,
survey_t.dobs)
elif driver["dataFile"][0] == 'MAG':
rxLoc_t = PF.BaseMag.RxObs(rxLoc[ind_t, :])
srcField = PF.BaseMag.SrcField([rxLoc_t],
param=survey.srcField.param)
survey_t = PF.BaseMag.LinearSurvey(srcField)
survey_t.dobs = survey.dobs[ind_t]
survey_t.std = survey.std[ind_t]
survey_t.ind = ind_t
Utils.io_utils.writeUBCmagneticsObservations(
workDir + dsep + outDir + "Tile" + str(ind) + '.dat', survey_t,
survey_t.dobs)
meshLocal = Utils.modelutils.meshBuilder(newTopo,
h,
padDist,
meshType='TREE',
meshGlobal=meshInput,
verticalAlignment='center')
if topo is not None:
meshLocal = Utils.modelutils.refineTree(meshLocal,
topo,
dtype='surface',
octreeLevels=octreeTopo,
finalize=False)
# Refine the mesh around loc
meshLocal = Utils.modelutils.refineTree(
meshLocal,
newTopo[ind_t, :],
dtype='surface',
octreeLevels=octreeObs,
octreeLevels_XY=octreeLevels_XY,
finalize=True)
# Need to find a way to compute sensitivities only for intersecting cells
activeCells_t = np.ones(
meshLocal.nC, dtype='bool'
) # meshUtils.modelutils.activeTopoLayer(meshLocal, topo)
# Create reduced identity map
tileMap = Maps.Tile((mesh, activeCells), (meshLocal, activeCells_t))
activeCells_t = tileMap.activeLocal
print(activeCells_t.sum(), meshLocal.nC)
if driver["dataFile"][0] == 'GRAV':
prob = PF.Gravity.GravityIntegral(meshLocal,
rhoMap=tileMap,
actInd=activeCells_t,
parallelized=parallelized,
Jpath=workDir + dsep + outDir +
"Tile" + str(ind) + ".zarr",
maxRAM=maxRAM / n_cpu,
n_cpu=n_cpu,
n_chunks=n_chunks)
elif driver["dataFile"][0] == 'MAG':
prob = PF.Magnetics.MagneticIntegral(
meshLocal,
chiMap=tileMap,
actInd=activeCells_t,
parallelized=parallelized,
Jpath=workDir + dsep + outDir + "Tile" + str(ind) + ".zarr",
maxRAM=maxRAM / n_cpu,
n_cpu=n_cpu,
n_chunks=n_chunks)
survey_t.pair(prob)
# Write out local active and obs for validation
Mesh.TreeMesh.writeUBC(
meshLocal,
workDir + dsep + outDir + dsep + 'Octree_Tile' + str(ind) + '.msh',
models={
workDir + dsep + outDir + dsep + 'ActiveGlobal_Tile' + str(ind) + ' .act':
activeCells_t
})
if driver["dataFile"][0] == 'GRAV':
Utils.io_utils.writeUBCgravityObservations(
workDir + dsep + outDir + dsep + 'Tile' + str(ind) + '.dat',
survey_t, survey_t.dobs)
elif driver["dataFile"][0] == 'MAG':
Utils.io_utils.writeUBCmagneticsObservations(
workDir + dsep + outDir + dsep + 'Tile' + str(ind) + '.dat',
survey_t, survey_t.dobs)
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey_t)
dmis.W = 1. / survey_t.std
wr = prob.getJtJdiag(np.ones(tileMap.P.shape[1]), W=dmis.W)
wrGlobal += wr
del meshLocal
# Create combo misfit function
return dmis
def createLocalProb(rxLoc, wrGlobal, lims, ind):
# Grab the data for current tile
ind_t = np.all([
rxLoc[:, 0] >= lims[0], rxLoc[:, 0] <= lims[1], rxLoc[:, 1] >= lims[2],
rxLoc[:, 1] <= lims[3], surveyMask
],
axis=0)
# Remember selected data in case of tile overlap
surveyMask[ind_t] = False
# Create new survey
rxLoc_t = PF.BaseGrav.RxObs(rxLoc[ind_t, :])
srcField = PF.BaseGrav.SrcField([rxLoc_t])
survey_t = PF.BaseGrav.LinearSurvey(srcField)
survey_t.dobs = survey.dobs[ind_t]
survey_t.std = survey.std[ind_t]
survey_t.ind = ind_t
meshLocal = Utils.modelutils.meshBuilder(rxLoc,
h,
padDist,
meshType='TREE',
meshGlobal=meshInput,
verticalAlignment='center')
if topo is not None:
meshLocal = Utils.modelutils.refineTree(meshLocal,
topo,
dtype='surface',
nCpad=octreeTopo,
finalize=False)
# Refine the mesh around loc
meshLocal = Utils.modelutils.refineTree(meshLocal,
rxLoc[ind_t, :],
dtype='surface',
nCpad=octreeObs,
finalize=True)
actv_t = np.ones(meshLocal.nC, dtype='bool')
Mesh.TreeMesh.writeUBC(
meshLocal,
work_dir + out_dir + 'OctreeMesh' + str(tt) + '.msh',
models={work_dir + out_dir + 'Active' + str(tt) + '.act': actv_t})
print(meshLocal.nC)
# Create reduced identity map
tileMap = Maps.Tile((mesh, actv), (meshLocal, actv_t))
# Create the forward model operator
prob = PF.Gravity.GravityIntegral(meshLocal,
rhoMap=tileMap,
actInd=actv_t,
parallelized=True,
Jpath=work_dir + out_dir + "Tile" +
str(ind) + ".zarr")
survey_t.pair(prob)
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey_t)
dmis.W = 1. / survey_t.std
wrGlobal += prob.getJtJdiag(np.ones(tileMap.P.shape[1]), W=dmis.W)
del meshLocal
# Create combo misfit function
return dmis, wrGlobal
shift = np.squeeze(mesh.gridCC[ind, :]) - center
mesh_t.x0 += shift
mesh_t.number()
# Extract model from global to local mesh
# if driver.topofile is not None:
# topo = np.genfromtxt(work_dir + driver.topofile,
# skip_header=1)
# actv_t = Utils.surface2ind_topo(mesh_t, topo, 'N')
# # actv_t = np.asarray(np.where(mkvc(actv))[0], dtype=int)
# else:
actv_t = np.ones(mesh_t.nC, dtype='bool')
# Create reduced identity map
tileMap = Maps.Tile((mesh, actv), (mesh_t, actv_t))
tileMap.nCell = 27
tileMap.nBlock = 3
# Create the forward model operator
prob = PF.Magnetics.MagneticVector(mesh_t, chiMap=tileMap, actInd=actv_t)
survey_t.pair(prob)
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey_t)
dmis.W = 1./survey_t.std
# ncell = Utils.mkvc(np.sum(prob.chiMap.deriv(0) > 0, axis=1))
# ncell[ncell>0] = (1./ncell[ncell>0]).copy()
# SCALE = Utils.sdiag(mesh_t.vol**(0))
for ii in range(prob.F.shape[0]):
wrGlobal += ((prob.F[ii, :])*(prob.chiMap.deriv(0)))**2.
def createLocalProb(rxLoc, wrGlobal, lims, ind):
# createLocalProb(rxLoc, wrGlobal, lims, ind)
# Generate a problem, calculate/store sensitivities for
# given data points
# Grab the data for current tile
ind_t = np.all([
rxLoc[:, 0] >= lims[0], rxLoc[:, 0] <= lims[1],
rxLoc[:, 1] >= lims[2], rxLoc[:, 1] <= lims[3], surveyMask
],
axis=0)
# Remember selected data in case of tile overlap
surveyMask[ind_t] = False
# Create new survey
rxLoc_t = PF.BaseMag.RxObs(rxLoc[ind_t, :])
srcField = PF.BaseMag.SrcField([rxLoc_t], param=survey.srcField.param)
survey_t = PF.BaseMag.LinearSurvey(srcField)
survey_t.dobs = survey.dobs[ind_t]
survey_t.std = survey.std[ind_t]
survey_t.ind = ind_t
Utils.io_utils.writeUBCmagneticsObservations(
out_dir + 'Tile' + str(tt) + 'dat', survey_t, survey_t.dobs)
meshLocal = Utils.modelutils.meshBuilder(newTopo,
h,
padDist,
meshType='TREE',
meshGlobal=meshInput,
verticalAlignment='center')
if topo is not None:
meshLocal = Utils.modelutils.refineTree(meshLocal,
topo,
dtype='surface',
octreeLevels=octreeTopo,
finalize=False)
# Refine the mesh around loc
meshLocal = Utils.modelutils.refineTree(
meshLocal,
newTopo[ind_t, :],
dtype='surface',
octreeLevels=octreeObs,
octreeLevels_XY=octreeObs_XY,
finalize=True,
)
actv_t = np.ones(meshLocal.nC, dtype='bool')
# Create reduced identity map
tileMap = Maps.Tile((mesh, actv), (meshLocal, actv_t), nBlock=3)
actv_t = tileMap.activeLocal
if homogenizeMref:
# Interpolate the geo model
_, ind = tree.query(meshLocal.gridCC)
mgeo_t = ((actvMap * mref)[ind])[actv_t]
# Build list of indecies for the geounits
index = []
for unit in geoUnits:
index += [mgeo_t == unit]
# Creat reduced identity map
homogMap_t = Maps.SurjectUnits(index)
homogMap.nBlock = 3
if modelDecomposition:
# Create Sum map
mapping = Maps.SumMap(
[homogMap_t * wires.h**o, tileMap * wires.hetero])
else:
mapping = homogMap_t * wires.h**o
else:
mapping = tileMap
# Create the forward model operator
prob = PF.Magnetics.MagneticIntegral(meshLocal,
chiMap=mapping,
actInd=actv_t,
parallelized=parallelized,
Jpath=out_dir + "Tile" +
str(ind) + ".zarr",
maxRAM=maxRAM,
modelType='vector',
n_cpu=np.ceil(n_cpu / nTiles))
survey_t.pair(prob)
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey_t)
dmis.W = 1. / survey_t.std
wr = prob.getJtJdiag(np.ones(int(mapping.shape[1])), W=dmis.W)
actvMap_t = Maps.InjectActiveCells(meshLocal, actv_t, 1e-8)
nC_t = int(actv_t.sum())
Mesh.TreeMesh.writeUBC(
meshLocal,
out_dir + 'OctreeMesh' + str(tt) + '.msh',
models={
out_dir + 'Wr_' + str(tt) + '.act':
actvMap_t * np.sum(
(tileMap * wr).reshape(nC_t, 3, order='F')**2., axis=1)**
0.5
})
wrGlobal += wr
del meshLocal
# Create combo misfit function
return dmis, wrGlobal
def createLocalProb(rxLoc, wrGlobal, lims, ind):
# Grab the data for current tile
ind_t = np.all([
rxLoc[:, 0] >= lims[0], rxLoc[:, 0] <= lims[1],
rxLoc[:, 1] >= lims[2], rxLoc[:, 1] <= lims[3], surveyMask
],
axis=0)
# Remember selected data in case of tile overlap
surveyMask[ind_t] = False
# Create new survey
rxLoc_t = PF.BaseMag.RxObs(rxLoc[ind_t, :])
srcField = PF.BaseMag.SrcField([rxLoc_t], param=survey.srcField.param)
survey_t = PF.BaseMag.LinearSurvey(srcField)
survey_t.dobs = survey.dobs[ind_t]
survey_t.std = survey.std[ind_t]
survey_t.ind = ind_t
meshLocal = meshutils.mesh_builder_xyz(topo,
h,
padding_distance=padDist,
mesh_type='TREE',
base_mesh=meshInput,
depth_core=depth_core)
if topo is not None:
meshLocal = meshutils.refine_tree_xyz(meshLocal,
topo,
method='surface',
octree_levels=octreeTopo,
finalize=False)
meshLocal = meshutils.refine_tree_xyz(
meshLocal,
rxLoc[ind_t, :],
method='surface',
max_distance=maxDist,
octree_levels=octreeObs,
octree_levels_padding=octreeObs_XY,
finalize=True,
)
actv_t = np.ones(meshLocal.nC, dtype='bool')
# Create reduced identity map
tileMap = Maps.Tile((mesh, actv), (meshLocal, actv_t))
actv_t = tileMap.activeLocal
print(actv_t.sum(), meshLocal.nC)
# Create the forward model operator
prob = PF.Magnetics.MagneticIntegral(meshLocal,
chiMap=tileMap,
actInd=actv_t,
parallelized='dask',
Jpath=work_dir + out_dir +
"Tile" + str(ind) + ".zarr",
store_zarr=True)
survey_t.pair(prob)
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey_t)
dmis.W = 1. / survey_t.std
wr = prob.getJtJdiag(np.ones(tileMap.P.shape[1]), W=dmis.W)
localMap = Maps.InjectActiveCells(meshLocal, actv_t, 1e-8)
Mesh.TreeMesh.writeUBC(
mesh,
work_dir + out_dir + 'OctreeMesh' + str(tt) + '.msh',
models={
work_dir + out_dir + 'Wr_' + str(tt) + '.act': actvMap * wr
})
Mesh.TreeMesh.writeUBC(
meshLocal,
work_dir + out_dir + 'OctreeMesh' + str(tt) + '.msh',
models={
work_dir + out_dir + 'Wr_' + str(tt) + '.act':
localMap * tileMap * wr
})
# localMap = Maps.InjectActiveCells(meshLocal, actv_t, 1e-8)
# Mesh.TreeMesh.writeUBC(
# meshLocal, work_dir + out_dir + 'OctreeMesh' + str(tt) + '.msh',
# models={work_dir + out_dir + 'Wr_' + str(tt) + '.act': localMap*wr}
# )
#
wrGlobal += wr
del meshLocal
# Create combo misfit function
return dmis, wrGlobal
def createLocalProb(rxLoc, wrGlobal, ind_t, ind):
# createLocalProb(rxLoc, wrGlobal, lims, ind)
# Generate a problem, calculate/store sensitivities for
# given data points
# Grab the data for current tile
# ind_t = np.all([rxLoc[:, 0] >= lims[0], rxLoc[:, 0] <= lims[1],
# rxLoc[:, 1] >= lims[2], rxLoc[:, 1] <= lims[3],
# surveyMask], axis=0)
# Remember selected data in case of tile overlap
surveyMask[ind_t] = False
# Create new survey
if input_dict["inversion_type"].lower() == 'grav':
rxLoc_t = PF.BaseGrav.RxObs(rxLoc[ind_t, :])
srcField = PF.BaseGrav.SrcField([rxLoc_t])
survey_t = PF.BaseGrav.LinearSurvey(srcField)
survey_t.dobs = survey.dobs[ind_t]
survey_t.std = survey.std[ind_t]
survey_t.ind = ind_t
Utils.io_utils.writeUBCgravityObservations(outDir + "Tile" + str(ind) + '.dat', survey_t, survey_t.dobs)
elif input_dict["inversion_type"].lower() in ['mag', 'mvi']:
rxLoc_t = PF.BaseMag.RxObs(rxLoc[ind_t, :])
srcField = PF.BaseMag.SrcField([rxLoc_t], param=survey.srcField.param)
survey_t = PF.BaseMag.LinearSurvey(srcField)
survey_t.dobs = survey.dobs[ind_t]
survey_t.std = survey.std[ind_t]
survey_t.ind = ind_t
Utils.io_utils.writeUBCmagneticsObservations(outDir + "Tile" + str(ind) + '.dat', survey_t, survey_t.dobs)
meshLocal = meshutils.mesh_builder_xyz(
newTopo, core_cell_size, padding_distance=padding_distance, mesh_type='TREE', base_mesh=meshInput,
depth_core=depth_core
)
if topo is not None:
meshLocal = meshutils.refine_tree_xyz(
meshLocal, topo, method='surface',
octree_levels=octree_levels_topo, finalize=False
)
meshLocal = meshutils.refine_tree_xyz(
meshLocal, rxLoc[ind_t, :], method='surface',
max_distance=max_distance,
octree_levels=octree_levels_obs,
octree_levels_padding=octree_levels_padding,
finalize=True,
)
# Need to find a way to compute sensitivities only for intersecting cells
activeCells_t = np.ones(meshLocal.nC, dtype='bool') # meshUtils.modelutils.activeTopoLayer(meshLocal, topo)
# Create reduced identity map
if input_dict["inversion_type"].lower() == 'mvi':
nBlock = 3
else:
nBlock = 1
tileMap = Maps.Tile((mesh, activeCells), (meshLocal, activeCells_t), nBlock=nBlock)
activeCells_t = tileMap.activeLocal
print(activeCells_t.sum(), meshLocal.nC)
if input_dict["inversion_type"].lower() == 'grav':
prob = PF.Gravity.GravityIntegral(
meshLocal, rhoMap=tileMap, actInd=activeCells_t,
parallelized=parallelized,
Jpath=outDir + "Tile" + str(ind) + ".zarr",
maxRAM=max_ram,
n_cpu=n_cpu,
)
elif input_dict["inversion_type"].lower() == 'mag':
prob = PF.Magnetics.MagneticIntegral(
meshLocal, chiMap=tileMap, actInd=activeCells_t,
parallelized=parallelized,
Jpath=outDir + "Tile" + str(ind) + ".zarr",
maxRAM=max_ram,
n_cpu=n_cpu,
)
elif input_dict["inversion_type"].lower() == 'mvi':
prob = PF.Magnetics.MagneticIntegral(
meshLocal, chiMap=tileMap, actInd=activeCells_t,
parallelized=parallelized,
Jpath=outDir + "Tile" + str(ind) + ".zarr",
maxRAM=max_ram,
modelType='vector',
n_cpu=n_cpu
)
survey_t.pair(prob)
# Write out local active and obs for validation
Mesh.TreeMesh.writeUBC(
meshLocal, outDir + 'Octree_Tile' + str(ind) + '.msh',
models={outDir + 'ActiveGlobal_Tile' + str(ind) + ' .act': activeCells_t}
)
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey_t)
dmis.W = 1./survey_t.std
wr = prob.getJtJdiag(np.ones(tileMap.shape[1]), W=dmis.W)
wrGlobal += wr
del meshLocal
# Create combo misfit function
return dmis
def createLocalProb(rxLoc, wrGlobal, lims, tileID):
# Grab the data for current tile
ind_t = np.all([rxLoc[:, 0] >= lims[0], rxLoc[:, 0] <= lims[1],
rxLoc[:, 1] >= lims[2], rxLoc[:, 1] <= lims[3],
surveyMask], axis=0)
# Remember selected data in case of tile overlap
surveyMask[ind_t] = False
# Create new survey
rxLoc_t = PF.BaseGrav.RxObs(rxLoc[ind_t, :])
srcField = PF.BaseGrav.SrcField([rxLoc_t])
survey_t = PF.BaseGrav.LinearSurvey(srcField)
survey_t.dobs = survey.dobs[ind_t]
survey_t.std = survey.std[ind_t]
survey_t.ind = ind_t
meshLocal = Utils.modelutils.meshBuilder(
rxLoc, h, padDist, meshType='TREE', meshGlobal=meshInput,
verticalAlignment='center'
)
if topo is not None:
meshLocal = Utils.modelutils.refineTree(
meshLocal, topo, dtype='surface',
nCpad=octreeTopo, finalize=False
)
# Refine the mesh around loc
meshLocal = Utils.modelutils.refineTree(
meshLocal, rxLoc[ind_t, :], dtype='surface',
nCpad=octreeObs, finalize=True
)
actv_t = np.ones(meshLocal.nC, dtype='bool')
Mesh.TreeMesh.writeUBC(
meshLocal,
out_dir + 'OctreeMesh' + str(tt) + '.msh',
models={
out_dir + 'Active' + str(tileID) + '.act':
actv_t
}
)
# Create reduced identity map
tileMap = Maps.Tile((mesh, actv), (meshLocal, actv_t))
actv_t = tileMap.activeLocal
# Interpolate the geo model
_, ind = tree.query(meshLocal.gridCC)
mgeo_t = ((fullMap * mgeo)[ind])[actv_t]
# Build list of indecies for the geounits
index = []
for unit in geoUnits:
index += [mgeo_t == unit]
# Creat reduced identity map
homogMap_t = Maps.SurjectUnits(index)
# Create Sum map
sumMap = Maps.SumMap([homogMap_t*wires.h**o, tileMap*wires.hetero])
# Create the forward model operator
prob = PF.Gravity.GravityIntegral(
meshLocal, rhoMap=sumMap,
actInd=actv_t,
parallelized=parallization,
Jpath=out_dir + "Tile" + str(tileID) + ".zarr",
n_cpu=n_cpu
)
survey_t.pair(prob)
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey_t)
dmis.W = 1./survey_t.std
wrGlobal += prob.getJtJdiag(np.ones(wires.h**o.shape[1]), W=dmis.W)
del meshLocal
# Create combo misfit function
return dmis, wrGlobal
