Convergence Problem With NonlinearBeamColumn Element

[mkumar07]

Hi Silvia,

I am performing nonlinear time history analysis of 5 storey steel frame, to different level of intensities (IDA).

I developed the model initially using displacement based elements and works perfect as I compared the results with Seismostruct. When I changed the elements to Nonlinear beam column elements model works Ok within elastic range but as I change the intensity to observed inelastic behaviour it fails to converge and following message appears.

ForceBeamColumn2d::update - failed to get compatible element forces & deformations for element: 1301(dW: <<1.11244e+010).

I am not applying any gravity loads, just giving seismic masses at beam column joints, the mode time period for both element types is same and also within elastic range nonlinear beam column is working fine.

I cannot find the solution of the problem. If you could help me Plzzzzz. Following is my File.


#********************----------------**************************
# Model of 5 Storey Steel Frame Designed to EC8 Frame ID 1
# Designed by Miguel et al, Modeled by Kumar, M., Sept 15 2008

#************ BASIC STEPS ******************
#************ SET UP ******************

wipe; # clear memory of all past model definitions
model BasicBuilder -ndm 2 -ndf 3; # Define the model builder, ndm=#dimension, ndf=#dofs

#************ SET DIRECTORIES ****************

set dataDir Data; # set up name of data directory (can remove this)
file mkdir $dataDir; # create data directory

set GMdir "../GMfiles/"; # ground-motion file directory

#**************INCLUDE TCL FILES TO BE CALLED LATER*******************

#source LibUnits.tcl; # define units
source Units_(mks).tcl; # Units definition
source DisplayPlane.tcl; # procedure for displaying a plane in model
source DisplayModel2D.tcl; # procedure for displaying 2D perspective of model
source Wsection.tcl; # procedure to define fiber W section

# define GEOMETRY -------------------------------------------------------------
# define structure-geometry paramters
set LBay [expr 6*$m]; # Bay Length
set HBSCol [expr 4.5*$m]; # Length of Bottom Storey Columns
set HOSCol [expr 3.5*$m]; # Length of Other Storeys Columns
set NStory 5; # number of stories above ground level -------------- you can change this.
set NBay 3; # number of bays (max 9) ------------------------------you can change this.
set NElem 4;
set tmpNElem $NElem;

set TmpNBay $NBay;

set Coord [open $dataDir/Coord.out w]

# define NODAL COORDINATES
set X 0;
set Y 0;
set CurrStory $HBSCol;
set NLHeight 0;
set InitNID 100;

for {set Pier 1} {$Pier < [expr $NBay+2]} {incr Pier 1} {

set InitNID [expr 100*$Pier]
set X [expr $LBay*($Pier-1)]
set nodeID $InitNID;
node $nodeID $X $Y
#puts $Coord "$nodeID $X $Y"

for {set level 0} {$level < $NStory} {incr level 1} {
if {$level > 0} {set Currstory $HOSCol} else {set Currstory $HBSCol}
if {$level > 0} {set NLHeight [expr $HBSCol+($level-1)*$HOSCol]}
for {set ElmCount 1} {$ElmCount < $NElem} {incr ElmCount 1} {
set Y [expr ($NLHeight+ $ElmCount*($Currstory/$NElem))]
set nodeID [expr $InitNID + ($level*10)+$ElmCount]
node $nodeID $X $Y;
#puts $Coord "$nodeID $X $Y"
}
}
set Y 0;
set NLHeight 0;
}

set X 0;
set Y $HBSCol;
for {set Pier 1} {$Pier < [expr $NBay+2]} {incr Pier 1} {

set InitNID [expr (1000+100*$Pier)]
set NBLength [expr $LBay*($Pier-1)]
#set nodeID $InitNID;
#node $nodeID $X $Y
#puts "$nodeID $X $Y"


for {set level 1} {$level < [expr $NStory+1]} {incr level 1} {
set InitNID [expr ((1000*$level)+(100*$Pier))]
set Y [expr $HBSCol+($level-1)*$HOSCol]
if {$Pier == [expr $NBay+1]} {set tmpNElem 1}
for {set ElmCount 0} {$ElmCount < $tmpNElem} {incr ElmCount 1} {
set X [expr ($NBLength+ $ElmCount*($LBay/$tmpNElem))]
set nodeID [expr $InitNID + $ElmCount]
node $nodeID $X $Y;
#puts $Coord "$nodeID $X $Y"
}

set NBLength [expr $LBay*($Pier-1)];
}

}

#determine support nodes where ground motions are input, for multiple-support excitation
set iSupportNode ""
set level 0
for {set pier 1} {$pier <= [expr $NBay+1]} {incr pier 1} {
set nodeID [expr $pier*100]
#puts $nodeID
lappend iSupportNode $nodeID
}


# BOUNDARY CONDITIONS
#fixY 0.0 1 1 1; # pin all Y=0.0 nodes
fix 100 1 1 1;
fix 200 1 1 1;
fix 300 1 1 1;
fix 400 1 1 1;

# define MATERIAL properties ----------------------------------------
set Fy [expr 275*$MPa]
set Es [expr 200000.0*$MPa]; # Steel Young's Modulus
set Hiso 0
set Hkin 1005; #0.5% Post Yield Stiffness
set matIDhard 1
uniaxialMaterial Hardening $matIDhard $Es $Fy $Hiso $Hkin

#******* ELEMENT properties ********
# Structural-Steel IPE300 properties
#********** Beam sections: IPE300 **********
set d [expr 0.3*$m]; # depth
set bf [expr 0.150*$m]; # flange width
set tf [expr 0.0107*$m]; # flange thickness
set tw [expr 0.0071*$m]; # web thickness
set nfdw 16; # number of fibers along dw
set nftw 2; # number of fibers along tw
set nfbf 16; # number of fibers along bf
set nftf 4; # number of fibers along tf
Wsection 1 $matIDhard $d $bf $tf $tw $nfdw $nftw $nfbf $nftf

# Structural-Steel IPE400 properties
#********** Beam sections: IPE400 **********
set d [expr 0.4*$m]; # depth
set bf [expr 0.180*$m]; # flange width
set tf [expr 0.0127*$m]; # flange thickness
set tw [expr 0.008*$m]; # web thickness
set nfdw 16; # number of fibers along dw
set nftw 2; # number of fibers along tw
set nfbf 16; # number of fibers along bf
set nftf 4; # number of fibers along tf
Wsection 2 $matIDhard $d $bf $tf $tw $nfdw $nftw $nfbf $nftf

# Structural-Steel HE400B properties
#********** Column sections: HE400B **********
set d [expr 0.4*$m]; # depth
set bf [expr 0.300*$m]; # flange width
set tf [expr 0.024*$m]; # flange thickness
set tw [expr 0.0135*$m]; # web thickness
set nfdw 16; # number of fibers along dw
set nftw 2; # number of fibers along tw
set nfbf 16; # number of fibers along bf
set nftf 4; # number of fibers along tf
Wsection 3 $matIDhard $d $bf $tf $tw $nfdw $nftw $nfbf $nftf

# Structural-Steel HE500B properties
#********** Column sections: HE500B **********
set d [expr 0.5*$m]; # depth
set bf [expr 0.300*$m]; # flange width
set tf [expr 0.028*$m]; # flange thickness
set tw [expr 0.0145*$m]; # web thickness
set nfdw 16; # number of fibers along dw
set nftw 2; # number of fibers along tw
set nfbf 16; # number of fibers along bf
set nftf 4; # number of fibers along tf
Wsection 4 $matIDhard $d $bf $tf $tw $nfdw $nftw $nfbf $nftf

# define ELEMENTS
# set up geometric transformations of element
# separate columns and beams, in case of P-Delta analysis for columns
set IDColTransf 1; # all columns
set IDBeamTransf 2; # all beams
set ColTransfType Corotational; # options, Linear PDelta Corotational
geomTransf $ColTransfType $IDColTransf ; # only columns can have PDelta effects (gravity effects)
geomTransf Linear $IDBeamTransf

# Define Beam-Column Elements
set np 4; # number of Gauss integration points for nonlinear curvature distribution-- np=2 for linear distribution ok
# columns
set ColID 4;
set NLHeight 0;
set InitNID 100;
set Y 0;

for {set Pier 1} {$Pier < [expr $NBay+2]} {incr Pier 1} {

set initNID [expr 100*$Pier]


for {set level 0} {$level < $NStory} {incr level 1} {

if {$level > 2 && $Pier == 1 || $level > 2 && $Pier == 4} {set ColID 3} else {set ColID 4}
#if {$level > 2 && $Pier == 4} {set ColID 3} else {set ColID 4}

for {set ElmCount 1} {$ElmCount < [expr $NElem+1] } {incr ElmCount 1} {
if {$ElmCount == 1} {set nodeI [expr (1000*$level+(100*$Pier))]} else {set nodeI [expr $initNID + ($level*10)+($ElmCount-1)]}
if {$ElmCount == $NElem} {set nodeJ [expr ((1000*($level+1))+(100*$Pier))]} else {set nodeJ [expr $initNID + ($level*10)+($ElmCount)]}
#puts "$nodeI $nodeJ"
set elemID [expr ($initNID+($level*10)+$ElmCount)];
puts $Coord "$elemID $nodeI $nodeJ $ColID $level $Pier";
element nonlinearBeamColumn $elemID $nodeI $nodeJ $np $ColID $IDColTransf

}
}

}

set BeamID 2;

for {set Pier 1} {$Pier < [expr $NBay+1]} {incr Pier 1} {

for {set level 1} {$level < [expr $NStory+1]} {incr level 1} {

if {$level == 5} {set BeamID 1} else {set BeamID 2}
for {set ElmCount 1} {$ElmCount < [expr $NElem+1] } {incr ElmCount 1} {
if {$ElmCount == 1} {set nodeI [expr (1000*$level+(100*$Pier))]} else {set nodeI [expr (1000*$level+(100*$Pier))+($ElmCount-1)]}
if {$ElmCount == $NElem} {set nodeJ [expr (1000*$level+(100*($Pier+1)))]} else {set nodeJ [expr (1000*$level+(100*$Pier))+$ElmCount]}
#puts "$nodeI $nodeJ"
set elemID [expr $nodeI+1];
puts $Coord "$elemID $nodeI $nodeJ $BeamID";
element nonlinearBeamColumn $elemID $nodeI $nodeJ $np $BeamID $IDBeamTransf
}
}

}


#************ Assign Nodal Masses ********

for {set level 1} {$level <= $NStory-1} {incr level 1} {
for {set pier 1} {$pier < [expr ($NBay+2)]} {incr pier 1} {
set nodeID [expr ($level*1000)+($pier*100)]
if {$pier == 1 || $pier == 4} {mass $nodeID 11650 1e-9 0} else {mass $nodeID 23300 1e-9 0}
puts "$pier $nodeID";
}
}

# Masses on top floor
mass 5100 9270 1e-9 0;
mass 5200 18540 1e-9 0;
mass 5300 18540 1e-9 0;
mass 5400 9270 1e-9 0;


# Define DISPLAY -------------------------------------------------------------
DisplayModel2D NodeNumbers

puts "Model Built"

recorder EnvelopeNode -file $dataDir/DFree.out -node 5400 -dof 1 disp; # displacements of free node
#recorder EnvelopeNode -file $dataDir/RBase.out -nodeRange 1 4 -dof 1 reaction; # support reaction
#recorder Drift -file $dataDir/DrNode.out -time -iNode $SupportNodeFirst -jNode $FreeNodeID -dof 1 -perpDirn 2; # lateral drift
recorder EnvelopeElement -file $dataDir/Fel1.out -ele 101 localForce; # element forces in local coordinates
recorder EnvelopeElement -file $dataDir/Fel2.out -ele 201 localForce;
recorder EnvelopeElement -file $dataDir/Fel3.out -ele 301 localForce;
recorder EnvelopeElement -file $dataDir/Fel4.out -ele 401 localForce;
recorder EnvelopeDrift -file $dataDir/MaxNodeDrift_Level1.out -iNode 400 -jNode 1400 -dof 1 -perpDirn 2;
recorder EnvelopeDrift -file $dataDir/MaxNodeDrift_Level2.out -iNode 1400 -jNode 2400 -dof 1 -perpDirn 2;
recorder EnvelopeDrift -file $dataDir/MaxNodeDrift_Level3.out -iNode 2400 -jNode 3400 -dof 1 -perpDirn 2;
recorder EnvelopeDrift -file $dataDir/MaxNodeDrift_Level4.out -iNode 3400 -jNode 4400 -dof 1 -perpDirn 2;
recorder EnvelopeDrift -file $dataDir/MaxNodeDrift_Level5.out -iNode 4400 -jNode 5400 -dof 1 -perpDirn 2;



set eigenvalues [eigen frequency 2]
set Fr [lindex $eigenvalues 0]
puts $Fr
set OmegaOPS [expr sqrt($Fr)]
set TP [expr (6.283/$OmegaOPS)]
puts "Final Time period from OpenSees = $TP sec"


# --------------------------------------------------------------------------------------------------
# Example 6. 2D Frame -- Uniform EQ ground motion
# Silvia Mazzoni & Frank McKenna, 2006
# execute this file after you have built the model, and after you apply gravity
#

# source in procedures
source ReadSMDfile.tcl; # procedure for reading GM file and converting it to proper format

# Uniform Earthquake ground motion (uniform acceleration input at all support nodes)
set GMdirection 1; # ground-motion direction
set GMfile "H-e12140" ; # ground-motion filenames
#set GMfact 2.8; # ground-motion scaling factor

# display deformed shape:
set ViewScale 5; # amplify display of deformed shape
DisplayModel2D DeformedShape $ViewScale ; # display deformed shape, the scaling factor needs to be adjusted for each model
#recorder plot $dataDir/DFree.out Displ 10 700 400 400 -columns 1 2; # a window to plot the nodal displacements versus time

# set up ground-motion-analysis parameters
set DtAnalysis [expr 0.01*$sec]; # time-step Dt for lateral analysis
set TmaxAnalysis [expr 38. *$sec]; # maximum duration of ground-motion analysis -- should be 50*$sec

# ----------- set up analysis parameters
source LibAnalysisDynamicParameters.tcl; # constraintsHandler,DOFnumberer,system-ofequations,convergenceTest,solutionAlgorithm,integrator

# ------------ define & apply damping
# RAYLEIGH damping parameters, Where to put M/K-prop damping, switches (http://opensees.berkeley.edu/OpenSees/m ... l/1099.htm)
# D=$alphaM*M + $betaKcurr*Kcurrent + $betaKcomm*KlastCommit + $beatKinit*$Kinitial
set xDamp 0.02; # damping ratio
set alphaM 0;
set betaKcomm 0;
set betaKinit 0;
#set MpropSwitch 0.0;
set KcurrSwitch 1.0;
#set KcommSwitch 1.0;
#set KinitSwitch 0.0;
#set omegaJ 0;
set nEigenI 1; # mode 1
#set nEigenJ 3; # mode 3
set lambdaI [eigen 1]; # eigenvalue analysis for nEigenJ modes
#set lambdaI [lindex $lambdaN [expr $nEigenI-1]]; # eigenvalue mode i
#set lambdaJ [lindex $lambdaN [expr $nEigenJ-1]]; # eigenvalue mode j
set omegaI [expr pow($lambdaI,0.5)];
#set omegaJ [expr pow($lambdaJ,0.5)]; #To use R
set TI [expr (6.283/$omegaI)]
#set TJ [expr (6.283/$omegaJ)]
puts "$TI"
#puts "$TJ"
#set alphaM [expr $MpropSwitch*$xDamp*(2*$omegaI*$omegaJ)/($omegaI+$omegaJ)]; # M-prop. damping; D = alphaM*M
#set betaKcurr [expr $KcurrSwitch*2.*$xDamp/($omegaI+$omegaJ)]; # current-K; +beatKcurr*KCurrent
set betaKcurr [expr $KcurrSwitch*2.*$xDamp/($omegaI)];
#set betaKcomm [expr $KcommSwitch*2.*$xDamp/($omegaI)]; # last-committed K; +betaKcomm*KlastCommitt
#set betaKinit [expr $KinitSwitch*2.*$xDamp/($omegaI+$omegaJ)]; # initial-K; +beatKinit*Kini
puts "betaKcurr is $betaKcurr"

# define damping
rayleigh $alphaM $betaKcurr $betaKinit $betaKcomm; # RAYLEIGH damping

# --------------------------------- perform Dynamic Ground-Motion Analysis
# the following commands are unique to the Uniform Earthquake excitation
set IDloadTag 400; # for uniformSupport excitation
# Uniform EXCITATION: acceleration input
set inFile $GMdir/$GMfile.at2
set outFile $GMdir/$GMfile.g3; # set variable holding new filename (PEER files have .at2/dt2 extension)
ReadSMDFile $inFile $outFile dt; # call procedure to convert the ground-motion file
set GMfatt [expr $g*$GMfact]; # data in input file is in g Unifts -- ACCELERATION TH
set AccelSeries "Series -dt $dt -filePath $outFile -factor $GMfatt"; # time series information
pattern UniformExcitation $IDloadTag $GMdirection -accel $AccelSeries ; # create Unifform excitation

set Nsteps [expr int($TmaxAnalysis/$DtAnalysis)];
set ok [analyze $Nsteps $DtAnalysis 0.001 0.01 5]; # actually perform analysis; returns ok=0 if analysis was successful
set Tol 1.0e-4

if {$ok != 0} { ; # analysis was not successful.
# --------------------------------------------------------------------------------------------------
# change some analysis parameters to achieve convergence
# performance is slower inside this loop
# Time-controlled analysis
set ok 0;
set controlTime [getTime];
while {$controlTime < $TmaxAnalysis && $ok == 0} {
set controlTime [getTime]
set ok [analyze 1 $DtAnalysis]
if {$ok != 0} {
puts "Trying Newton with Initial Tangent .."
test NormDispIncr $Tol 1000 0
algorithm Newton -initial
set ok [analyze 1 $DtAnalysis]
test $testTypeDynamic $TolDynamic $maxNumIterDynamic 0
algorithm $algorithmTypeDynamic
}
if {$ok != 0} {
puts "Trying Broyden .."
algorithm Broyden 8
set ok [analyze 1 $DtAnalysis]
algorithm $algorithmTypeDynamic
}
if {$ok != 0} {
puts "Trying NewtonWithLineSearch .."
algorithm NewtonLineSearch .8
set ok [analyze 1 $DtAnalysis]
algorithm $algorithmTypeDynamic
}

}
} ; # end if ok !0




puts "Ground Motion Done. End Time: [getTime]"



# --------------------------------------------------------------------------------------------------
# dynamic-analysis parameters
# I am setting all these variables as global variables (using variable rather than set command)
# so that these variables can be uploaded by a procedure
# Silvia Mazzoni & Frank McKenna, 2006


# Set up Analysis Parameters ---------------------------------------------
# CONSTRAINTS handler -- Determines how the constraint equations are enforced in the analysis (http://opensees.berkeley.edu/OpenSees/m ... al/617.htm)
# Plain Constraints -- Removes constrained degrees of freedom from the system of equations
# Lagrange Multipliers -- Uses the method of Lagrange multipliers to enforce constraints
# Penalty Method -- Uses penalty numbers to enforce constraints
# Transformation Method -- Performs a condensation of constrained degrees of freedom
variable constraintsTypeDynamic Transformation;
constraints $constraintsTypeDynamic ;

# DOF NUMBERER (number the degrees of freedom in the domain): (http://opensees.berkeley.edu/OpenSees/m ... al/366.htm)
# determines the mapping between equation numbers and degrees-of-freedom
# Plain -- Uses the numbering provided by the user
# RCM -- Renumbers the DOF to minimize the matrix band-width using the Reverse Cuthill-McKee algorithm
variable numbererTypeDynamic RCM
numberer $numbererTypeDynamic

# SYSTEM (http://opensees.berkeley.edu/OpenSees/m ... al/371.htm)
# Linear Equation Solvers (how to store and solve the system of equations in the analysis)
# -- provide the solution of the linear system of equations Ku = P. Each solver is tailored to a specific matrix topology.
# ProfileSPD -- Direct profile solver for symmetric positive definite matrices
# BandGeneral -- Direct solver for banded unsymmetric matrices
# BandSPD -- Direct solver for banded symmetric positive definite matrices
# SparseGeneral -- Direct solver for unsymmetric sparse matrices (-piv option)
# SparseSPD -- Direct solver for symmetric sparse matrices
# UmfPack -- Direct UmfPack solver for unsymmetric matrices
variable systemTypeDynamic BandGeneral; # try UmfPack for large problems
system $systemTypeDynamic

# TEST: # convergence test to
# Convergence TEST (http://opensees.berkeley.edu/OpenSees/m ... al/360.htm)
# -- Accept the current state of the domain as being on the converged solution path
# -- determine if convergence has been achieved at the end of an iteration step
# NormUnbalance -- Specifies a tolerance on the norm of the unbalanced load at the current iteration
# NormDispIncr -- Specifies a tolerance on the norm of the displacement increments at the current iteration
# EnergyIncr-- Specifies a tolerance on the inner product of the unbalanced load and displacement increments at the current iteration
# RelativeNormUnbalance --
# RelativeNormDispIncr --
# RelativeEnergyIncr --
variable TolDynamic 1.e-8; # Convergence Test: tolerance
variable maxNumIterDynamic 100; # Convergence Test: maximum number of iterations that will be performed before "failure to converge" is returned
variable printFlagDynamic 0; # Convergence Test: flag used to print information on convergence (optional) # 1: print information on each step;
variable testTypeDynamic NormDispIncr; # Convergence-test type
#test $testTypeDynamic $TolDynamic $maxNumIterDynamic $printFlagDynamic;
test NormDispIncr $TolDynamic $maxNumIterDynamic $printFlagDynamic;

# for improved-convergence procedure:
variable maxNumIterConvergeDynamic 2000;
variable printFlagConvergeDynamic 0;

# Solution ALGORITHM: -- Iterate from the last time step to the current (http://opensees.berkeley.edu/OpenSees/m ... al/682.htm)
# Linear -- Uses the solution at the first iteration and continues
# Newton -- Uses the tangent at the current iteration to iterate to convergence
# ModifiedNewton -- Uses the tangent at the first iteration to iterate to convergence
# NewtonLineSearch --
# KrylovNewton --
# BFGS --
# Broyden --
variable algorithmTypeDynamic ModifiedNewton
algorithm $algorithmTypeDynamic;

# Static INTEGRATOR: -- determine the next time step for an analysis (http://opensees.berkeley.edu/OpenSees/m ... al/689.htm)
# LoadControl -- Specifies the incremental load factor to be applied to the loads in the domain
# DisplacementControl -- Specifies the incremental displacement at a specified DOF in the domain
# Minimum Unbalanced Displacement Norm -- Specifies the incremental load factor such that the residual displacement norm in minimized
# Arc Length -- Specifies the incremental arc-length of the load-displacement path
# Transient INTEGRATOR: -- determine the next time step for an analysis including inertial effects
# Newmark -- The two parameter time-stepping method developed by Newmark
# HHT -- The three parameter Hilbert-Hughes-Taylor time-stepping method
# Central Difference -- Approximates velocity and acceleration by centered finite differences of displacement
variable NewmarkGamma 0.5; # Newmark-integrator gamma parameter (also HHT)
variable NewmarkBeta 0.25; # Newmark-integrator beta parameter
variable integratorTypeDynamic Newmark;
integrator $integratorTypeDynamic $NewmarkGamma $NewmarkBeta
set xDamp 0.02; # damping ratio
set alphaM 0;
set betaKcomm 0;
set betaKinit 0;
set KcurrSwitch 1.0;
set nEigenI 1; # mode 1
set lambdaI [eigen 1]; # eigenvalue analysis for nEigenJ modes
set omegaI [expr pow($lambdaI,0.5)];
set TI [expr (6.283/$omegaI)]
#puts "betaKcurr is $betaKcurr"

#integrator HHT 0.5 $alphaM $betaKcurr $betaKinit $betaKcomm;

# ANALYSIS -- defines what type of analysis is to be performed (http://opensees.berkeley.edu/OpenSees/m ... al/324.htm)
# Static Analysis -- solves the KU=R problem, without the mass or damping matrices.
# Transient Analysis -- solves the time-dependent analysis. The time step in this type of analysis is constant. The time step in the output is also constant.
# variableTransient Analysis -- performs the same analysis type as the Transient Analysis object. The time step, however, is variable. This method is used when
# there are convergence problems with the Transient Analysis object at a peak or when the time step is too small. The time step in the output is also variable.
variable analysisTypeDynamic VariableTransient
analysis $analysisTypeDynamic

#***********************************

Look forward to your response.

Kumar, M.

[silvia]

look at the critical-section response.
likely, the demands on a fiber are too high.

[mkumar07]

Dear Silvia,

First of all thanks for prompt response as always.

It does not make too much sense to me ; because when I use single forced based element per member the nonlinear time history works for ductilities as large as 6-8 for the given frame; and the frame also works with 4 displacement based elements per member. But when I increase the forced based elements per member from (1 to 2 or 4) or higher it doesnot work and gives the error as mentioned in my post.

I find it appropriate to mention here that if I use one force based element in comparison to 4 displacement based elements the accuracy is not compromised for the given frame and time history; which is the beauty of forced based elements as mentioned in paper by Neuenhofer and Filippou.

But I still want to see the difference with more forced based elements per member . If you have any other suggestion, please share.

Thanks once again.

Kumar, M.

[silvia]

you should read-up on the nonlinearbeamcolumn element to see how very accurate it is with one single element. if you use more than 1, or 2, you do run into convergence problems.

[mkumar07]

I am thankful to you for the response and confirmation of convergence problems if more than one elements are used.

Kumar, M.