3D model problem: frame and core walls

[amia]

Dear Frank

I am struggling to get my model to work correctly in 3D and I was hoping you could provide me with some guidance as whatever I have tried has not been successful and I am running out of options.

I have created a 3D model which is composed of perimeter frames and 3 core walls (box shape and c-shaped walls):
1) The columns and beams are modeled using an elastic element with zero length springs on each end to represent the non-linear moment rotation response, the joints are also modeled using a zero length spring and rigid elements to represent the joint dimensions (i.e. scissor's model with rigid offset).
2) the walls are modeled using force-based beam-column elements with fiber section representing the wall cross-section (using Concrete04 and Steel02 material models). I have also used the MinMax command to put a strain limit on the tensile strain of steel to ensure that the steel fibers fail at a certain limit.

The building that I am looking at is extremely non-ductile; the walls achieve their cracking moment prior to reaching their yield moment and I believe this is why I'm struggling to get convergence (especially after the first crack that occurs in the walls). I have modeled the walls individually in 3D and I am getting the response that I expect, however when I put them all together with the perimeter frames the model does not run correctly after the first crack.

I have tried nearly all of the recommended methods (which have seemed to be appropriate including, reducing the step size, increasing the tolerance, changing the algorithm, test, and solver ) to solve convergence issues but I have had no luck. I can sometimes get the model to run after the first crack occurs (usually by reducing the tolerance) however, the results are not correct at all. I've included my convergence strategy below (at the moment I'm conducting pushover analysis but I also intend to move onto dynamic time history analyses).

Could you please let me know if it possible to run such a non-ductile building and if there is anything else that I can try. Any advice would be much appreciated.

Thank you
Anita

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# MONOTONIC PUSHOVER ANALYSIS

# 1st: Set Recorders
# -------------------------------------------------------------------------------------------------------------------- #
wipeAnalysis
loadConst
set Time1 [clock seconds]

set PATH Results/AnalysisPOXdir
file mkdir $PATH

logFile $PATH/LogFile.txt
recorder Node -xml $PATH/nodeReactionsX.out -load -node 1 2 3 4 5 6 10 11 15 16 20 21 25 26 27 28 29 30 54 64 74 -dof 1 reaction
recorder Node -xml $PATH/nodeReactionsZ.out -load -node 1 2 3 4 5 6 10 11 15 16 20 21 25 26 27 28 29 30 54 64 74 -dof 3 reaction

recorder Node -xml $PATH/DispCMX.out -time -load -node 900001 900002 900003 900004 900005 -dof 1 disp
recorder Node -xml $PATH/DispCMZ.out -time -load -node 900001 900002 900003 900004 900005 -dof 3 disp


foreach Dof {1 3} {
if {$Dof == 1} {
set DofTag X
}

if {$Dof == 3} {
set DofTag Z
}

foreach i {1010 1050 1260 1300} {
for {set level 0} {$level <= [expr $nStories-1]} {incr level 1} {
set nodeNo [expr $i+$level*1000]
recorder Node -xml $PATH/DispNode$DofTag$nodeNo.out -node $nodeNo -dof $Dof disp
}
}
} ; # Close foreach loop Dof

# 2nd: Set parameters for Pushover Analysis
# -------------------------------------------------------------------------------------------------------------------- #
puts " -------------------------"
puts " >>>> Running PO analysis... <<<< "
puts " -------------------------"

set nodeTag 900005
set dofTag 1
set Dmax [expr 500.0]; # maximum displacement of pushover


pattern Plain 2 Linear {
#load nd? Fx? Fy? Fz?
load 900001 0.11 0 0 0 0 0
load 900002 0.26 0 0 0 0 0
load 900003 0.53 0 0 0 0 0
load 900004 0.74 0 0 0 0 0
load 900005 1.0 0 0 0 0 0

foreach node {1019 1012 1016 1020 1029 1022 1024 1026 1028 1030 1039 1032 1034 1036 1038 1040 1049 1042 1044 1046 1048 1050 1059 1054 1058 1260 1269 1262 1266 1270 1279 1272 1274 1276 1278 1280 1289 1282 1284 1286 1288 1290 1299 1292 1294 1296 1298 1300 1309 1304 1308 1052 1056 1100 1109 1102 1104 1106 1108 1150 1159 1152 1154 1156 1158 1720 1728 1770 1776 1200 1209 1202 1204 1206 1208 1250 1259 1252 1254 1256 1258 1302 1306 1014 1018 1060 1069 1062 1064 1066 1068 1110 1119 1112 1114 1116 1118 1500 1508 1550 1556 1160 1169 1162 1164 1166 1168 1210 1219 1212 1214 1216 1218 1264 1268 150 153 154 155 164 172 173 174 177} {
load $node 0.11 0 0 0 0 0
}

foreach node {2019 2012 2016 2020 2029 2022 2024 2026 2028 2030 2039 2032 2034 2036 2038 2040 2049 2042 2044 2046 2048 2050 2059 2054 2058 2260 2269 2262 2266 2270 2279 2272 2274 2276 2278 2280 2289 2282 2284 2286 2288 2290 2299 2292 2294 2296 2298 2300 2309 2304 2308 2052 2056 2100 2109 2102 2104 2106 2108 2150 2159 2152 2154 2156 2158 2720 2728 2770 2776 2200 2209 2202 2204 2206 2208 2250 2259 2252 2254 2256 2258 2302 2306 2014 2018 2060 2069 2062 2064 2066 2068 2110 2119 2112 2114 2116 2118 2500 2508 2550 2556 2160 2169 2162 2164 2166 2168 2210 2219 2212 2214 2216 2218 2264 2268 250 253 254 255 264 272 273 274 277} {
load $node 0.26 0 0 0 0 0
}

foreach node {3019 3012 3016 3020 3029 3022 3024 3026 3028 3030 3039 3032 3034 3036 3038 3040 3049 3042 3044 3046 3048 3050 3059 3054 3058 3260 3269 3262 3266 3270 3279 3272 3274 3276 3278 3280 3289 3282 3284 3286 3288 3290 3299 3292 3294 3296 3298 3300 3309 3304 3308 3052 3056 3100 3109 3102 3104 3106 3108 3150 3159 3152 3154 3156 3158 3720 3728 3770 3776 3200 3209 3202 3204 3206 3208 3250 3259 3252 3254 3256 3258 3302 3306 3014 3018 3060 3069 3062 3064 3066 3068 3110 3119 3112 3114 3116 3118 3500 3508 3550 3556 3160 3169 3162 3164 3166 3168 3210 3219 3212 3214 3216 3218 3264 3268 350 353 354 355 364 372 373 374 377} {
load $node 0.53 0 0 0 0 0
}

foreach node {4019 4012 4016 4020 4029 4022 4024 4026 4028 4030 4039 4032 4034 4036 4038 4040 4049 4042 4044 4046 4048 4050 4059 4054 4058 4260 4269 4262 4266 4270 4279 4272 4274 4276 4278 4280 4289 4282 4284 4286 4288 4290 4299 4292 4294 4296 4298 4300 4309 4304 4308 4052 4056 4100 4109 4102 4104 4106 4108 4150 4159 4152 4154 4156 4158 4720 4728 4770 4776 4200 4209 4202 4204 4206 4208 4250 4259 4252 4254 4256 4258 4302 4306 4014 4018 4060 4069 4062 4064 4066 4068 4110 4119 4112 4114 4116 4118 4500 4508 4550 4556 4160 4169 4162 4164 4166 4168 4210 4219 4212 4214 4216 4218 4264 4268 450 453 454 455 464 472 473 474 477} {
load $node 0.74 0 0 0 0 0
}

foreach node {5019 5012 5016 5020 5029 5022 5024 5026 5028 5030 5039 5032 5034 5036 5038 5040 5049 5042 5044 5046 5048 5050 5059 5054 5058 5260 5269 5262 5266 5270 5279 5272 5274 5276 5278 5280 5289 5282 5284 5286 5288 5290 5299 5292 5294 5296 5298 5300 5309 5304 5308 5052 5056 5100 5109 5102 5104 5106 5108 5150 5159 5152 5154 5156 5158 5720 5728 5770 5776 5200 5209 5202 5204 5206 5208 5250 5259 5252 5254 5256 5258 5302 5306 5014 5018 5060 5069 5062 5064 5066 5068 5110 5119 5112 5114 5116 5118 5500 5508 5550 5556 5160 5169 5162 5164 5166 5168 5210 5219 5212 5214 5216 5218 5264 5268 550 553 554 555 564 572 573 574 577} {
load $node 1.0 0 0 0 0 0
}

}

## Initial parameters:
set tol 1.0e-12 ; # Usually 1.0-6 is sufficient
set iterations 500 ;
set Dincr 0.1 ; # initial increment step size
#set test EnergyIncr
set test NormDispIncr

## Parameters to try after non-convergence:
set newTol 1.0e-10 ; # Usually 1.0-6 is sufficient
set newIterations 1000 ;
set newDincr 0.01 ; # increment step size
set newDincr2 0.001 ; # increment step size

constraints Penalty 9.9e16 9.9e16 ;
#constraints Transformation
#constraints Lagrange
numberer RCM ;
system UmfPack -lvalueFact 60 ;
#system BandGeneral ;
test $test $tol $iterations ; # tolerance, max iterations, 2 print information when convergence has been achieved
#algorithm $algorithmCyclic ;
#algorithm ModifiedNewton -initial
algorithm KrylovNewton ; #-maxDim 55
#algorithm KrylovNewton -iterate initial -increment initial ; #-maxDim 55
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
analysis Static ;


# 3rd: Conduct Monotonic Pushover Analysis
# -------------------------------------------------------------------------------------------------------------------- #
set ok 0 ;
set controlDisp 0.0 ;

while {$controlDisp < $Dmax && $ok == 0} {

set ok [analyze 1] ; # this will return zero if no convergence problems were encountered
set controlDisp [nodeDisp $nodeTag $dofTag]

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Not converging, trying reduced step size..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr ;
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "Reduced step size was successful!"
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with reduced step size"
puts "Trying ModifiedNewton with initial stiffness..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr ;
algorithm ModifiedNewton -initial ;
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... Modified Newton worked"
}
}


if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with reduced step size"
puts "Trying Newton Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr ;
algorithm Newton
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... Newton Algorithm worked"
}
}

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with reduced step size"
puts "Trying Newton wit Line Search Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr ;
algorithm NewtonLineSearch
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... Newton Line Search Algorithm worked"
}
}

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with reduced step size"
puts "Trying Secant Newton Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr ;
algorithm SecantNewton
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... SecantNewton Algorithm worked"
}
}

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with reduced step size"
puts "Trying KrylovNewton Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr ;
algorithm KrylovNewton
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... KrylovNewton Algorithm worked"
}
}

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with reduced step size"
puts "Trying Broyden Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr ;
algorithm Broyden 12
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... Broyden Algorithm worked"
}
}

# ------------------------- Try second reduced step size ------------------------------- #

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "trying second reduced step size"
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr2;
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
puts "it tried the reduced step size, ok = $ok"
if {$ok == 0} {
puts "Reduced step size was successful!"
}
puts " ----------------------------------------------- "
} ; # if closed for reducing step size

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with 2nd reduced step size"
puts "Trying ModifiedNewton with initial stiffness..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr2;
algorithm ModifiedNewton -initial ;
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... Modified Newton worked"
}
}


if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with 2nd reduced step size"
puts "Trying Newton Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr2;
algorithm Newton
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... Newton Algorithm worked"
}
}

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with 2nd reduced step size"
puts "Trying Newton wit Line Search Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr2;
algorithm NewtonLineSearch
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... Newton Line Search Algorithm worked"
}
}

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with 2nd reduced step size"
puts "Trying Secant Newton Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr2;
algorithm SecantNewton
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... SecantNewton Algorithm worked"
}
}

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with 2nd reduced step size"
puts "Trying KrylovNewton Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr2;
algorithm KrylovNewton
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... KrylovNewton Algorithm worked"
}
}

if {$ok != 0} {
puts " ----------------------------------------------- "
puts "Trying different Algorthims with 2nd reduced step size"
puts "Trying Broyden Algorithm..."
puts "displacement at non-convergence: $controlDisp"
test $test $newTol $newIterations 1 ;
integrator DisplacementControl $nodeTag $dofTag $newDincr2;
algorithm Broyden 12
set ok [analyze 1]
test $test $tol $iterations 0
integrator DisplacementControl $nodeTag $dofTag $Dincr ;
if {$ok == 0} {
puts "... Broyden Algorithm worked"
}
}

} ; # End while loop

puts " ----------------------------------------------- "
if {$ok == 0} {
puts " >>>> Pushover analysis completed SUCCESSFULLY <<<< " ;
} else {
puts " >>>> Pushover analysis FAILED <<<< " ;
}

[selimgunay]

You can try displacement-based elements instead of the force-based elements for the walls. However, in this case you should use more than one element (probably 4 or 5) for each wall. Since the displacement-based elements do not require an iterative element formulation, you can improve convergence for your non-ductile building.

[amia]

Thank you very much for your reply.
I have tried displacement-based elements as well. I'm able to get the correct wall response when I'm modelling a single wall, however when I start modelling a system (multiple walls and perimeter frames), convergence becomes impossible! I have also tried just modelling the plastic hinge region with fiber-sections, and I have modelled the remaining portion of the wall with elastic elements, however I've still had no luck with this approach.

I have now moved onto using the lumped plasticity approach to model the wall response. However, now I am unsure what the best approach is to incorporate the effects of biaxial bending, especially during time history analysis. Any further advice or potential references on this matter would be much appreciated.

Thank you
Anita

[selimgunay]

There are two things you can do:

1. Try your analysis without the limits on the steel strain. This is for the fiber model.

2. Use a section analysis software and see how important the biaxial bending is for your wall section.

[amia]

Thank you, I think they are my best two options and I can change the backbone accordingly for the global system.