def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Pre-initializing fault '%s'." % self.label())
FaultCohesive.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
ModuleFaultCohesiveDyn.quadrature(self, self.faultQuadrature)
if mesh.dimension() == 2:
self.availableFields['vertex']['info'] += ["strike_dir"]
elif mesh.dimension() == 3:
self.availableFields['vertex']['info'] += ["strike_dir", "dip_dir"]
if not isinstance(self.tract, NullComponent):
self.tract.preinitialize(mesh)
self.availableFields['vertex'][
'info'] += self.tract.availableFields['vertex']['info']
self.availableFields['vertex']['info'] += \
self.friction.availableFields['vertex']['info']
self.availableFields['vertex']['data'] += \
self.friction.availableFields['vertex']['data']
return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Pre-initializing fault '%s'." % self.label())
FaultCohesive.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
ModuleFaultCohesiveDyn.quadrature(self, self.faultQuadrature)
if mesh.dimension() == 2:
self.availableFields['vertex']['info'] += ["strike_dir"]
elif mesh.dimension() == 3:
self.availableFields['vertex']['info'] += ["strike_dir",
"dip_dir"]
if not isinstance(self.tract, NullComponent):
self.tract.preinitialize(mesh)
self.availableFields['vertex']['info'] += self.tract.availableFields['vertex']['info']
self.availableFields['vertex']['info'] += \
self.friction.availableFields['vertex']['info']
self.availableFields['vertex']['data'] += \
self.friction.availableFields['vertex']['data']
return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
BoundaryCondition.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Pre-initializing fault '%s'." % self.label())
FaultCohesive.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
ModuleFaultCohesiveKin.quadrature(self, self.faultQuadrature)
for eqsrc in self.eqsrcs.components():
eqsrc.preinitialize()
ModuleFaultCohesiveKin.eqsrcs(self, self.eqsrcs.inventory.facilityNames(),
self.eqsrcs.components())
for name in self.eqsrcs.inventory.facilityNames():
self.availableFields['vertex']['info'] += ["final_slip_%s" % name]
self.availableFields['vertex']['info'] += ["slip_time_%s" % name]
if mesh.dimension() == 2:
self.availableFields['vertex']['info'] += ["strike_dir"]
elif mesh.dimension() == 3:
self.availableFields['vertex']['info'] += ["strike_dir",
"dip_dir"]
return
def preinitialize(self, mesh): """ Do pre-initialization setup. """ BoundaryCondition.preinitialize(self, mesh) Integrator.preinitialize(self, mesh) return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Pre-initializing fault '%s'." % self.label())
FaultCohesive.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
ModuleFaultCohesiveKin.quadrature(self, self.faultQuadrature)
for eqsrc in self.eqsrcs.components():
eqsrc.preinitialize()
ModuleFaultCohesiveKin.eqsrcs(self,
self.eqsrcs.inventory.facilityNames(),
self.eqsrcs.components())
for name in self.eqsrcs.inventory.facilityNames():
self.availableFields['vertex']['info'] += ["final_slip_%s" % name]
self.availableFields['vertex']['info'] += ["slip_time_%s" % name]
if mesh.dimension() == 2:
self.availableFields['vertex']['info'] += ["strike_dir"]
elif mesh.dimension() == 3:
self.availableFields['vertex']['info'] += ["strike_dir", "dip_dir"]
return
def __init__(self, name="absorbingdampers"):
"""
Constructor.
"""
BoundaryCondition.__init__(self, name)
Integrator.__init__(self)
self._loggingPrefix = "AbBC "
return
def __init__(self, name="pointforce"): """ Constructor. """ BoundaryCondition.__init__(self, name) Integrator.__init__(self) self._loggingPrefix = "PFBC " return
def finalize(self): """ Cleanup. """ BoundaryCondition.finalize(self) Integrator.finalize(self) self._modelMemoryUse() return
def __init__(self, name="pointforce"):
"""
Constructor.
"""
BoundaryCondition.__init__(self, name)
Integrator.__init__(self)
self._loggingPrefix = "PFBC "
return
def finalize(self):
"""
Cleanup.
"""
BoundaryCondition.finalize(self)
Integrator.finalize(self)
self._modelMemoryUse()
return
def __init__(self, name="absorbingdampers"): """ Constructor. """ BoundaryCondition.__init__(self, name) Integrator.__init__(self) self._loggingPrefix = "AbBC " return
def finalize(self): """ Cleanup. """ FaultCohesive.finalize(self) Integrator.finalize(self) self.output.close() self.output.finalize() return
def finalize(self):
"""
Cleanup.
"""
FaultCohesive.finalize(self)
Integrator.finalize(self)
self.output.close()
self.output.finalize()
return
def preinitialize(self, mesh): """ Do pre-initialization setup. """ BoundaryCondition.preinitialize(self, mesh) Integrator.preinitialize(self, mesh) self.bcQuadrature.preinitialize(mesh.coordsys().spaceDim()) self.quadrature(self.bcQuadrature) self.createSubMesh(mesh) return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
BoundaryCondition.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
self.bcQuadrature.preinitialize(mesh.coordsys().spaceDim())
self.quadrature(self.bcQuadrature)
self.createSubMesh(mesh)
return
def finalize(self):
"""
Cleanup.
"""
for eqsrc in self.eqsrcs.components():
eqsrc.finalize()
FaultCohesive.finalize(self)
Integrator.finalize(self)
self.output.close()
self.output.finalize()
return
def finalize(self):
"""
Cleanup.
"""
for eqsrc in self.eqsrcs.components():
eqsrc.finalize()
FaultCohesive.finalize(self)
Integrator.finalize(self)
self.output.close()
self.output.finalize()
return
def poststep(self, t, dt, fields):
"""
Hook for doing stuff after advancing time step.
"""
logEvent = "%spoststep" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
Integrator.poststep(self, t, dt, fields)
FaultCohesive.poststep(self, t, dt, fields)
self._eventLogger.eventEnd(logEvent)
return
def poststep(self, t, dt, fields):
"""
Hook for doing stuff after advancing time step.
"""
logEvent = "%spoststep" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
Integrator.poststep(self, t, dt, fields)
FaultCohesive.poststep(self, t, dt, fields)
self._eventLogger.eventEnd(logEvent)
return
def verifyConfiguration(self):
"""
Verify compatibility of configuration.
"""
logEvent = "%sverify" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
FaultCohesive.verifyConfiguration(self)
Integrator.verifyConfiguration(self)
ModuleFaultCohesiveImpulses.verifyConfiguration(self, self.mesh())
self._eventLogger.eventEnd(logEvent)
return
def verifyConfiguration(self):
"""
Verify compatibility of configuration.
"""
logEvent = "%sverify" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
FaultCohesive.verifyConfiguration(self)
Integrator.verifyConfiguration(self)
ModuleFaultCohesiveDyn.verifyConfiguration(self, self.mesh())
self._eventLogger.eventEnd(logEvent)
return
def __init__(self, name="faultcohesiveimpulses"):
"""
Initialize configuration.
"""
FaultCohesive.__init__(self, name)
Integrator.__init__(self)
self._loggingPrefix = "CoIm "
self.availableFields = {
"vertex": {"info": ["normal_dir", "impulse_amplitude", "area"], "data": ["slip", "traction_change"]},
"cell": {"info": ["partition"], "data": []},
}
return
def initialize(self, totalTime, numTimeSteps, normalizer):
"""
Initialize cohesive elements.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
self._info.log("Initializing fault '%s'." % self.label())
Integrator.initialize(self, totalTime, numTimeSteps, normalizer)
FaultCohesive.initialize(self, totalTime, numTimeSteps, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def initialize(self, totalTime, numTimeSteps, normalizer):
"""
Initialize cohesive elements.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
self._info.log("Initializing fault '%s'." % self.label())
Integrator.initialize(self, totalTime, numTimeSteps, normalizer)
FaultCohesive.initialize(self, totalTime, numTimeSteps, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def __init__(self, name="neumann"):
"""
Constructor.
"""
BoundaryCondition.__init__(self, name)
Integrator.__init__(self)
TimeDependent.__init__(self)
self._loggingPrefix = "NeBC "
self.availableFields = \
{'vertex': \
{'info': [],
'data': []},
'cell': \
{'info': [],
'data': []}}
return
def verifyConfiguration(self):
"""
Verify compatibility of configuration.
"""
logEvent = "%sverify" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
FaultCohesive.verifyConfiguration(self)
Integrator.verifyConfiguration(self)
ModuleFaultCohesiveKin.verifyConfiguration(self, self.mesh())
for eqsrc in self.eqsrcs.components():
eqsrc.verifyConfiguration()
self._eventLogger.eventEnd(logEvent)
return
def verifyConfiguration(self):
"""
Verify compatibility of configuration.
"""
logEvent = "%sverify" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
FaultCohesive.verifyConfiguration(self)
Integrator.verifyConfiguration(self)
ModuleFaultCohesiveKin.verifyConfiguration(self, self.mesh())
for eqsrc in self.eqsrcs.components():
eqsrc.verifyConfiguration()
self._eventLogger.eventEnd(logEvent)
return
def __init__(self, name="neumann"):
"""
Constructor.
"""
BoundaryCondition.__init__(self, name)
Integrator.__init__(self)
TimeDependent.__init__(self)
self._loggingPrefix = "NeBC "
self.availableFields = \
{'vertex': \
{'info': [],
'data': []},
'cell': \
{'info': [],
'data': []}}
return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
self._info.log("Pre-initializing fault '%s'." % self.label())
FaultCohesive.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
ModuleFaultCohesiveTract.quadrature(self, self.faultQuadrature)
if mesh.dimension() == 2:
self.availableFields['cell']['info'] += ["strike_dir"]
elif mesh.dimension() == 3:
self.availableFields['cell']['info'] += ["strike_dir",
"dip_dir"]
return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
self._info.log("Pre-initializing fault '%s'." % self.label())
FaultCohesive.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
ModuleFaultCohesiveTract.quadrature(self, self.faultQuadrature)
if mesh.dimension() == 2:
self.availableFields['cell']['info'] += ["strike_dir"]
elif mesh.dimension() == 3:
self.availableFields['cell']['info'] += ["strike_dir",
"dip_dir"]
return
def initialize(self, totalTime, numTimeSteps, normalizer):
"""
Initialize PointForce boundary condition.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Initializing point forces '%s'." % self.label())
Integrator.initialize(self, totalTime, numTimeSteps, normalizer)
BoundaryCondition.initialize(self, totalTime, numTimeSteps, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def __init__(self, name="faultcohesivedyn"):
"""
Initialize configuration.
"""
FaultCohesive.__init__(self, name)
Integrator.__init__(self)
self._loggingPrefix = "CoTr "
self.availableFields = \
{'vertex': \
{'info': [],
'data': []},
'cell': \
{'info': ["normal_dir"],
'data': ["slip",
"traction"]},
}
return
def __init__(self, name="faultcohesivedyn"):
"""
Initialize configuration.
"""
FaultCohesive.__init__(self, name)
Integrator.__init__(self)
self._loggingPrefix = "CoDy "
self.availableFields = \
{'vertex': \
{'info': ["normal_dir"],
'data': ["slip",
"slip_rate",
"traction"]},
'cell': \
{'info': ["partition"],
'data': []}}
return
def initialize(self, totalTime, numTimeSteps, normalizer):
"""
Initialize cohesive elements.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Initializing fault '%s'." % self.label())
Integrator.initialize(self, totalTime, numTimeSteps, normalizer)
FaultCohesive.initialize(self, totalTime, numTimeSteps, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def initialize(self, totalTime, numTimeSteps, normalizer):
"""
Initialize PointForce boundary condition.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Initializing point forces '%s'." % self.label())
Integrator.initialize(self, totalTime, numTimeSteps, normalizer)
BoundaryCondition.initialize(self, totalTime, numTimeSteps, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def initialize(self, totalTime, numTimeSteps, normalizer):
"""
Initialize cohesive elements.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Initializing fault '%s'." % self.label())
Integrator.initialize(self, totalTime, numTimeSteps, normalizer)
FaultCohesive.initialize(self, totalTime, numTimeSteps, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def __init__(self, name="faultcohesivekin"):
"""
Initialize configuration.
"""
FaultCohesive.__init__(self, name)
Integrator.__init__(self)
self._loggingPrefix = "CoKi "
self.availableFields = \
{'vertex': \
{'info': ["normal_dir",
"final_slip",
"slip_time"],
'data': ["slip",
"traction_change"]},
'cell': \
{'info': ["partition"],
'data': []}}
return
def verifyConfiguration(self):
"""
Verify compatibility of configuration.
"""
logEvent = "%sverify" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
BoundaryCondition.verifyConfiguration(self, self.mesh())
Integrator.verifyConfiguration(self)
if self.bcQuadrature.cellDim() != self.mesh().dimension() - 1:
raise ValueError, "Quadrature scheme and mesh are incompatible.\n" "Dimension for quadrature: %d\n" "Dimension of mesh boundary '%s': %d" % (
self.bcQuadrature.cellDim,
self.label(),
self.mesh().dimension() - 1,
)
ModuleAbsorbingDampers.verifyConfiguration(self, self.mesh())
self._eventLogger.eventEnd(logEvent)
return
def __init__(self, name="faultcohesiveimpulses"):
"""
Initialize configuration.
"""
FaultCohesive.__init__(self, name)
Integrator.__init__(self)
self._loggingPrefix = "CoIm "
self.availableFields = \
{'vertex': \
{'info': ["normal_dir",
"impulse_amplitude",
"area",],
'data': ["slip",
"traction_change"]},
'cell': \
{'info': ["partition"],
'data': []}}
return
def __init__(self, name="faultcohesiveimpulses"):
"""
Initialize configuration.
"""
FaultCohesive.__init__(self, name)
Integrator.__init__(self)
self._loggingPrefix = "CoIm "
self.availableFields = \
{'vertex': \
{'info': ["normal_dir",
"impulse_amplitude",
"area",],
'data': ["slip",
"traction_change"]},
'cell': \
{'info': ["partition"],
'data': []}}
return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Pre-initializing fault '%s'." % self.label())
FaultCohesive.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
ModuleFaultCohesiveImpulses.quadrature(self, self.faultQuadrature)
if mesh.dimension() == 2:
self.availableFields['vertex']['info'] += ["strike_dir"]
elif mesh.dimension() == 3:
self.availableFields['vertex']['info'] += ["strike_dir",
"dip_dir"]
return
def verifyConfiguration(self):
"""
Verify compatibility of configuration.
"""
logEvent = "%sverify" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
BoundaryCondition.verifyConfiguration(self, self.mesh())
Integrator.verifyConfiguration(self)
if self.bcQuadrature.cellDim() != self.mesh().dimension() - 1:
raise ValueError, \
"Quadrature scheme and mesh are incompatible.\n" \
"Dimension for quadrature: %d\n" \
"Dimension of mesh boundary '%s': %d" % \
(self.bcQuadrature.cellDim,
self.label(), self.mesh().dimension()-1)
ModuleAbsorbingDampers.verifyConfiguration(self, self.mesh())
self._eventLogger.eventEnd(logEvent)
return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Pre-initializing fault '%s'." % self.label())
FaultCohesive.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
ModuleFaultCohesiveImpulses.quadrature(self, self.faultQuadrature)
if mesh.dimension() == 2:
self.availableFields['vertex']['info'] += ["strike_dir"]
elif mesh.dimension() == 3:
self.availableFields['vertex']['info'] += ["strike_dir",
"dip_dir"]
return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
BoundaryCondition.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
self.bcQuadrature.preinitialize(mesh.coordsys().spaceDim())
self.quadrature(self.bcQuadrature)
self.createSubMesh(mesh)
self.output.preinitialize(self)
fields = []
if not isinstance(self.inventory.dbInitial, NullComponent):
fields += ["initial_value"]
if not isinstance(self.inventory.dbRate, NullComponent):
fields += ["rate_of_change", "rate_start_time"]
if not isinstance(self.inventory.dbChange, NullComponent):
fields += ["change_in_value", "change_start_time"]
self.availableFields['cell']['info'] += fields
return
def preinitialize(self, mesh):
"""
Do pre-initialization setup.
"""
BoundaryCondition.preinitialize(self, mesh)
Integrator.preinitialize(self, mesh)
self.bcQuadrature.preinitialize(mesh.coordsys().spaceDim())
self.quadrature(self.bcQuadrature)
self.createSubMesh(mesh)
self.output.preinitialize(self)
fields = []
if not isinstance(self.inventory.dbInitial, NullComponent):
fields += ["initial_value"]
if not isinstance(self.inventory.dbRate, NullComponent):
fields += ["rate_of_change", "rate_start_time"]
if not isinstance(self.inventory.dbChange, NullComponent):
fields += ["change_in_value", "change_start_time"]
self.availableFields['cell']['info'] += fields
return
def initialize(self, totalTime, numTimeSteps, normalizer):
"""
Initialize Neumann boundary condition.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Initializing Neumann boundary '%s'." % self.label())
Integrator.initialize(self, totalTime, numTimeSteps, normalizer)
BoundaryCondition.initialize(self, totalTime, numTimeSteps, normalizer)
self.output.initialize(normalizer, self.bcQuadrature)
self.output.writeInfo()
self._eventLogger.eventEnd(logEvent)
return
def initialize(self, totalTime, numTimeSteps, normalizer):
"""
Initialize Neumann boundary condition.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
from pylith.mpi.Communicator import mpi_comm_world
comm = mpi_comm_world()
if 0 == comm.rank:
self._info.log("Initializing Neumann boundary '%s'." % self.label())
Integrator.initialize(self, totalTime, numTimeSteps, normalizer)
BoundaryCondition.initialize(self, totalTime, numTimeSteps, normalizer)
self.output.initialize(normalizer, self.bcQuadrature)
self.output.writeInfo()
self._eventLogger.eventEnd(logEvent)
return
