def move_mesh(self, event: str, iteration: str):
"""
Move mesh to simulation mesh path, where model will be added to it
:param event: Name of event
:type event: str
:param iteration: Name of iteration
:type iteration: str
"""
import shutil
has, event_mesh = lapi.find_event_mesh(self.lasif_comm, event)
if not has:
raise ValueError(f"{event_mesh} does not exist")
else:
event_iteration_mesh = lapi.get_simulation_mesh(
self.lasif_comm, event, iteration)
if not os.path.exists(event_iteration_mesh):
if not os.path.exists(os.path.dirname(event_iteration_mesh)):
os.makedirs(os.path.dirname(event_iteration_mesh))
shutil.copy(event_mesh, event_iteration_mesh)
print(
f"Mesh for event: {event} has been moved to correct path for "
f"iteration: {iteration} and is ready for interpolation.")
else:
print(f"Mesh for event: {event} already exists in the "
f"correct path for iteration {iteration}. "
f"Will not move new one.")
def has_mesh(self, event: str) -> bool:
"""
Check whether mesh has been constructed for respective event
:param event: Name of event
:type event: str
:return: Answer whether mesh exists
:rtype: bool
"""
has, _ = lapi.find_event_mesh(self.lasif_comm, event)
return has
def find_event_mesh(self, event: str) -> pathlib.Path:
"""
Find the path for an event mesh
:param event: Name of event
:type event: str
:return: Path to where the mesh is stored.
:rtype: Pathlib.Path
"""
if self.comm.project.meshes == "mono-mesh":
mesh = self.lasif_comm.project.lasif_config["domain_settings"][
"domain_file"]
return mesh
has, mesh = lapi.find_event_mesh(self.lasif_comm, event)
if not has:
raise InversionsonError(
f"Mesh for event: {event} can not be found.")
return pathlib.Path(mesh)
def has_mesh(self, event: str, hpc_cluster=None) -> bool:
"""
Check whether mesh has been constructed for respective event
:param event: Name of event
:type event: str
:return: Answer whether mesh exists
:rtype: bool
"""
# If interpolations are remote, we check for mesh remotely too
if self.comm.project.interpolation_mode == "remote":
has, _ = self.has_remote_mesh(event,
gradient=False,
hpc_cluster=hpc_cluster)
else:
has, _ = lapi.find_event_mesh(self.lasif_comm, event)
return has
def move_mesh(self, event: str, iteration: str):
"""
Move mesh to simulation mesh path, where model will be added to it
:param event: Name of event
:type event: str
:param iteration: Name of iteration
:type iteration: str
"""
import shutil
# If we use mono-mesh we copy the salvus opt mesh here.
if self.comm.project.meshes == "mono-mesh":
self.comm.salvus_mesher.write_new_opt_fields_to_simulation_mesh()
return
has, event_mesh = lapi.find_event_mesh(self.lasif_comm, event)
if not has:
raise ValueError(f"{event_mesh} does not exist")
else:
event_iteration_mesh = lapi.get_simulation_mesh(
self.lasif_comm, event, iteration
)
if not os.path.exists(event_iteration_mesh):
if not os.path.exists(os.path.dirname(event_iteration_mesh)):
os.makedirs(os.path.dirname(event_iteration_mesh))
shutil.copy(event_mesh, event_iteration_mesh)
event_xdmf = event_mesh[:-2] + "xdmf"
event_iteration_xdmf = event_iteration_mesh[:-2] + "xdmf"
shutil.copy(event_xdmf, event_iteration_xdmf)
print(
f"Mesh for event: {event} has been moved to correct path for "
f"iteration: {iteration} and is ready for interpolation."
)
else:
print(
f"Mesh for event: {event} already exists in the "
f"correct path for iteration {iteration}. "
f"Will not move new one."
)
def _move_mesh_to_cluster(self,
event: str,
gradient=False,
hpc_cluster=None):
"""
Move the mesh to the cluster for interpolation
:param event: Name of event
:type event: str
"""
if event is None:
if gradient:
self.print("Moving example gradient to cluster",
emoji_alias=":package:")
self.move_gradient_to_cluster(hpc_cluster)
else:
# This happens when we want to move the model to the cluster
self.print("Moving model to cluster", emoji_alias=":package:")
self._move_model_to_cluster(hpc_cluster)
return
has, event_mesh = lapi.find_event_mesh(self.lasif_comm, event)
if not has:
raise InversionsonError(f"Mesh for event {event} does not exist.")
# Get remote connection
if hpc_cluster is None:
hpc_cluster = get_site(self.comm.project.interpolation_site)
path_to_mesh = self.find_remote_mesh(
event=event,
interpolate_to=True,
check_if_exists=False,
hpc_cluster=hpc_cluster,
)
if not hpc_cluster.remote_exists(path_to_mesh.parent):
hpc_cluster.remote_mkdir(path_to_mesh.parent)
if not hpc_cluster.remote_exists(path_to_mesh):
self.print(f"Moving mesh for event {event} to cluster",
emoji_alias=":package:")
hpc_cluster.remote_put(event_mesh, path_to_mesh)
def move_mesh(self,
event: str,
iteration: str,
hpc_cluster=None,
validation=False):
"""
Move mesh to simulation mesh path, where model will be added to it
:param event: Name of event
:type event: str
:param iteration: Name of iteration
:type iteration: str
"""
import shutil
# If we use mono-mesh we copy the salvus opt mesh here.
if self.comm.project.meshes == "mono-mesh":
optimizer = self.comm.project.get_optimizer()
model = optimizer.model_path
# copy to lasif project and also move to cluster
simulation_mesh = self.comm.lasif.get_simulation_mesh(
event_name=None)
shutil.copy(model, simulation_mesh)
self._move_model_to_cluster(hpc_cluster=hpc_cluster,
overwrite=False,
validation=validation)
return
if self.comm.project.interpolation_mode == "remote":
if event is None:
self._move_model_to_cluster(
hpc_cluster=hpc_cluster,
overwrite=False,
validation=validation,
)
else:
self._move_mesh_to_cluster(event=event,
hpc_cluster=hpc_cluster)
return
has, event_mesh = lapi.find_event_mesh(self.lasif_comm, event)
if not has:
raise ValueError(f"{event_mesh} does not exist")
else:
event_iteration_mesh = lapi.get_simulation_mesh(
self.lasif_comm, event, iteration)
if not os.path.exists(event_iteration_mesh):
if not os.path.exists(os.path.dirname(event_iteration_mesh)):
os.makedirs(os.path.dirname(event_iteration_mesh))
shutil.copy(event_mesh, event_iteration_mesh)
event_xdmf = event_mesh[:-2] + "xdmf"
event_iteration_xdmf = event_iteration_mesh[:-2] + "xdmf"
shutil.copy(event_xdmf, event_iteration_xdmf)
self.print(
f"Mesh for event: {event} has been moved to correct path for "
f"iteration: {iteration} and is ready for interpolation.",
emoji_alias=":package:",
)
else:
self.print(
f"Mesh for event: {event} already exists in the "
f"correct path for iteration {iteration}. "
f"Will not move new one.",
emoji_alias=":white_check_mark",
)