A convergence issue?

[anitaa]

Hi

I’m conducting time-history analysis for a 3D model of an 8-storey reinforced concrete building. I’ve been able to successfully run a couple of time-history analyses but for some records (with similar intensity) the analysis does not converge.

A very large divergence seems to occur and I get the following error message:
“numeric analysis returns 1 -- Umfpackgenlinsolver::solve”

This occurs after some time the analysis has been running. The records are not causing significant nonlinear behaviour. Would it be possible to get any guidance on what this means. Is it simply a convergence issue or is there an issue with the model?

I am using adaptive solution strategies to overcome non-convergence, however it does not seem to help in this case. Below is a sample of the solution strategy that I am using.

Any guidance would be much appreciated.




# ------------- 4th analysis command for Dynamic Time History analysis ------------- #
puts " -------------------------"
puts " >> Running Time History Analysis... << "
puts " -------------------------"
## Initial parameter:
set tol 1.0e-8; # Usually 1.0-6 is sufficient
set dTinitial [expr $dT/2] ; # initial time step
set iterations 20 ;
#set test NormDispIncr
set test EnergyIncr
set algorithmInitial Newton


## Parameters to try after non-convergence:
set newTol 1.0e-6 ; # Usually 1.0-6 is sufficient
set newTol2 1.0e-5 ; # Usually 1.0-6 is sufficient
set newTol3 1.0e-4 ; # Usually 1.0-6 is sufficient
set newTol4 1.0e-3 ; # Usually 1.0-6 is sufficient
set newTol5 1.0e-2 ;

set newIterations 40 ;
set newIterations2 50 ;
set newIterations3 100 ;
set newIterations4 1000 ;
set newIterations5 1000 ;

set dTnew1 [expr $dT/4] ; # time step if it fails
set dTnew2 [expr $dT/5] ;
set dTnew3 [expr $dT/10] ;
set dTnew4 [expr $dT/100] ;
set dTnew5 [expr $dT/1000] ;

test $test $tol $iterations ;
#test EnergyIncr $tol $iter <$pFlag> <$nType>
#test NormDispIncr $tol $iter <$pFlag> <$nType>
constraints Transformation
numberer RCM
#algorithm NewtonLineSearch
#algorithm KrylovNewton -maxDim 55
algorithm $algorithmInitial
#system BandGeneral
system UmfPack -lvalueFact 50 ;
#integrator Newmark 0.5 0.25 ; # integrator Newmark $gamma $beta
integrator HHT 0.95 ; # integrator HHT $alpha <$gamma $beta> ; The smaller the alpha the greater the numerical damping.
#analysis Transient
analysis VariableTransient ; # for when step size varies

set ok 0
set Nsteps [expr int($EqDuration/$dT)]
set tFinal [expr $Nsteps*$dT]
set tCurrent [getTime]


## ---------- Perform Transient analysis ------------ ##

## Can peform analysis without WHILE LOOP if no convergance issues.. ##
#set ok [analyze $Nsteps $dT]


set ok 0 ;
# Transient analysis with WHILE LOOP: ##
while {$ok==0 && $tCurrent < $tFinal} {

puts "Earthquake time: $tCurrent"

set ok [analyze 1 [expr $dTinitial]]
set tCurrent [getTime]
## if analysis fails try different things..

# FIRST try things that should work
if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying Newton Algorithm..."
test $test $newTol $newIterations 1
algorithm Newton
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... Newton Algorithm worked"
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying Newton Algorithm..."
test $test $newTol $newIterations 1
integrator Newmark 0.5 0.25;
algorithm Newton
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... Newton Algorithm worked"
test $test $tol $iterations 0
integrator HHT 0.95 ;
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size


if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying Newton Algorithm..."
test $test $newTol $newIterations 1
integrator Newmark 0.5 0.25;
algorithm NewtonLineSearch
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... Newton Algorithm worked"
test $test $tol $iterations 0
integrator HHT 0.95 ;
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size


# systematically try other things

if {$ok != 0} {
puts "Not converging, trying reduced step size..."
test $test $newTol $newIterations 1
algorithm KrylovNewton -maxDim 55
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "Reduced step with KrylovNewton size was successful!"
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying ModifiedNewton with initial stiffness..."
test $test $newTol $newIterations 1
algorithm ModifiedNewton -initial
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... Modified Newton worked"
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size


if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying Newton wit Line Search Algorithm..."
test $test $newTol $newIterations 1
algorithm NewtonLineSearch
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... Newton Line Search Algorithm worked"
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying Secant Newton Algorithm..."
test $test $newTol $newIterations 1
algorithm SecantNewton
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... SecantNewton Algorithm worked"
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

# ***
if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying Bisection ...";
algorithm NewtonLineSearch <-type Bisection>;
test $test $newTol $newIterations 1
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... SecantNewton Algorithm worked"
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying Secant ...";
algorithm NewtonLineSearch <-type Secant>;
test $test $newTol $newIterations 1
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... SecantNewton Algorithm worked"
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying RegulaFalsi ...";
algorithm NewtonLineSearch <-type RegulaFalsi>;
test $test $newTol $newIterations 1
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... SecantNewton Algorithm worked"
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying KrylovNewton ...";
algorithm KrylovNewton;
test $test $newTol $newIterations 1
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... KrylovNewton Algorithm worked"
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

# if {$ok != 0} {
# puts "Trying different Algorthims with reduced step size"
# puts "Trying BFGS ...";
# algorithm BFGS;
# test $test $newTol $newIterations 1
# set ok [analyze 1 $dTnew1]
# puts "it tried the reduced step size, ok = $ok"
# if {$ok == 0} {
# puts "... SecantNewton Algorithm worked"
# test $test $tol $iterations 0
# algorithm $algorithmInitial
# }
# puts " ----------------------------------------------- "
# } ; # if closed for reducing step size

# if {$ok != 0} {
# puts "Trying different Algorthims with reduced step size"
# puts "Trying Broyden ...";
# algorithm Broyden;
# test $test $newTol $newIterations 1
# set ok [analyze 1 $dTnew1]
# puts "it tried the reduced step size, ok = $ok"
# if {$ok == 0} {
# puts "... SecantNewton Algorithm worked"
# test $test $tol $iterations 0
# algorithm $algorithmInitial
# }
# puts " ----------------------------------------------- "
# } ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying NewtonLineSearch and Newmark Integrator";
integrator Newmark 0.5 0.25;
algorithm NewtonLineSearch
test $test $newTol $newIterations 1
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... NewtonLineSearch and Newmark Integrator"
integrator HHT 0.95 ;
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying OS ...";
test $test $newTol $newIterations 1
integrator AlphaOS 1.00;
algorithm Linear;
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... AlphaOS worked"
integrator HHT 0.95 ;
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying OSG ...";
integrator AlphaOSGeneralized 1.00;
algorithm Linear;
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "... AlphaOSGeneralized worked"
integrator HHT 0.95 ;
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size


# if {$ok != 0} {
# puts "Trying different Algorthims with reduced step size"
# puts "Trying Broyden Algorithm..."
# test $test $newTol $newIterations 1
# algorithm Broyden 12
# set ok [analyze 1 $dTnew1]
# puts "it tried the reduced step size, ok = $ok"
# if {$ok == 0} {
# puts "... Broyden Algorithm worked"
# test $test $tol $iterations 0
# algorithm $algorithmInitial
# }
# puts " ----------------------------------------------- "
# } ; # if closed for reducing step size

if {$ok != 0} {
puts "Trying different Algorthims with reduced step size"
puts "Trying Newton Algorithm..."
integrator HHT 0.80 ;
test $test $newTol $newIterations 1
algorithm Newton
set ok [analyze 1 $dTnew1]
puts "it tried the reduced step size and HHT=0.8, ok = $ok"
if {$ok == 0} {
puts "... Newton Algorithm worked with HHt=0.80"
integrator HHT 0.95 ;
test $test $tol $iterations 0
algorithm $algorithmInitial
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

# ---------------------------------------------------------------------------------------

[selimgunay]

It looks like this is because of the method that you are using to solve the linear system of equations, you can try system bandgeneral or umfpack without the additional parameter.

[anitaa]

Changing the system without the additional parameter helped with the beginning of the earthquake, but it eventually faced the same problem.
A very large divergence occurs and afterwards it does not go through the iterations of the different algorithms. I've included an example of when this occurs. At time 2.04 it was able to successfully converge (using AlphaOS) but afterwards the error "WARNING: numeric analysis returns 1 -- Umfpackgenlinsolver::solve" occurs and it is not able to conduct the iterations.


-----------------------------------------------
Trying different Algorthims with reduced step size
Trying OS ...
it tried the reduced step size, ok = 0
... AlphaOS worked
-----------------------------------------------
Earthquake time: 2.040000
WARNING: numeric analysis returns 1 -- Umfpackgenlinsolver::solve
WARNING NewtonRaphson::solveCurrentStep() -the LinearSysOfEqn failed in solve()
DirectIntegrationAnalysis::analyze() - the Algorithm failed at time 2.04362
OpenSees > analyze failed, returned: -3 error flag
Trying different Algorthims with reduced step size
Trying Newton Algorithm...
WARNING: numeric analysis returns 1 -- Umfpackgenlinsolver::solve
WARNING NewtonRaphson::solveCurrentStep() -the LinearSysOfEqn failed in solve()
DirectIntegrationAnalysis::analyze() - the Algorithm failed at time 2.04244
OpenSees > analyze failed, returned: -3 error flag
it tried the reduced step size, ok = -3
-----------------------------------------------
Trying different Algorthims with reduced step size
Trying Newton Algorithm...
WARNING: numeric analysis returns 1 -- Umfpackgenlinsolver::solve
WARNING NewtonRaphson::solveCurrentStep() -the LinearSysOfEqn failed in solve()
DirectIntegrationAnalysis::analyze() - the Algorithm failed at time 2.0425
OpenSees > analyze failed, returned: -3 error flag
it tried the reduced step size, ok = -3
-----------------------------------------------

[anitaa]

Also, here is the step before earthquake time 2.04 converges. You can see the very large divergence which had occurred. But this occurs through out the analysis towards the end before it eventually does not conduct the iterations of the different algorithms.

Any suggestions would be greatly appreciated.
Thank you

_________________________________________
Trying different Algorthims with reduced step size
Trying NewtonLineSearch and Newmark Integrator
CTestEnergyIncr::test() - iteration: 1 current EnergyIncr: 3.36815e+105 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 1 current EnergyIncr: 3.36815e+103 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 1 current EnergyIncr: 6.74656e+134 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 2 current EnergyIncr: 6.74656e+132 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 1 current EnergyIncr: 3.08007e+165 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 3 current EnergyIncr: 3.08007e+163 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 1 current EnergyIncr: 3.41624e+197 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 4 current EnergyIncr: 3.41624e+195 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 1 current EnergyIncr: 3.98686e+229 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 5 current EnergyIncr: 3.98686e+227 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 1 current EnergyIncr: 4.6775e+261 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 6 current EnergyIncr: 4.6775e+259 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 1 current EnergyIncr: 5.50923e+293 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 7 current EnergyIncr: 5.50923e+291 (max: 1e-06)
CTestEnergyIncr::test() - iteration: 1 current EnergyIncr: inf (max: 1e-06)
WARNING: CTestEnergyIncr::test() - failed to converge
after: 1 iterations
current EnergyIncr: inf (max: 1e-06) Norm deltaX: inf, Norm deltaR: inf
CTestEnergyIncr::test() - iteration: 8 current EnergyIncr: inf (max: 1e-06)
WARNING: CTestEnergyIncr::test() - failed to converge
after: 8 iterations
current EnergyIncr: inf (max: 1e-06) Norm deltaX: inf, Norm deltaR: inf
NewtonLineSearch::solveCurrentStep() -the ConvergenceTest object failed in test()
DirectIntegrationAnalysis::analyze() - the Algorithm failed at time 2.04125
OpenSees > analyze failed, returned: -3 error flag
it tried the reduced step size, ok = -3
-----------------------------------------------
Trying different Algorthims with reduced step size
Trying OS ...
it tried the reduced step size, ok = 0
... AlphaOS worked
-----------------------------------------------
Earthquake time: 2.040000

[gifariz]

I have similar problem here. I have a large number of nonlinear elements, most of them yields, thus is difficult to converge. I tried every convergence test methods and solution algorithms provided in OpenSees, also increasing the maximum iterations. So far I found test NormDispIncr with large tolerance (1e-2) and large max iterations (2000), and algorithm SecantNewton to be setting with highest probable of convergence. But it takes a lot more time due to max iteration increase, and probably less accurate with large tolerance. I am also still looking for better solution suggestion from people in this forum.

[anitaa]

My apologies for the multiple posts, but I am desperate to get my models to run due to strict deadlines!

Are there any useful references to help with selecting suitable algorithm methods, systems, etc...?
I have modelled the 8-storey building with displacement-based (DB) elements in the hinge region for walls and columns, zerolength spring for the beam hinges, and everything else elastic. From my understanding DB elements (compared to force-based) should have a good convergence.

Is the problem related to not setting up a correct convergence strategy or is the model simply too large/complex to consistently converge?

[gifariz]

Sorry I need to revise my statement in previous reply. Today I found out that test NormDispIncr with default tolerance 1e-12 and max iterations 100, and basic algorithm Newton has better performance for my case, almost always converge. I think enlarge the tolerance would rather create inaccuracy and more problems during analysis. My model is 40-story irregular building with thousands of nonlinear element, so I don't think your model is too large. Another suggestion, maybe find a way to use a more simple elements.

[anitaa]

That's great to hear, gives me hope!
May I ask does your model have walls and frames? And how long did it take to run a time-history analysis?
From my understanding, capturing the combined response of walls and frames becomes difficult (in terms of convergence) because of the difference in displaced shape..

I'd really like to learn how to write up a reliable convergence strategy. I need to conduct numerous time-history analyses, and it would be good to have a reliable and consistent approach. I have spent around a week now trying to get my model to converge (for a single record) and I am not sure if this is normal or if I am making a mistake somewhere..