def run( self , props , globdat ):
globdat.cycle += 1
globdat.lam = 1.0 * globdat.cycle
dofCount = len(globdat.dofs)
a_0 = np.copy(globdat.state) # minh
a = globdat.state
Da = globdat.Dstate
fhat = globdat.fhat
Da[:] = zeros( dofCount )
fint = zeros( dofCount )
fext = globdat.lam * fhat
print '================================='
print ' Load step %i' % globdat.cycle
print '================================='
print ' NR iter : L2-norm residual'
globdat.iiter = 0
K, fint = assembleTangentStiffness( props, globdat )
error = 1.
while error > self.tol:
globdat.iiter += 1
da = globdat.dofs.solve(K, fext - fint)
Da[:] += da[:]
a [:] += da[:]
K, fint = assembleTangentStiffness( props, globdat )
# note that the code is different from the one presented in the book, which
# is slightly shorter for the sake of clarity.
# In the case of a prescribed displacement, the external force is zero
# and hence its norm is zero. In that case, the norm of the residue is not
# divided by the norm of the external force.
# norm = globdat.dofs.norm(fext) # minh commented
Du_norm_tuso = np.linalg.norm(da) # minh
Du_norm_mauso = np.linalg.norm(a - a_0) # minh
error = Du_norm_tuso / Du_norm_mauso # minh
# minh commented this block of code
# if norm < 1.0e-16:
# error = globdat.dofs.norm(fext - fint)
# else:
# error = globdat.dofs.norm(fext - fint) / norm
print ' Iter', globdat.iiter, ':', error
if globdat.iiter == self.iterMax:
raise RuntimeError('Newton-Raphson iterations did not converge!')
# Converged
globdat.elements.commitHistory()
# print("------------- DU ---------------")
# print(Da)
Da[:] = zeros( len(globdat.dofs) )
globdat.fint = fint
if globdat.cycle == self.maxCycle or globdat.lam > self.maxLam:
globdat.active = False
def run(self, props, globdat):
globdat.cycle += 1
dofCount = len(globdat.dofs)
a = globdat.state
Da = globdat.Dstate
Da[:] = zeros(dofCount)
fint = zeros(dofCount)
fext = zeros(dofCount)
print('=================================')
print(' Load step %i' % globdat.cycle)
print('=================================')
print(' NR iter : L2-norm residual')
#fext = fext + Dfext
globdat.iiter = 0
K = assembleTangentStiffness(props, globdat)
error = 1.
while error > self.tol:
globdat.iiter += 1
da = globdat.dofs.solve(K, fext - fint)
Da[:] += da[:]
a[:] += da[:]
fint = assembleInternalForce(props, globdat)
K = assembleTangentStiffness(props, globdat)
error = globdat.dofs.norm(fext - fint)
print(' Iter', globdat.iiter, ':', error)
if globdat.iiter == self.iterMax:
raise RuntimeError(
'Newton-Raphson iterations did not converge!')
# Converged
elements.commitHistory()
if globdat.cycle == 10:
globdat.active = False
def run(self, props, global_data):
global_data.cycle += 1
K, fint = assembleTangentStiffness(props, global_data)
global_data.state = global_data.dofs.solve(K, global_data.fhat)
global_data.fint = assembleInternalForce(props, global_data)
global_data.elements.commitHistory()
global_data.active = False
def run( self , props , globdat ):
K0,fint = assembleTangentStiffness( props, globdat )
globdat.state = globdat.dofs.solve( K0 , globdat.fhat )
K,fint = assembleTangentStiffness( props, globdat )
eigenvals , eigenvecs = globdat.dofs.eigensolve( K0 , (K0-K) )
globdat.state = eigenvecs
globdat.elements.commitHistory()
globdat.active = False
self.printResults( eigenvals )
def run( self , props , globdat ):
globdat.cycle = 1
K,fint = assembleTangentStiffness( props, globdat )
M,Mlump = assembleMass( props , globdat )
globdat.vecs , globdat.vals = globdat.dofs.eigensolve( K, M )
globdat.active = False
def run( self , props , globdat ):
globdat.cycle += 1
K,fint = assembleTangentStiffness( props, globdat )
globdat.state = globdat.dofs.solve( K, globdat.fhat )
globdat.fint = assembleInternalForce( props, globdat )
globdat.elements.commitHistory()
globdat.active = False
def run(self, props, globdat):
K, fint = assembleTangentStiffness(props, globdat)
M, mlump = assembleMassMatrix(props, globdat)
eigenvals, eigenvecs = globdat.dofs.eigensolve(K, M, self.eigenCount)
globdat.state = eigenvecs
globdat.elements.commitHistory()
globdat.active = False
self.printResults(eigenvals)
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
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
def run( self , props , globdat ):
globdat.cycle += 1
globdat.lam = 1.0 * globdat.cycle
dofCount = len(globdat.dofs)
a = globdat.state
Da = globdat.Dstate
fhat = globdat.fhat
Da[:] = zeros( dofCount )
fint = zeros( dofCount )
fext = globdat.lam*fhat
print '================================='
print ' Load step %i' % globdat.cycle
print '================================='
print ' NR iter : L2-norm residual'
globdat.iiter = 0
K,fint = assembleTangentStiffness( props, globdat )
error = 1.
while error > self.tol:
globdat.iiter += 1
da = globdat.dofs.solve( K, fext-fint )
Da[:] += da[:]
a [:] += da[:]
K,fint = assembleTangentStiffness( props, globdat )
# note that the code is different from the one presented in the book, which
# is slightly shorter for the sake of clarity.
# In the case of a prescribed displacement, the external force is zero
# and hence its norm is zero. In that case, the norm of the residue is not
# divided by the norm of the external force.
norm = globdat.dofs.norm( fext )
if norm < 1.0e-16:
error = globdat.dofs.norm( fext-fint )
else:
error = globdat.dofs.norm( fext-fint ) / norm
print ' Iter', globdat.iiter, ':', error
if globdat.iiter == self.iterMax:
raise RuntimeError('Newton-Raphson iterations did not converge!')
# Converged
globdat.elements.commitHistory()
Da[:] = zeros( len(globdat.dofs) )
globdat.fint = fint
if globdat.cycle == self.maxCycle or globdat.lam > self.maxLam:
globdat.active = False
def run(self, props, globdat):
globdat.cycle += 1
a = globdat.state
Da = globdat.Dstate
fhat = globdat.fhat
self.printHeader(globdat.cycle)
error = 1.
globdat.iiter = 0
lam0 = globdat.lam
K, fint = assembleTangentStiffness(props, globdat)
while error > self.tol:
if self.method == 'force-controlled':
da = globdat.dofs.solve(K, globdat.lam * fhat - fint)
elif self.method == 'nrg-controlled':
h = 0.5 * lam0 * fhat
w = -0.5 * dot((a - Da), fhat)
g = 0.5 * dot((lam0 * Da - self.Dlam *
(a[:] - Da[:])), fhat) - globdat.dtau
d1 = globdat.dofs.solve(K, globdat.lam * fhat - fint)
d2 = globdat.dofs.solve(K, -1.0 * fhat)
denom = dot(h, d2) - w
da = d1 - (d2 * (dot(h, d1) + g)) / denom
dlam = -g - (dot(-1.0 * h, d1) - g * (1.0 + denom)) / denom
self.Dlam += dlam
globdat.lam += dlam
else:
raise RuntimeError('Method not known')
# Update displacements
Da[:] += da[:]
a[:] += da[:]
# Solve for new displacement vector, load factor
K, fint = assembleTangentStiffness(props, globdat)
# Check convergence
error = globdat.dofs.norm(globdat.lam * fhat -
fint) / globdat.dofs.norm(
globdat.lam * fhat)
# Increment the Newton-Raphson iteration counter
# and print error
globdat.iiter += 1
self.printIteration(globdat.iiter, error)
# If converged, calculate the amount of energy that has been dissipated in the \
# previous step.
dissnrg = 0.5 * dot(
(lam0 * Da - (globdat.lam - lam0) * (a - Da)), fhat)
self.printConverged(globdat.iiter, dissnrg)
Da[:] = zeros(len(globdat.dofs))
if self.method == 'force-controlled':
if dissnrg > self.switchEnergy:
print ' Switch to nrg diss. arc-length'
self.method = 'nrg-controlled'
globdat.dtau = 0.25 * self.switchEnergy
else:
globdat.lam += self.Dlam
else:
self.Dlam = 0.
globdat.dtau *= pow(0.5, 0.25 * (globdat.iiter - self.optiter))
if globdat.dtau > self.maxdTau:
globdat.dtau = self.maxdTau
globdat.elements.commitHistory()
globdat.fint = fint
if globdat.lam > self.maxLam or globdat.cycle > self.maxCycle:
globdat.active = False
# Step 2: #
# Compute the new external force vector #
#############################################
fext = fext + Dfext
#Initialize Newton-Raphson iteration parameters
error = 1.
iiter = 0
#############################################
# Step 3: #
# Compute the tangent stiffness matrix #
#############################################
K, fint = assembleTangentStiffness(props, globdat)
while error > tol:
###############################################
# Step 4+5: #
# Solve for da (while satisfying constraints) #
###############################################
da = dofs.solve(K, fext - fint)
###############################################
# Step 6: #
# Update Delta a #
###############################################
def run(self, props, globdat):
stat = globdat.solverStatus
stat.increaseStep()
a = globdat.state
Da = globdat.Dstate
fhat = globdat.fhat
self.printHeader(stat.cycle)
# Initialize Newton-Raphson iteration parameters
error = 1.
# Predictor
if stat.cycle == 1:
K, fint = assembleTangentStiffness(props, globdat)
Da1 = globdat.dofs.solve(K, globdat.lam * fhat)
Dlam1 = globdat.lam
else:
# Da1 = self.factor * self.Daprev
# Dlam1 = self.factor * self.Dlamprev
Da1 = globdat.factor * globdat.Daprev
Dlam1 = globdat.factor * globdat.Dlamprev
globdat.lam += Dlam1
a[:] += Da1[:]
Da[:] = Da1[:]
Dlam = Dlam1
K, fint = assembleTangentStiffness(props, globdat)
res = globdat.lam * fhat - fint
while error > self.tol:
stat.iiter += 1
d1 = globdat.dofs.solve(K, fhat)
d2 = globdat.dofs.solve(K, res)
ddlam = -dot(Da1, d2) / dot(Da1, d1)
dda = ddlam * d1 + d2
Dlam += ddlam
globdat.lam += ddlam
Da[:] += dda[:]
a[:] += dda[:]
K, fint = assembleTangentStiffness(props, globdat)
res = globdat.lam * fhat - fint
error = globdat.dofs.norm(res) / globdat.dofs.norm(
globdat.lam * fhat)
self.printIteration(stat.iiter, error)
if stat.iiter == self.iterMax:
raise RuntimeError(
'Newton-Raphson iterations did not converge!')
# Converged
self.printConverged(stat.iiter)
globdat.elements.commitHistory()
globdat.fint = fint
if not self.fixedStep:
globdat.factor = pow(0.5, 0.25 * (stat.iiter - self.optiter))
globdat.totalFactor *= globdat.factor
if globdat.totalFactor > self.maxFactor:
globdat.factor = 1.0
globdat.Daprev[:] = Da[:]
globdat.Dlamprev = Dlam
if globdat.lam > self.maxLam or stat.cycle > 1000 or a[
globdat.dofs.getForType(4, 'v')] > 5:
globdat.active = False
def run( self , props , globdat ):
globdat.cycle += 1
a = globdat.state
Da = globdat.Dstate
fhat = globdat.fhat
self.printHeader( globdat.cycle )
# Initialize Newton-Raphson iteration parameters
error = 1.
globdat.iiter = 0
# Predictor
if globdat.cycle == 1:
K,fint = assembleTangentStiffness( props, globdat )
Da1 = globdat.dofs.solve( K , globdat.lam*fhat )
Dlam1 = globdat.lam
else:
Da1 = self.factor * self.Daprev
Dlam1 = self.factor * self.Dlamprev
globdat.lam += Dlam1
a [:] += Da1[:]
Da[:] = Da1[:]
Dlam = Dlam1
K,fint = assembleTangentStiffness( props, globdat )
res = globdat.lam*fhat-fint
while error > self.tol:
globdat.iiter += 1
d1 = globdat.dofs.solve( K , fhat )
d2 = globdat.dofs.solve( K , res )
ddlam = -dot(Da1,d2)/dot(Da1,d1)
dda = ddlam*d1 + d2
Dlam += ddlam
globdat.lam += ddlam
Da[:] += dda[:]
a [:] += dda[:]
K,fint = assembleTangentStiffness( props, globdat )
res = globdat.lam*fhat-fint
error = globdat.dofs.norm( res ) / globdat.dofs.norm( globdat.lam*fhat )
self.printIteration( globdat.iiter,error)
if globdat.iiter == self.iterMax:
raise RuntimeError('Newton-Raphson iterations did not converge!')
# Converged
self.printConverged( globdat.iiter )
globdat.elements.commitHistory()
globdat.fint = fint
if not self.fixedStep:
self.factor = pow(0.5,0.25*(globdat.iiter-self.optiter))
self.totalFactor *= self.factor
if self.totalFactor > self.maxFactor:
self.factor = 1.0
self.Daprev[:] = Da[:]
self.Dlamprev = Dlam
if globdat.lam > self.maxLam or globdat.cycle > 1000 or a[globdat.dofs.getForType(4,'v')] > 5:
globdat.active=False
# Step 2: #
# Compute the new external force vector #
#############################################
fext = fext + Dfext
#Initialize Newton-Raphson iteration parameters
error = 1.
iiter = 0
#############################################
# Step 3: #
# Compute the tangent stiffness matrix #
#############################################
K,fint = assembleTangentStiffness( props, globdat )
while error > tol:
###############################################
# Step 4+5: #
# Solve for da (while satisfying constraints) #
###############################################
da = dofs.solve( K, fext-fint )
###############################################
# Step 6: #
# Update Delta a #
###############################################
def run( self , props , globdat ):
globdat.cycle += 1
a = globdat.state
Da = globdat.Dstate
fhat = globdat.fhat
self.printHeader( globdat.cycle )
error = 1.
globdat.iiter = 0
lam0 = globdat.lam
K,fint = assembleTangentStiffness( props, globdat )
while error > self.tol:
if self.method == 'force-controlled':
da = globdat.dofs.solve( K, globdat.lam*fhat-fint )
elif self.method == 'nrg-controlled':
h = 0.5 * lam0 * fhat
w = -0.5 * dot ( (a-Da) , fhat )
g = 0.5 * dot ( ( lam0 * Da - self.Dlam * ( a[:] - Da[:] ) ) , fhat ) - globdat.dtau
d1 = globdat.dofs.solve( K , globdat.lam*fhat - fint )
d2 = globdat.dofs.solve( K , -1.0*fhat )
denom = dot ( h , d2 ) - w
da = d1 - ( d2 * ( dot( h , d1 ) + g ) ) / denom
dlam = -g - ( dot( -1.0*h , d1 ) - g * ( 1.0 + denom ) ) / denom;
self.Dlam += dlam
globdat.lam += dlam
else:
raise RuntimeError('Method not known')
# Update displacements
Da[:] += da[:]
a [:] += da[:]
# Solve for new displacement vector, load factor
K,fint = assembleTangentStiffness( props, globdat )
# Check convergence
error = globdat.dofs.norm( globdat.lam*fhat-fint ) / globdat.dofs.norm( globdat.lam*fhat )
# Increment the Newton-Raphson iteration counter
# and print error
globdat.iiter += 1
self.printIteration( globdat.iiter , error )
# If converged, calculate the amount of energy that has been dissipated in the \
# previous step.
dissnrg = 0.5 * dot( ( lam0 * Da - (globdat.lam-lam0) * ( a - Da ) ),fhat )
self.printConverged( globdat.iiter , dissnrg )
Da[:] = zeros( len(globdat.dofs) )
if self.method == 'force-controlled':
if dissnrg > self.switchEnergy:
print ' Switch to nrg diss. arc-length'
self.method = 'nrg-controlled'
globdat.dtau = 0.25*self.switchEnergy
else:
globdat.lam += self.Dlam
else:
self.Dlam = 0.
globdat.dtau *= pow(0.5,0.25*(globdat.iiter-self.optiter))
if globdat.dtau > self.maxdTau:
globdat.dtau = self.maxdTau
globdat.elements.commitHistory()
globdat.fint = fint
if globdat.lam > self.maxLam or globdat.cycle > self.maxCycle:
globdat.active=False
def run( self , props , globdat ):
stat = globdat.solverStatus
stat.increaseStep()
dofCount = len(globdat.dofs)
a = globdat.state
Da = globdat.Dstate
Da[:] = zeros( dofCount )
fint = zeros( dofCount )
logger.info("Nonlinear solver ............")
logger.info(" =============================================")
logger.info(" Load step %i"%globdat.solverStatus.cycle)
logger.info(" =============================================")
logger.info(' Newton-Raphson : L2-norm residual')
self.setLoadAndConstraints( globdat )
K,fint = assembleTangentStiffness( props, globdat )
error = 1.
self.setLoadAndConstraints( globdat )
fext = assembleExternalForce ( props, globdat )
while error > self.tol:
stat.iiter += 1
da = globdat.dofs.solve( K, fext - fint )
Da[:] += da[:]
a [:] += da[:]
K,fint = assembleTangentStiffness( props, globdat )
# note that the code is different from the one presented in the book, which
# is slightly shorter for the sake of clarity.
# In the case of a prescribed displacement, the external force is zero
# and hence its norm is zero. In that case, the norm of the residue is not
# divided by the norm of the external force.
norm = globdat.dofs.norm( fext )
if norm < 1.0e-16:
error = globdat.dofs.norm( fext-fint )
else:
error = globdat.dofs.norm( fext-fint ) / norm
logger.info(' Iteration %4i : %6.4e'%(stat.iiter,error) )
globdat.dofs.setConstrainFactor( 0.0 )
if stat.iiter == self.iterMax:
raise RuntimeError('Newton-Raphson iterations did not converge!')
# Converged
globdat.elements.commitHistory()
Da[:] = zeros( len(globdat.dofs) )
globdat.fint = fint
if stat.cycle == self.maxCycle or globdat.lam > self.maxLam:
globdat.active = False
def run( self , props , globdat ):
globdat.cycle += 1
dofCount = len(globdat.dofs)
a = globdat.state
Da = globdat.Dstate
Da[:] = zeros( dofCount )
fint = zeros( dofCount )
fext = zeros( dofCount )
print '================================='
print ' Load step %i' % globdat.cycle
print '================================='
print ' NR iter : L2-norm residual'
#fext = fext + Dfext
globdat.iiter = 0
K = assembleTangentStiffness( props, globdat )
error = 1.
while error > self.tol:
globdat.iiter += 1
da = globdat.dofs.solve( K, fext-fint )
Da[:] += da[:]
a [:] += da[:]
fint = assembleInternalForce ( props, globdat )
K = assembleTangentStiffness( props, globdat )
error = globdat.dofs.norm( fext-fint )
print ' Iter', globdat.iiter, ':', error
if globdat.iiter == self.iterMax:
raise RuntimeError('Newton-Raphson iterations did not converge!')
# Converged
elements.commitHistory()
if globdat.cycle == 10:
globdat.active = False
# Solve for new displacement vector, load factor
if self.method == 'force-controlled':
da = dofs.solve( K, lam*fhat-fint )
elif self.method == 'nrg':
h = 0.5 * lam0 * fhat
w = -0.5 * dot ( (a-Da) , fhat )
g = 0.5 * dot ( ( lam0 * Da - Dlam * ( a[:] - Da[:] ) ) , fhat ) - dtau
d1 = dofs.solve( K , lam*fhat - fint )
d2 = dofs.solve( K , -1.0*fhat )
denom = dot ( h , d2 ) - w
da = d1 - ( d2 * ( dot( h , d1 ) + g ) ) / denom
dlam = -g - ( dot( -1.0*h , d1 ) - g * ( 1.0 + denom ) ) / denom;
Dlam += dlam
lam += dlam
else:
raise RuntimeError('Method not known')
# Update displacements
Da[:] += da[:]
a [:] += da[:]
# Solve for new displacement vector, load factor
K = assembleTangentStiffness( props, globdat )
fint = assembleInternalForce( props, globdat )
# Check convergence
error = globdat.dofs.norm( lam*fhat-fint ) / globdat.dofs.norm( lam*fhat )
# Increment the Newton-Raphson iteration counter
# and print error
globdat.iiter += 1
print ' Iter %5i : %4.2e ' %(iiter,error)
if globdat.iiter == iterMax:
plotCurve( output )
raise RuntimeError('Newton-Raphson iterations did not converge!')
# If converged, calculate the amount of energy that has been dissipated in the \
# previous step.
print '---------------------------------'
print ' C O N V E R G E D'
if method == 'force-controlled':
print ' Diss. nrg : %1.3e ' %dissnrg
Da[:] = zeros( len(dofs) )
lam0 = lam
if method == 'force-controlled':
if dissnrg > switchnrg:
print ' Switch to nrg diss. arc-length'
self.method = 'nrg'
Dlam = 0.;
dtau = 0.25*switchnrg
else:
lam += Dlam
else:
Dlam = 0.;
dtau *= pow(0.5,0.25*(iiter-5))
if dtau > maxnrg:
dtau = maxnrg
globdat.elements.commitHistory()
globdat.dissnrg = 0.5 * dot( ( lam0 * Da - (lam-lam0) * ( a - Da ) ) , fhat )
def run( self , props , globdat ):
globdat.cycle += 1
dofCount = len(globdat.dofs)
a = globdat.state
Da = globdat.Dstate
Da[:] = zeros( dofCount )
fint = zeros( dofCount )
fext = zeros( dofCount )
print '================================='
print ' Load step %i' % globdat.cycle
print '================================='
print ' NR iter : L2-norm residual'
#fext = fext + Dfext
globdat.iiter = 0
K = assembleTangentStiffness( props, globdat )
error = 1.
while error > self.tol:
globdat.iiter += 1
da = globdat.dofs.solve( K, fext-fint )
Da[:] += da[:]
a [:] += da[:]
fint = assembleInternalForce ( props, globdat )
K = assembleTangentStiffness( props, globdat )
error = globdat.dofs.norm( fext-fint )
print ' Iter', globdat.iiter, ':', error
if globdat.iiter == self.iterMax:
raise RuntimeError('Newton-Raphson iterations did not converge!')
# Converged
elements.commitHistory()
if globdat.cycle == 10:
globdat.active = False
# Solve for new displacement vector, load factor
if self.method == 'force-controlled':
da = dofs.solve( K, lam*fhat-fint )
elif self.method == 'nrg':
h = 0.5 * lam0 * fhat
w = -0.5 * dot ( (a-Da) , fhat )
g = 0.5 * dot ( ( lam0 * Da - Dlam * ( a[:] - Da[:] ) ) , fhat ) - dtau
d1 = dofs.solve( K , lam*fhat - fint )
d2 = dofs.solve( K , -1.0*fhat )
denom = dot ( h , d2 ) - w
da = d1 - ( d2 * ( dot( h , d1 ) + g ) ) / denom
dlam = -g - ( dot( -1.0*h , d1 ) - g * ( 1.0 + denom ) ) / denom;
Dlam += dlam
lam += dlam
else:
raise RuntimeError('Method not known')
# Update displacements
Da[:] += da[:]
a [:] += da[:]
# Solve for new displacement vector, load factor
K = assembleTangentStiffness( props, globdat )
fint = assembleInternalForce( props, globdat )
# Check convergence
error = globdat.dofs.norm( lam*fhat-fint ) / globdat.dofs.norm( lam*fhat )
# Increment the Newton-Raphson iteration counter
# and print error
globdat.iiter += 1
print ' Iter %5i : %4.2e ' %(iiter,error)
if globdat.iiter == iterMax:
plotCurve( output )
raise RuntimeError('Newton-Raphson iterations did not converge!')
# If converged, calculate the amount of energy that has been dissipated in the \
# previous step.
print '---------------------------------'
print ' C O N V E R G E D'
if method == 'force-controlled':
print ' Diss. nrg : %1.3e ' %dissnrg
Da[:] = zeros( len(dofs) )
lam0 = lam
if method == 'force-controlled':
if dissnrg > switchnrg:
print ' Switch to nrg diss. arc-length'
self.method = 'nrg'
Dlam = 0.;
dtau = 0.25*switchnrg
else:
lam += Dlam
else:
Dlam = 0.;
dtau *= pow(0.5,0.25*(iiter-5))
if dtau > maxnrg:
dtau = maxnrg
globdat.elements.commitHistory()
globdat.dissnrg = 0.5 * dot( ( lam0 * Da - (lam-lam0) * ( a - Da ) ) , fhat )
def run(self, props, globdat):
globdat.cycle += 1
globdat.lam = 1.0 * globdat.cycle
dofCount = len(globdat.dofs)
a = globdat.state
Da = globdat.Dstate
fhat = globdat.fhat
Da[:] = zeros(dofCount)
fint = zeros(dofCount)
fext = globdat.lam * fhat
print('=================================')
print(' Load step %i' % globdat.cycle)
print('=================================')
print(' NR iter : L2-norm residual')
globdat.iiter = 0
K, fint = assembleTangentStiffness(props, globdat)
error = 1.
globdat.dofs.setConstrainFactor(1.0)
while error > self.tol:
globdat.iiter += 1
da = globdat.dofs.solve(K, fext - fint)
Da[:] += da[:]
a[:] += da[:]
K, fint = assembleTangentStiffness(props, globdat)
# note that the code is different from the one presented in the book, which
# is slightly shorter for the sake of clarity.
# In the case of a prescribed displacement, the external force is zero
# and hence its norm is zero. In that case, the norm of the residue is not
# divided by the norm of the external force.
norm = globdat.dofs.norm(fext)
if norm < 1.0e-16:
error = globdat.dofs.norm(fext - fint)
else:
error = globdat.dofs.norm(fext - fint) / norm
print(' Iter', globdat.iiter, ':', error)
globdat.dofs.setConstrainFactor(0.0)
if globdat.iiter == self.iterMax:
raise RuntimeError(
'Newton-Raphson iterations did not converge!')
# Converged
globdat.elements.commitHistory()
Da[:] = zeros(len(globdat.dofs))
globdat.fint = fint
if globdat.cycle == self.maxCycle or globdat.lam > self.maxLam:
globdat.active = False
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
def run( self , props , globdat ):
stat = globdat.solverStatus
stat.increaseStep()
a = globdat.state
Da = globdat.Dstate
#fhat = globdat.fhat
fhat = assembleExternalForce( props, globdat )
self.printHeader( stat.cycle )
error = 1.
lam0 = globdat.lam
if stat.cycle == 1:
stat.dtime = max( globdat.lam * self.dtime , 0.0001 )
K,fint = assembleTangentStiffness( props, globdat )
Da1 = globdat.dofs.solve( K , globdat.lam*fhat )
Dlam = globdat.lam
else:
Da1 = self.factor * self.Daprev
Dlam = self.factor * self.Dlamprev
globdat.lam += Dlam
a [:] += Da1[:]
Da[:] = Da1[:]
stat.dtime = max( Dlam * self.dtime , 0.0001 )
K,fint = assembleTangentStiffness( props, globdat )
dgda,diss = assembleDissipation( props , globdat )
res = globdat.lam*fhat-fint
while error > self.tol:
stat.iiter += 1
d1 = globdat.dofs.solve( K , fhat )
d2 = globdat.dofs.solve( K , res )
ddlamR = -dot(Da1,d2)/dot(Da1,d1)
ddaR = ddlamR*d1 + d2
if self.method == 'nrg-controlled':
if self.disstype == "Classic":
h = 0.5 * lam0 * fhat # wordt dgda
w = -0.5 * dot ( (a-Da) , fhat ) # wordt 0.0
g = 0.5 * dot ( ( lam0 * Da - Dlam * ( a[:] - Da[:] ) ) , fhat ) - globdat.dtau
elif self.disstype == "Local":
h = dgda
w = 0.0
g = diss - globdat.dtau
else:
raise RuntimeError('Not implemented!')
denom = - dot ( h , d1 ) - w
ddaN = d2 - ( -d1 * ( dot( h , d2 ) + g ) ) / denom
ddlamN = -g - ( dot( -1.0*h , d2 ) - g * ( 1.0 + denom ) ) / denom;
if self.method == 'force-controlled':
Dlam += ddlamR
globdat.lam += ddlamR
Da[:] += ddaR[:]
a [:] += ddaR[:]
elif self.method == 'nrg-controlled':
if stat.iiter == 1 and globdat.dofs.norm(Da+ddaN)/globdat.dofs.norm(Da1) > self.beta:
self.method = 'force-controlled'
Dlam += ddlamR
globdat.lam += ddlamR
Da[:] += ddaR[:]
a [:] += ddaR[:]
else:
Dlam += ddlamN
globdat.lam += ddlamN
Da[:] += ddaN[:]
a [:] += ddaN[:]
# Solve for new displacement vector, load factor
stat.dtime = max( Dlam * self.dtime , 0.0001 )
K,fint = assembleTangentStiffness( props, globdat )
dgda,diss = assembleDissipation( props , globdat )
res = globdat.lam*fhat-fint
# Check convergence
error = globdat.dofs.norm( res ) / globdat.dofs.norm( globdat.lam*fhat )
self.printIteration( stat.iiter , error )
# If converged, calculate the amount of energy that has been dissipated in the \
# previous step.
if self.disstype == "Classic":
diss = 0.5 * dot( ( lam0 * Da - Dlam * ( a[:] - Da[:] ) ),fhat )
self.printConverged( stat.iiter , diss )
self.Daprev = Da
self.Dlamprev = Dlam
self.factor = pow(0.5,0.25*(stat.iiter-self.optiter))
globdat.dtau = diss
if self.method == 'force-controlled':
if diss > self.switchEnergy:
print(' Switch to nrg diss. arc-length')
self.method = 'nrg-controlled'
globdat.dtau = diss
self.factor = 1.0
else:
globdat.dtau *= self.factor
if globdat.dtau > self.maxdTau:
self.factor *= self.maxdTau / globdat.dtau
globdat.dtau = self.maxdTau
globdat.elements.commitHistory()
globdat.fint = fint
if globdat.lam > self.maxLam or stat.cycle > self.maxCycle:
globdat.active=False
