def evaluate_constraint(self, mesh, element, eqn, masterpos, smallsystem):
# TODO: Test for the right equation.
# Compute the stress -- start with the strain.
strain = symmmatrix.SymmMatrix3
ep = field.getField('Plastic')
efi = element.funcnode_iterator()
while not efi.end():
coef = efi.shapefunction(masterpos)
ep_output = ep.output(mesh, efi.funcnode())
strain -= ep_output.valuePtr()*coef
efi += 1
disp = field.getField('Displacement')
efi = element.funcnode_iterator()
while not efi.end():
ddx = efi.dshapefunction(0,masterpos)
ddy = efi.dshapefunction(1,masterpos)
uxx = disp(efi,0).value()*ddx
uxy = disp(efi,0).value()*ddy
uyx = disp(efi,1).value()*ddx
uyy = disp(efi,1).value()*ddy
strain.set(0,0,strain.get(0,0)+uxx)
strain.set(0,1,strain.get(0,1)+(0.5*uxy+uyx))
strain.set(1,1,strain.get(1,1)+uyy)
try:
ops = field.getField('Displacement_z')
except:
pass
else:
efi = element.funcnode_iterator()
while not efi.end():
uxz = ops(efi,0).value()
uyz = ops(efi,1).value()
uyz = ops(efi,2).value()
strain.set(0,2,strain.get(0,2)+uxz)
strain.set(1,2,strain.get(1,2)+uyz)
strain.set(2,2,strain.get(2,2)+uzz)
# At this point, "strain" contains the elastic strain,
# geometric minus plastic.
modulus = self.elasticity.cijkl(mesh, element, masterpos)
ij = fieldindex.SymTensorIterator()
while (not ij.end()):
stressij = 0.0
kl = ep_val.getIterator()
while (not kl.end()):
idx = kl.integer
cijkl = modulus[ij.integer(),kl.integer()]
if idx<3:
stressij += cijkl*strain[kl]
else:
stressij += 2.0*cijkl*strain[kl]
kl.next()
# Accumulate the stress somewhere.
ij.next()
def evaluate_constraint(self, mesh, element, eqn, masterpos, smallsystem):
# TODO: Test for the right equation.
# Compute the stress -- start with the strain.
strain = symmmatrix.SymmMatrix3
ep = field.getField('Plastic')
efi = element.funcnode_iterator()
while not efi.end():
coef = efi.shapefunction(masterpos)
ep_output = ep.output(mesh, efi.funcnode())
strain -= ep_output.valuePtr() * coef
efi += 1
disp = field.getField('Displacement')
efi = element.funcnode_iterator()
while not efi.end():
ddx = efi.dshapefunction(0, masterpos)
ddy = efi.dshapefunction(1, masterpos)
uxx = disp(efi, 0).value() * ddx
uxy = disp(efi, 0).value() * ddy
uyx = disp(efi, 1).value() * ddx
uyy = disp(efi, 1).value() * ddy
strain.set(0, 0, strain.get(0, 0) + uxx)
strain.set(0, 1, strain.get(0, 1) + (0.5 * uxy + uyx))
strain.set(1, 1, strain.get(1, 1) + uyy)
try:
ops = field.getField('Displacement_z')
except:
pass
else:
efi = element.funcnode_iterator()
while not efi.end():
uxz = ops(efi, 0).value()
uyz = ops(efi, 1).value()
uyz = ops(efi, 2).value()
strain.set(0, 2, strain.get(0, 2) + uxz)
strain.set(1, 2, strain.get(1, 2) + uyz)
strain.set(2, 2, strain.get(2, 2) + uzz)
# At this point, "strain" contains the elastic strain,
# geometric minus plastic.
modulus = self.elasticity.cijkl(mesh, element, masterpos)
ij = fieldindex.SymTensorIterator()
while (not ij.end()):
stressij = 0.0
kl = ep_val.getIterator()
while (not kl.end()):
idx = kl.integer
cijkl = modulus[ij.integer(), kl.integer()]
if idx < 3:
stressij += cijkl * strain[kl]
else:
stressij += 2.0 * cijkl * strain[kl]
kl.next()
# Accumulate the stress somewhere.
ij.next()
def heatEqnEngine(self, soln_no, z_soln_no, test_solver):
soln_func = self.heat_solns[soln_no]["Solution"]
z_soln_func = self.heat_solns[z_soln_no]["Solution"]
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=StaticDriver(),
nonlinear_solver=test_solver,
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000)))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Temperature,
initializer=ConstScalarFieldInit(value=0.0))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Temperature_z,
initializer=ConstScalarFieldInit(value=0.0))
OOF.Mesh.Apply_Field_Initializers(mesh='microstructure:skeleton:mesh')
OOF.Mesh.Solve(mesh='microstructure:skeleton:mesh', endtime=self.time)
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
mesh_obj = mesh.meshes["microstructure:skeleton:mesh"].getObject()
# first compute the numerical error in the computed temperature field
field_ptr = field.getField("Temperature")
L2_error = computeScalarErrorL2(soln_func,
mesh_obj,
field_ptr,
self.numX,
self.numY,
time=self.time)
print "Temperature L2 error: ", L2_error
self.assert_(L2_error < 1.e-2)
# now compute the numerical error in the computed temperature_z field
field_ptr = field.getField("Temperature_z")
L2_error = computeScalarErrorL2(z_soln_func,
mesh_obj,
field_ptr,
self.numX,
self.numY,
time=self.time)
print "Temperture_z L2 error: ", L2_error
self.assert_(L2_error < 1.e-2)
def elasticityEqnEngine(self, soln_no, z_soln_no, test_solver):
soln_func = self.elasticity_solns[soln_no]["Solution"]
z_soln_func = self.elasticity_z_solns[z_soln_no]["Solution"]
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=StaticDriver(),
nonlinear_solver=test_solver,
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000)))
OOF.Mesh.Set_Field_Initializer(mesh='microstructure:skeleton:mesh',
field=Displacement,
initializer=ConstTwoVectorFieldInit(
cx=0.0, cy=0.0))
OOF.Mesh.Apply_Field_Initializers(mesh='microstructure:skeleton:mesh')
OOF.Mesh.Set_Field_Initializer(mesh='microstructure:skeleton:mesh',
field=Displacement_z,
initializer=ConstThreeVectorFieldInit(
cx=0.0, cy=0.0, cz=0.0))
OOF.Mesh.Solve(mesh='microstructure:skeleton:mesh', endtime=self.time)
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
mesh_obj = mesh.meshes["microstructure:skeleton:mesh"].getObject()
field_ptr = field.getField("Displacement")
L2_error = computeVector2DErrorL2(soln_func,
mesh_obj,
field_ptr,
self.numX,
self.numY,
time=self.time)
print "Displacement L2 error: ", L2_error
self.assert_(L2_error < 6.e-2)
field_ptr = field.getField("Displacement_z")
L2_error = computeVector3DErrorL2(z_soln_func,
mesh_obj,
field_ptr,
self.numX,
self.numY,
time=self.time)
print "Displacement_z L2 error: ", L2_error
self.assert_(L2_error < 1.1e-1)
def heatEqnEngine(self, soln_no, z_soln_no, test_solver):
soln_func = self.heat_solns[soln_no]["Solution"]
z_soln_func = self.heat_solns[z_soln_no]["Solution"]
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=StaticDriver(),
nonlinear_solver=test_solver,
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000)))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Temperature,
initializer=ConstScalarFieldInit(value=0.0))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Temperature_z,
initializer=ConstScalarFieldInit(value=0.0))
OOF.Mesh.Apply_Field_Initializers(
mesh='microstructure:skeleton:mesh')
OOF.Mesh.Solve(
mesh='microstructure:skeleton:mesh',
endtime=self.time)
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
mesh_obj = mesh.meshes["microstructure:skeleton:mesh"].getObject()
# first compute the numerical error in the computed temperature field
field_ptr = field.getField( "Temperature" )
L2_error = computeScalarErrorL2( soln_func, mesh_obj, field_ptr,
self.numX, self.numY, time=self.time )
print "Temperature L2 error: ", L2_error
self.assert_( L2_error < 1.e-2 )
# now compute the numerical error in the computed temperature_z field
field_ptr = field.getField( "Temperature_z" )
L2_error = computeScalarErrorL2( z_soln_func, mesh_obj, field_ptr,
self.numX, self.numY, time=self.time )
print "Temperture_z L2 error: ", L2_error
self.assert_( L2_error < 1.e-2 )
def elasticityEqnEngine(self, soln_no, z_soln_no, test_solver):
soln_func = self.elasticity_solns[soln_no]["Solution"]
z_soln_func = self.elasticity_z_solns[z_soln_no]["Solution"]
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=StaticDriver(),
nonlinear_solver=test_solver,
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000)))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Displacement,
initializer=ConstTwoVectorFieldInit(cx=0.0,cy=0.0))
OOF.Mesh.Apply_Field_Initializers(
mesh='microstructure:skeleton:mesh')
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Displacement_z,
initializer=ConstThreeVectorFieldInit(cx=0.0,cy=0.0,cz=0.0))
OOF.Mesh.Solve(
mesh='microstructure:skeleton:mesh',
endtime=self.time)
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
mesh_obj = mesh.meshes["microstructure:skeleton:mesh"].getObject()
field_ptr = field.getField( "Displacement" )
L2_error = computeVector2DErrorL2( soln_func, mesh_obj, field_ptr,
self.numX, self.numY, time=self.time )
print "Displacement L2 error: ", L2_error
self.assert_( L2_error < 6.e-2 )
field_ptr = field.getField( "Displacement_z" )
L2_error = computeVector3DErrorL2( z_soln_func, mesh_obj, field_ptr,
self.numX, self.numY, time=self.time )
print "Displacement_z L2 error: ", L2_error
self.assert_( L2_error < 1.1e-1 )
def flux_offset(self, mesh, element, flux, masterpos, time, smallsystem):
# Retrieve the plastic strain field and evaluate it at this
# masterposition.
ep_val = symmmatrix.SymmMatrix3()
ep = field.getField('Plastic')
efi = element.funcnode_iterator()
while not efi.end():
coef = efi.shapefunction(masterpos)
ep_output = ep.output(mesh, efi.funcnode())
ep_val += ep_output.valuePtr()*coef
efi += 1
# Now ep_val contains the plastic strain at this gausspoint.
# We can do the arithmetic. Note that this assumes the same
# gausspoint set from one iteration to the next, which will in
# general be a bad assumption.
modulus = self.elasticity.cijkl(mesh, element, masterpos)
ij = fieldindex.SymTensorIterator()
while (not ij.end()):
offset = 0.0
kl = ep_val.getIterator()
while (not kl.end()):
idx = kl.integer()
cijkl = modulus[ij.integer(),kl.integer()]
if idx<3:
offset += cijkl*ep_val[kl]
else:
offset += 2.0*cijkl*ep_val[kl]
kl.next()
smallsystem.add_offset_element(ij, offset)
ij.next()
def flux_offset(self, mesh, element, flux, masterpos, time, smallsystem):
# Retrieve the plastic strain field and evaluate it at this
# masterposition.
ep_val = symmmatrix.SymmMatrix3()
ep = field.getField('Plastic')
efi = element.funcnode_iterator()
while not efi.end():
coef = efi.shapefunction(masterpos)
ep_output = ep.output(mesh, efi.funcnode())
ep_val += ep_output.valuePtr() * coef
efi += 1
# Now ep_val contains the plastic strain at this gausspoint.
# We can do the arithmetic. Note that this assumes the same
# gausspoint set from one iteration to the next, which will in
# general be a bad assumption.
modulus = self.elasticity.cijkl(mesh, element, masterpos)
ij = fieldindex.SymTensorIterator()
while (not ij.end()):
offset = 0.0
kl = ep_val.getIterator()
while (not kl.end()):
idx = kl.integer()
cijkl = modulus[ij.integer(), kl.integer()]
if idx < 3:
offset += cijkl * ep_val[kl]
else:
offset += 2.0 * cijkl * ep_val[kl]
kl.next()
smallsystem.add_offset_element(ij, offset)
ij.next()
def update(self, indx):
debug.subthreadTest()
if indx is not None:
meshctxt = self.gfxtoolbox.getMeshContext()
meshctxt.begin_reading()
try:
femesh = meshctxt.getObject()
node = femesh.getNode(indx)
# node probably can't be None, but it doesn't hurt to
# check.
if node is not None:
# Find out which fields are defined at the node
fieldnames = node.fieldNames() # compound field names
nfieldrows = 0
listedfields = []
for fieldname in fieldnames:
fld = field.getField(fieldname)
nfieldrows += fld.ndof()
listedfields.append(fld)
if config.dimension() == 2:
zfld = fld.out_of_plane()
if node.hasField(zfld):
listedfields.append(zfld)
nfieldrows += zfld.ndof()
tfld = fld.time_derivative()
if node.hasField(tfld):
listedfields.append(tfld)
nfieldrows += tfld.ndof()
# Rebuild the table of field values, but only if the
# fields have changed.
if self.fieldslisted != listedfields:
mainthread.runBlock(self.rebuildFieldTable, (
nfieldrows,
listedfields,
))
# Get the field values for the table.
fieldvals = []
# The structure of this loop must match the loop
# in update_thread, below.
for fld in self.fieldslisted:
fcomp = fld.iterator(planarity.ALL_INDICES)
while not fcomp.end():
fieldvals.append(
fld.value(femesh, node, fcomp.integer()))
fcomp.next()
# end loop over field values
mainthread.runBlock(self.update_thread,
( ` node.index() `, node.classname(),
genericinfoGUI.posString(
node.position()), fieldvals))
return
# end if node is not None
finally:
meshctxt.end_reading()
# end if indx is not None
# No node
mainthread.runBlock(self.update_thread, ("", "", "", []))
def initialize_fields(self, mesh):
if config.dimension() == 2:
initializer = fieldinit.ConstTwoVectorFieldInit(cx=0.0,cy=0.0)
elif config.dimension() == 3:
initializer = fieldinit.ConstTwoVectorFieldInit(cx=0.0,cy=0.0,cz=0.0)
meshmenu.initField(self, self.meshname, field.getField('Displacement'),
initializer)
meshmenu.applyFieldInits(self, self.meshname)
def define_fields(self, meshctxt):
femesh = meshctxt.femesh()
subp = meshctxt.get_default_subproblem().getObject()
displacement = field.getField('Displacement')
subp.define_field(displacement)
subp.activate_field(displacement)
if config.dimension() == 2:
meshctxt.set_in_plane_field(displacement, True)
def define_fields(self, meshctxt):
femesh = meshctxt.femesh()
subp = meshctxt.get_default_subproblem().getObject()
displacement = field.getField('Displacement')
subp.define_field(displacement)
subp.activate_field(displacement)
if config.dimension() == 2:
meshctxt.set_in_plane_field(displacement, True)
def _displaced(self, mesh, elem, realpos=None, masterpos=None): # 2D only
masterpos = masterpos or elem.to_master(realpos)
realpos = realpos or elem.from_master(masterpos)
disp = elem.outputField(mesh, field.getField("Displacement"),
masterpos)
# 'disp' is an OutputValue wrapping a VectorOutputVal
vdisp = disp.valuePtr() # the underlying VectorOutputVal
return realpos + self.where.factor() * coord.Coord(*vdisp)
def initialize_fields(self, mesh):
if config.dimension() == 2:
initializer = fieldinit.ConstTwoVectorFieldInit(cx=0.0,cy=0.0)
elif config.dimension() == 3:
initializer = fieldinit.ConstTwoVectorFieldInit(cx=0.0,cy=0.0,cz=0.0)
meshmenu.initField(self, self.meshname, field.getField('Displacement'),
initializer)
meshmenu.applyFieldInits(self, self.meshname)
def elasticityEqnEngine(self, test_no, soln_no, test_solver, test_stepper,
tolerance):
soln_func = self.elasticity_solns[soln_no]["Solution"]
init_func = self.elasticity_solns[soln_no]["InitialValue"]
init_deriv_func = self.elasticity_solns[soln_no]["InitialTimeDeriv"]
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=UniformDriver(stepsize=self.timestep,
stepper=test_stepper),
nonlinear_solver=test_solver,
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000)))
OOF.Mesh.Set_Field_Initializer(mesh='microstructure:skeleton:mesh',
field=Displacement,
initializer=FuncThreeVectorFieldInit(
fx=init_func[0],
fy=init_func[1],
fz=init_func[2]))
OOF.Mesh.Set_Field_Initializer(mesh='microstructure:skeleton:mesh',
field=Displacement_t,
initializer=FuncThreeVectorFieldInit(
fx=init_deriv_func[0],
fy=init_deriv_func[1],
fz=init_deriv_func[2]))
OOF.Mesh.Apply_Field_Initializers_at_Time(
mesh='microstructure:skeleton:mesh', time=0.0)
OOF.Mesh.Solve(mesh='microstructure:skeleton:mesh', endtime=self.time)
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
mesh_obj = mesh.meshes["microstructure:skeleton:mesh"].getObject()
field_ptr = field.getField("Displacement")
L2_error = exact_solns.computeVector3DErrorL2(soln_func,
mesh_obj,
field_ptr,
self.numX,
self.numY,
self.numZ,
time=self.time)
print "L2 error: ", L2_error
self.assert_(L2_error < tolerance)
def elasticityEqnEngine(self,test_no,soln_no,test_solver,test_stepper):
soln_func = self.elasticity_solns[soln_no]["Solution"]
init_func = self.elasticity_solns[soln_no]["InitialValue"]
init_deriv_func = self.elasticity_solns[soln_no]["InitialTimeDeriv"]
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=UniformDriver(
stepsize=self.timestep,
stepper = test_stepper ),
nonlinear_solver = test_solver,
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000)))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Displacement,
initializer=FuncTwoVectorFieldInit(
fx = init_func[0],
fy = init_func[1] ))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Displacement_t,
initializer=FuncTwoVectorFieldInit(
fx = init_deriv_func[0],
fy = init_deriv_func[1] ))
OOF.Mesh.Apply_Field_Initializers_at_Time(
mesh='microstructure:skeleton:mesh',
time=0.0)
OOF.Mesh.Solve(
mesh='microstructure:skeleton:mesh',
endtime=self.time)
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
mesh_obj = mesh.meshes["microstructure:skeleton:mesh"].getObject()
field_ptr = field.getField( "Displacement" )
L2_error = computeVector2DErrorL2( soln_func, mesh_obj, field_ptr,
self.numX, self.numY, time=self.time)
print "L2 error: ", L2_error
self.assert_( L2_error < 1.e-1 )
def set_boundary_conditions(self, mesh):
## here, mesh is a Mesh (Who) object
displacement = field.getField('Displacement')
if config.dimension() == 2:
## left boundary
self.leftBoundaryCondition = \
bdycondition.DirichletBC(displacement,
'x',
equation.getEquation('Force_Balance'),
'x',
profile.ConstantProfile(0),
'left'
)
self.leftBoundaryCondition.add_to_mesh('left', mesh.path())
## right boundary
self.rightBoundaryCondition = \
bdycondition.DirichletBC(displacement,
'x',
equation.getEquation('Force_Balance'),
'x',
profile.ConstantProfile(0),
'right'
)
self.rightBoundaryCondition.add_to_mesh('right', mesh.path())
## top boundary
self.topBoundaryCondition = \
bdycondition.DirichletBC(displacement,
'y',
equation.getEquation('Force_Balance'),
'y',
profile.ConstantProfile(0),
'top'
)
self.topBoundaryCondition.add_to_mesh('top', mesh.path())
## bottom boundary
self.bottomBoundaryCondition = \
bdycondition.DirichletBC(displacement,
'y',
equation.getEquation('Force_Balance'),
'y',
profile.ConstantProfile(0),
'bottom'
)
self.bottomBoundaryCondition.add_to_mesh('bottom', mesh.path())
def set_boundary_conditions(self, mesh):
## here, mesh is a Mesh (Who) object
displacement = field.getField('Displacement')
if config.dimension() == 2:
## left boundary
self.leftBoundaryCondition = \
bdycondition.DirichletBC(displacement,
'x',
equation.getEquation('Force_Balance'),
'x',
profile.ConstantProfile(0),
'left'
)
self.leftBoundaryCondition.add_to_mesh('left', mesh.path())
## right boundary
self.rightBoundaryCondition = \
bdycondition.DirichletBC(displacement,
'x',
equation.getEquation('Force_Balance'),
'x',
profile.ConstantProfile(0),
'right'
)
self.rightBoundaryCondition.add_to_mesh('right', mesh.path())
## top boundary
self.topBoundaryCondition = \
bdycondition.DirichletBC(displacement,
'y',
equation.getEquation('Force_Balance'),
'y',
profile.ConstantProfile(0),
'top'
)
self.topBoundaryCondition.add_to_mesh('top', mesh.path())
## bottom boundary
self.bottomBoundaryCondition = \
bdycondition.DirichletBC(displacement,
'y',
equation.getEquation('Force_Balance'),
'y',
profile.ConstantProfile(0),
'bottom'
)
self.bottomBoundaryCondition.add_to_mesh('bottom', mesh.path())
def elasticityEqnEngine(self, test_no, soln_no):
soln_func = self.elasticity_solns[soln_no]["Solution"]
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=StaticDriver(),
nonlinear_solver=NoNonlinearSolver(),
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000)))
OOF.Mesh.Set_Field_Initializer(mesh='microstructure:skeleton:mesh',
field=Displacement,
initializer=ConstTwoVectorFieldInit(
cx=0.0, cy=0.0))
OOF.Mesh.Apply_Field_Initializers(mesh='microstructure:skeleton:mesh')
OOF.Mesh.Solve(mesh='microstructure:skeleton:mesh', endtime=self.time)
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
mesh_obj = mesh.meshes["microstructure:skeleton:mesh"].getObject()
field_ptr = field.getField("Displacement")
L2_error = exact_solns.computeVector2DErrorL2(soln_func,
mesh_obj,
field_ptr,
self.numX,
self.numY,
self.numZ,
time=self.time)
print "L2 error: ", L2_error
# We've checked that the L2_error is scaling correctly with
# the grid size, so this test is run with a coarse grid and a
# large tolerance to make it fast.
self.assert_(L2_error < 1.1e-1)
def heatEqnEngine(self, test_no, soln_no, test_solver, test_stepper):
soln_func = self.heat_solns[soln_no]["Solution"]
init_func = self.heat_solns[soln_no]["InitialValue"]
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=UniformDriver(stepsize=self.timestep,
stepper=test_stepper),
nonlinear_solver=test_solver,
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000)))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Temperature,
initializer=FuncScalarFieldInit(function=init_func))
OOF.Mesh.Apply_Field_Initializers_at_Time(
mesh='microstructure:skeleton:mesh', time=0.0)
OOF.Mesh.Solve(mesh='microstructure:skeleton:mesh', endtime=self.time)
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
mesh_obj = mesh.meshes["microstructure:skeleton:mesh"].getObject()
field_ptr = field.getField("Temperature")
L2_error = computeScalarErrorL2(soln_func,
mesh_obj,
field_ptr,
self.numX,
self.numY,
time=self.time)
print "L2 error: ", L2_error
self.assert_(L2_error < 1.e-1)
def update_node_positions(self, skeleton, mesh):
skeleton.incrementTimestamp()
## mesh is a Mesh Who object
femesh = mesh.getObject()
displacement = field.getField('Displacement')
# TODO OPT: this should probably be moved to C
for i in range(skeleton.nnodes()):
node = skeleton.getNode(i)
#Interface branch
## realnode = femesh.getNode(node.meshindex)
skelel = node.getElement(0)
realel = femesh.getElement(skelel.getIndex())
realnode = realel.getCornerNode(skelel.getNodeIndexIntoList(node))
dx = displacement.value(femesh, realnode, 0)
dy = displacement.value(femesh, realnode, 1)
if config.dimension() == 2:
skeleton.moveNodeBy(node, primitives.Point(dx, dy))
elif config.dimension() == 3:
dz = displacement.value(femesh, realnode, 2)
skeleton.moveNodeBy(node, (dx, dy, dz))
def update_node_positions(self, skeleton, mesh):
skeleton.timestamp.increment()
## mesh is a Mesh Who object
femesh = mesh.getObject()
displacement = field.getField('Displacement')
for node in skeleton.nodes:
#Interface branch
## realnode = femesh.getNode(node.meshindex)
#TODO: Do we have to update all the realmesh nodes
#that correspond to node?
skelel = node.neighborElements()[0]
realel = femesh.getElement(skelel.meshindex)
realnode = realel.getCornerNode(skelel.getNodeIndexIntoList(node))
dx = displacement.value(femesh, realnode, 0)
dy = displacement.value(femesh, realnode, 1)
if config.dimension() == 2:
skeleton.moveNodeBy(node, primitives.Point(dx, dy))
elif config.dimension() == 3:
dz = displacement.value(femesh, realnode, 2)
skeleton.moveNodeBy(node, primitives.Point(dx, dy, dz))
def update_node_positions(self, skeleton, mesh):
skeleton.timestamp.increment()
## mesh is a Mesh Who object
femesh = mesh.getObject()
displacement = field.getField('Displacement')
for node in skeleton.nodes:
#Interface branch
## realnode = femesh.getNode(node.meshindex)
#TODO: Do we have to update all the realmesh nodes
#that correspond to node?
skelel = node.neighborElements()[0]
realel = femesh.getElement(skelel.meshindex)
realnode = realel.getCornerNode(skelel.getNodeIndexIntoList(node))
dx = displacement.value(femesh, realnode, 0)
dy = displacement.value(femesh, realnode, 1)
if config.dimension() == 2:
skeleton.moveNodeBy(node, primitives.Point(dx, dy))
elif config.dimension() == 3:
dz = displacement.value(femesh, realnode, 2)
skeleton.moveNodeBy(node, primitives.Point(dx, dy, dz))
from ooflib.engine import problem
from ooflib.engine.IO import output
from ooflib.engine.IO import outputClones
from ooflib.engine.IO import propertyoutputreg
from types import *
import string
######################################
# Displacement
# Although Displacement is a Field, it's convenient to treat it as a
# Point so that it can be added to a position.
Displacement = field.getField("Displacement")
if config.dimension() == 2:
iter = Displacement.iterator(planarity.IN_PLANE)
elif config.dimension() == 3:
iter = Displacement.iterator(planarity.ALL_INDICES)
disp0 = iter.cloneIndex()
iter.next()
disp1 = iter.cloneIndex()
displacementFieldOutput = outputClones.FieldOutput.clone(
name="displacement field", params=dict(field=Displacement))
# displacementOutput produces the Displacement Field as a set of Points.
def _disp2point(mesh, elements, coords, field):
def Small(self):
OOF.Microstructure.New(
name='microstructure',
width=1.0, height=1.0,
width_in_pixels=10, height_in_pixels=10)
OOF.Material.New(
name='material', material_type='bulk')
# Reset the default parameter values for isotropic elasticity.
# This shouldn't be necessary if earlier tests clean up after
# themselves properly.
OOF.Property.Parametrize.Mechanical.Elasticity.Isotropic(
cijkl=IsotropicRank4TensorCij(c11=1.0,c12=0.5))
OOF.Material.Add_property(
name='material',
property='Mechanical:Elasticity:Isotropic')
OOF.Material.Assign(
material='material',
microstructure='microstructure',
pixels=all)
OOF.Skeleton.New(
name='skeleton',
microstructure='microstructure',
x_elements=1, y_elements=1,
skeleton_geometry=QuadSkeleton(
left_right_periodicity=False,top_bottom_periodicity=False))
OOF.Mesh.New(
name='mesh',
skeleton='microstructure:skeleton',
element_types=['D2_2', 'T3_3', 'Q4_4'])
OOF.Subproblem.Field.Define(
subproblem='microstructure:skeleton:mesh:default',
field=Displacement)
OOF.Subproblem.Field.Activate(
subproblem='microstructure:skeleton:mesh:default',
field=Displacement)
OOF.Subproblem.Equation.Activate(
subproblem='microstructure:skeleton:mesh:default',
equation=Force_Balance)
OOF.Subproblem.Equation.Activate(
subproblem='microstructure:skeleton:mesh:default',
equation=Plane_Stress)
OOF.Mesh.Boundary_Conditions.New(
name='bc',
mesh='microstructure:skeleton:mesh',
condition=DirichletBC(
field=Displacement,field_component='x',
equation=Force_Balance,eqn_component='x',
profile=ConstantProfile(value=0.0),
boundary='left'))
OOF.Mesh.Boundary_Conditions.New(
name='bc<2>',
mesh='microstructure:skeleton:mesh',
condition=DirichletBC(
field=Displacement,field_component='x',
equation=Force_Balance,eqn_component='x',
profile=ConstantProfile(value=0.1),
boundary='right'))
OOF.Mesh.Boundary_Conditions.New(
name='bc<3>',
mesh='microstructure:skeleton:mesh',
condition=DirichletBC(
field=Displacement,field_component='y',
equation=Force_Balance,eqn_component='y',
profile=ConstantProfile(value=0),
boundary='left'))
OOF.Mesh.Boundary_Conditions.New(
name='bc<4>',
mesh='microstructure:skeleton:mesh',
condition=DirichletBC(
field=Displacement,field_component='y',
equation=Force_Balance,eqn_component='y',
profile=ConstantProfile(value=0),
boundary='right'))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Displacement,
initializer=ConstTwoVectorFieldInit(cx=0.0,cy=0.0))
OOF.Mesh.Set_Field_Initializer(
mesh='microstructure:skeleton:mesh',
field=Displacement_z,
initializer=ConstThreeVectorFieldInit(cx=0.0,cy=0.0,cz=0.0))
OOF.Mesh.Apply_Field_Initializers_at_Time(
mesh='microstructure:skeleton:mesh',
time=0.0)
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=StaticDriver(),
nonlinear_solver=Newton(
relative_tolerance=1e-08,
absolute_tolerance=1.e-13,
maximum_iterations=200),
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,max_iterations=1000)))
OOF.Mesh.Solve(
mesh='microstructure:skeleton:mesh',
endtime=0.0)
# Check that the average out-of-plane stress is 0.0.
OOF.Mesh.Analyze.Average(
mesh='microstructure:skeleton:mesh',
time=latest,
data=getOutput('Flux:Value',flux=Stress),
domain=EntireMesh(),
sampling=ElementSampleSet(order=automatic),
destination=OutputStream(filename='test.dat', mode='w'))
self.assert_(file_utils.compare_last(
'test.dat',
(0.0, 0.075, 0.025, 0.0, 0.0, 0.0, 0.0)))
file_utils.remove('test.dat')
# Check that the out-of-plane displacement derivative at the
# nodes is correct. u_zz should be -0.05 and the other
# components should be 0.0.
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
msh = mesh.meshes["microstructure:skeleton:mesh"]
msh_obj = msh.getObject()
dispz = field.getField("Displacement_z")
for node in msh_obj.funcnode_iterator():
vals = [dispz.value(msh_obj, node, i) for i in range(3)]
self.assert_(vals[0] == 0.0 and vals[1] == 0 and
math.fabs(vals[2]+0.05) < 1.e-13)
def updateSomething(self, container):
debug.mainthreadTest()
node = container.object
femesh = container.context.femesh()
self.index.set_text(`node.index()`)
self.type.set_text(node.classname())
if config.dimension() == 2:
self.pos.set_text("(%s, %s)" %
(node.position().x, node.position().y))
elif config.dimension() == 3:
self.pos.set_text("(%s, %s, %s)" %
(node.position().x, node.position().y,
node.position().z))
fieldnames = node.fieldNames()
# Find out which fields are defined at the node
nfieldrows = 0
listedfields = []
for fieldname in fieldnames:
fld = field.getField(fieldname)
zfld = fld.out_of_plane()
tfld = fld.time_derivative()
nfieldrows += fld.ndof()
listedfields.append(fld)
if node.hasField(zfld):
listedfields.append(zfld)
nfieldrows += zfld.ndof()
if node.hasField(tfld):
listedfields.append(tfld)
nfieldrows += tfld.ndof()
# Rebuild the table of field values, but only if the fields
# have changed.
if self.fieldslisted != listedfields:
for entry in self.fieldvalEntries.values():
entry.destroy()
for widget in self.fieldvalWidgets:
widget.destroy()
self.fieldvalEntries.clear()
self.fieldvalWidgets.clear()
self.table.resize(rows=self.baserows + nfieldrows, columns=3)
fldrow = self.baserows # starting row for a field
for fld in listedfields:
sep = gtk.HSeparator()
self.fieldvalWidgets.add(sep)
self.table.attach(sep, 0,3, fldrow,fldrow+1,xoptions=gtk.FILL)
fldrow += 1
label = gtk.Label(fld.name())
label.set_alignment(1.0, 0.5)
self.fieldvalWidgets.add(label)
self.table.attach(label,
0,1, fldrow,fldrow+fld.ndof(),
xoptions=0)
fcomp = fld.iterator(planarity.ALL_INDICES)
while not fcomp.end():
row = fldrow + fcomp.integer()
label = gtk.Label(" " + fcomp.shortrepr()+"=")
self.fieldvalWidgets.add(label)
self.table.attach(label, 1,2, row,row+1, xoptions=gtk.FILL)
e = gtk.Entry()
e.set_size_request(10*guitop.top().charsize, -1)
e.set_editable(False)
self.fieldvalEntries[(fld, fcomp.integer())] = e
self.table.attach(e, 2,3, row,row+1,
xoptions=gtk.EXPAND|gtk.FILL)
fcomp.next()
fldrow += fld.ndof()
self.table.show_all()
self.fieldslisted = listedfields
# Fill in the field values in the table.
for fld in self.fieldslisted:
fcomp = fld.iterator(planarity.ALL_INDICES)
while not fcomp.end():
e = self.fieldvalEntries[(fld, fcomp.integer())]
e.set_text("%-13.6g"%fld.value(femesh, node, fcomp.integer()))
fcomp.next()
def updateSomething(self, container):
debug.mainthreadTest()
node = container.object
femesh = container.context.femesh()
self.index.set_text(`node.index()`)
self.type.set_text(node.classname())
if config.dimension() == 2:
self.pos.set_text("(%s, %s)" %
(node.position().x, node.position().y))
elif config.dimension() == 3:
self.pos.set_text("(%s, %s, %s)" %
(node.position().x, node.position().y,
node.position().z))
fieldnames = node.fieldNames()
# Find out which fields are defined at the node
nfieldrows = 0
listedfields = []
for fieldname in fieldnames:
fld = field.getField(fieldname)
zfld = fld.out_of_plane()
tfld = fld.time_derivative()
nfieldrows += fld.ndof()
listedfields.append(fld)
if node.hasField(zfld):
listedfields.append(zfld)
nfieldrows += zfld.ndof()
if node.hasField(tfld):
listedfields.append(tfld)
nfieldrows += tfld.ndof()
# Rebuild the table of field values, but only if the fields
# have changed.
if self.fieldslisted != listedfields:
for entry in self.fieldvalEntries.values():
entry.destroy()
for widget in self.fieldvalWidgets:
widget.destroy()
self.fieldvalEntries.clear()
self.fieldvalWidgets.clear()
self.table.resize(rows=self.baserows + nfieldrows, columns=3)
fldrow = self.baserows # starting row for a field
for fld in listedfields:
sep = gtk.HSeparator()
self.fieldvalWidgets.add(sep)
self.table.attach(sep, 0,3, fldrow,fldrow+1,xoptions=gtk.FILL)
fldrow += 1
label = gtk.Label(fld.name())
label.set_alignment(1.0, 0.5)
self.fieldvalWidgets.add(label)
self.table.attach(label,
0,1, fldrow,fldrow+fld.ndof(),
xoptions=0)
fcomp = fld.iterator(planarity.ALL_INDICES)
while not fcomp.end():
row = fldrow + fcomp.integer()
label = gtk.Label(" " + fcomp.shortrepr()+"=")
self.fieldvalWidgets.add(label)
self.table.attach(label, 1,2, row,row+1, xoptions=gtk.FILL)
e = gtk.Entry()
e.set_size_request(10*guitop.top().charsize, -1)
e.set_editable(False)
self.fieldvalEntries[(fld, fcomp.integer())] = e
self.table.attach(e, 2,3, row,row+1,
xoptions=gtk.EXPAND|gtk.FILL)
fcomp.next()
fldrow += fld.ndof()
self.table.show_all()
self.fieldslisted = listedfields
# Fill in the field values in the table.
for fld in self.fieldslisted:
fcomp = fld.iterator(planarity.ALL_INDICES)
while not fcomp.end():
e = self.fieldvalEntries[(fld, fcomp.integer())]
e.set_text("%-13.6g"%fld.value(femesh, node, fcomp.integer()))
fcomp.next()
ordering=2.0)
xyzfunc = outputClones.ScalarFunctionOutput.clone(
tip='Compute an arbitrary scalar function of x, y, and z.',
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/output/funcOutput.xml'))
output.defineOutput('XYZFunction:Scalar', xyzfunc, ordering=100)
xyzvecfunc = outputClones.VectorFunctionOutput.clone(
tip='Compute an arbitrary vector function of x, y and z.')
output.defineOutput('XYZFunction:Vector', xyzvecfunc, ordering=100)
###########
negElectricFieldOutput = outputClones.FieldDerivOutput.clone(
params=dict(field=field.getField("Voltage"))
)
electricFieldOutput = outputClones.NegateOutput.clone()
electricFieldOutput.connect("scalee", negElectricFieldOutput)
#output.defineOutput('E Field', electricFieldOutput)
eFieldCompOutput = outputClones.ComponentOutput.clone()
eFieldCompOutput.connect('field', electricFieldOutput)
#output.defineOutput('E Field:component', eFieldCompOutput)
## TODO 3.1: Uncomment the above two defineOutput lines, but only after
## fixing the problems with the MeshParamWidgets. The problem is that
## the widget for the component of the E field looks for a
## FieldWidget, and doesn't find one because the Field isn't a
## settable parameter.
######################
def Small(self):
OOF.Microstructure.New(name='microstructure',
width=1.0,
height=1.0,
width_in_pixels=10,
height_in_pixels=10)
OOF.Material.New(name='material', material_type='bulk')
# Reset the default parameter values for isotropic elasticity.
# This shouldn't be necessary if earlier tests clean up after
# themselves properly.
OOF.Property.Parametrize.Mechanical.Elasticity.Isotropic(
cijkl=IsotropicRank4TensorCij(c11=1.0, c12=0.5))
OOF.Material.Add_property(name='material',
property='Mechanical:Elasticity:Isotropic')
OOF.Material.Assign(material='material',
microstructure='microstructure',
pixels=all)
OOF.Skeleton.New(name='skeleton',
microstructure='microstructure',
x_elements=1,
y_elements=1,
skeleton_geometry=QuadSkeleton(
left_right_periodicity=False,
top_bottom_periodicity=False))
OOF.Mesh.New(name='mesh',
skeleton='microstructure:skeleton',
element_types=['D2_2', 'T3_3', 'Q4_4'])
OOF.Subproblem.Field.Define(
subproblem='microstructure:skeleton:mesh:default',
field=Displacement)
OOF.Subproblem.Field.Activate(
subproblem='microstructure:skeleton:mesh:default',
field=Displacement)
OOF.Subproblem.Equation.Activate(
subproblem='microstructure:skeleton:mesh:default',
equation=Force_Balance)
OOF.Subproblem.Equation.Activate(
subproblem='microstructure:skeleton:mesh:default',
equation=Plane_Stress)
OOF.Mesh.Boundary_Conditions.New(
name='bc',
mesh='microstructure:skeleton:mesh',
condition=DirichletBC(field=Displacement,
field_component='x',
equation=Force_Balance,
eqn_component='x',
profile=ConstantProfile(value=0.0),
boundary='left'))
OOF.Mesh.Boundary_Conditions.New(
name='bc<2>',
mesh='microstructure:skeleton:mesh',
condition=DirichletBC(field=Displacement,
field_component='x',
equation=Force_Balance,
eqn_component='x',
profile=ConstantProfile(value=0.1),
boundary='right'))
OOF.Mesh.Boundary_Conditions.New(name='bc<3>',
mesh='microstructure:skeleton:mesh',
condition=DirichletBC(
field=Displacement,
field_component='y',
equation=Force_Balance,
eqn_component='y',
profile=ConstantProfile(value=0),
boundary='left'))
OOF.Mesh.Boundary_Conditions.New(name='bc<4>',
mesh='microstructure:skeleton:mesh',
condition=DirichletBC(
field=Displacement,
field_component='y',
equation=Force_Balance,
eqn_component='y',
profile=ConstantProfile(value=0),
boundary='right'))
OOF.Mesh.Set_Field_Initializer(mesh='microstructure:skeleton:mesh',
field=Displacement,
initializer=ConstTwoVectorFieldInit(
cx=0.0, cy=0.0))
OOF.Mesh.Set_Field_Initializer(mesh='microstructure:skeleton:mesh',
field=Displacement_z,
initializer=ConstThreeVectorFieldInit(
cx=0.0, cy=0.0, cz=0.0))
OOF.Mesh.Apply_Field_Initializers_at_Time(
mesh='microstructure:skeleton:mesh', time=0.0)
OOF.Subproblem.Set_Solver(
subproblem='microstructure:skeleton:mesh:default',
solver_mode=AdvancedSolverMode(
time_stepper=StaticDriver(),
nonlinear_solver=Newton(relative_tolerance=1e-08,
absolute_tolerance=1.e-13,
maximum_iterations=200),
symmetric_solver=ConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000),
asymmetric_solver=BiConjugateGradient(
preconditioner=ILUPreconditioner(),
tolerance=1e-13,
max_iterations=1000)))
OOF.Mesh.Solve(mesh='microstructure:skeleton:mesh', endtime=0.0)
# Check that the average out-of-plane stress is 0.0.
OOF.Mesh.Analyze.Average(mesh='microstructure:skeleton:mesh',
time=latest,
data=getOutput('Flux:Value', flux=Stress),
domain=EntireMesh(),
sampling=ElementSampleSet(order=automatic),
destination=OutputStream(filename='test.dat',
mode='w'))
self.assert_(
file_utils.compare_last('test.dat',
(0.0, 0.075, 0.025, 0.0, 0.0, 0.0, 0.0)))
file_utils.remove('test.dat')
# Check that the out-of-plane displacement derivative at the
# nodes is correct. u_zz should be -0.05 and the other
# components should be 0.0.
from ooflib.engine import mesh
from ooflib.SWIG.engine import field
msh = mesh.meshes["microstructure:skeleton:mesh"]
msh_obj = msh.getObject()
dispz = field.getField("Displacement_z")
for node in msh_obj.funcnode_iterator():
vals = [dispz.value(msh_obj, node, i) for i in range(3)]
self.assert_(vals[0] == 0.0 and vals[1] == 0
and math.fabs(vals[2] + 0.05) < 1.e-13)
from ooflib.common.IO import xmlmenudump
from ooflib.engine import problem
from ooflib.engine.IO import output
from ooflib.engine.IO import outputClones
from types import *
import string
######################################
# Displacement
# Although Displacement is a Field, it's convenient to treat it as a
# Point so that it can be added to a position.
Displacement = field.getField("Displacement")
if config.dimension() == 2:
iter = Displacement.iterator(planarity.IN_PLANE)
elif config.dimension() == 3:
iter = Displacement.iterator(planarity.ALL_INDICES)
disp0 = iter.cloneIndex()
iter.next()
disp1 = iter.cloneIndex()
displacementFieldOutput = outputClones.FieldOutput.clone(
name="displacement field",
params=dict(field=Displacement))
# displacementOutput produces the Displacement Field as a set of Points.
def _disp2point(mesh, elements, coords, field):