예제 #1
0
    def run(self, props, globdat):

        globdat.cycle += 1

        K, fint = assembleTangentStiffness(props, globdat)

        state0 = globdat.state

        globdat.state = globdat.dofs.solve(K, globdat.fhat)

        globdat.Dstate = globdat.state - state0

        globdat.fint = assembleInternalForce(props, globdat)

        commit(props, globdat)

        globdat.elements.commitHistory()

        globdat.active = False
예제 #2
0
    def run(self, props, globdat):

        globdat.solverStatus.increaseStep()

        K, fint = assembleTangentStiffness(props, globdat)
        fext = assembleExternalForce(props, globdat)

        state0 = globdat.state

        globdat.state = globdat.dofs.solve(K, fext)

        globdat.Dstate = globdat.state - state0

        globdat.fint = assembleInternalForce(props, globdat)

        commit(props, globdat)

        globdat.elements.commitHistory()

        globdat.active = False
예제 #3
0
    def run(self, props, globdat):

        stat = globdat.solverStatus

        self.stat = stat

        stat.increaseStep()

        #fext  = zeros( len(globdat.dofs) )

        logger.info("Staggered solver ............")
        logger.info("    =============================================")
        logger.info("    Load step %i" % globdat.solverStatus.cycle)
        logger.info("    =============================================")

        for solver in self.solvers:

            stat.iiter = 0
            error = 1.0

            K, fint = assembleTangentStiffness(props, globdat)
            fext = assembleExternalForce(props, globdat)

            self.setLoadAndConstraints(solver.cons)

            da = globdat.dofs.solve(K, fext - fint, solver.cons)

            globdat.state += da

            logger.info('    Solver           : %s' % solver.name)

            if solver.type == "Nonlinear":

                if solver.name == "dummy":
                    norm = 1.0
                else:
                    norm = globdat.dofs.norm(fext - fint, solver.cons)

                logger.info('    Newton-Raphson   : L2-norm residual')

                while error > self.tol:

                    stat.iiter += 1

                    K, fint = assembleTangentStiffness(props, globdat)

                    solver.cons.setConstrainFactor(0.0)

                    da = globdat.dofs.solve(K, fext - fint, solver.cons)

                    globdat.state += da

                    if solver.name == "dummy":
                        error = 1.0e-8
                    elif norm < 1.0e16:
                        error = globdat.dofs.norm(fext - fint, solver.cons)
                    else:
                        error = globdat.dofs.norm(fext - fint) / norm

                    logger.info('    Iteration %4i   : %6.4e' %
                                (stat.iiter, error))

                    if stat.iiter == self.iterMax:
                        raise RuntimeError(
                            'Newton-Raphson iterations did not converge!')

        # Combine results and calculate stresses

        globdat.fint = assembleInternalForce(props, globdat)

        commit(props, globdat)

        globdat.elements.commitHistory()

        if stat.cycle == self.maxCycle:  # or globdat.lam > self.maxLam:
            globdat.active = False