Beispiel #1
0
    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()
Beispiel #2
0
    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()
Beispiel #3
0
    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)
Beispiel #4
0
    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 )
Beispiel #7
0
    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()
Beispiel #8
0
    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()
Beispiel #9
0
    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, ("", "", "", []))
Beispiel #10
0
 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)
Beispiel #11
0
 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)
Beispiel #12
0
 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)
Beispiel #13
0
 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)
Beispiel #14
0
 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 )
Beispiel #17
0
    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())
Beispiel #18
0
    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)
Beispiel #20
0
    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)
Beispiel #21
0
    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))
Beispiel #22
0
    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))
Beispiel #23
0
    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))
Beispiel #24
0
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)
Beispiel #26
0
    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()
Beispiel #27
0
    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()
Beispiel #28
0
                    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.

######################
Beispiel #29
0
    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)
Beispiel #30
0
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):