I, Gid+Opensees user, built a simple 1 story reinforced concrete frame, 2 intervals setted, cyclic loads loaded in joint node, this is my .tcl file and log, can any one help solve this problem. 3Q very much!
TCL file
#
# ____ _ ____ ___ ____ ___ _ __
# / ___(_) _ \ _ / _ \ _ __ ___ _ __ / ___| ___ ___ ___ |_ _|_ __ | |_ ___ _ __ / _| __ _ ___ ___
# | | _| | | | |_| |_| | | | '_ \ / _ \ '_ \\___ \ / _ \/ _ \/ __| | || '_ \| __/ _ \ '__| |_ / _` |/ __/ _ \
# | |_| | | |_| |_ _| |_| | |_) | __/ | | |___) | __/ __/\__ \ | || | | | || __/ | | _| (_| | (_| __/
# \____|_|____/ |_| \___/| .__/ \___|_| |_|____/ \___|\___||___/ |___|_| |_|\__\___|_| |_| \__,_|\___\___|
# |_|
#
# GiD + OpenSees Interface - An Integrated FEA Platform
# Copyright (C) 2016-2018
#
# Lab of R/C and Masonry Structures
# School of Civil Engineering, AUTh
#
# Development team
#
# T. Kartalis-Kaounis, Civil Engineer AUTh
# V. Protopapadakis, Civil Engineer AUTh
# T. Papadopoulos, Civil Engineer AUTh
#
# Project coordinator
#
# V.K. Papanikolaou, Assistant Professor AUTh
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# --------------------------------------------------------------------------------------------------------------
# U N I T S
# --------------------------------------------------------------------------------------------------------------
# Length : m
# Force : kN
# Moment : kNm
# Stress : kPa
# Mass : ton
# --------------------------------------------------------------------------------------------------------------
# E L E M E N T S U S E D
# --------------------------------------------------------------------------------------------------------------
# C500X500 (6)
# B250X500 (6)
# --------------------------------------------------------------------------------------------------------------
#
# M O D E L D O M A I N 1 (6DOF)
#
# --------------------------------------------------------------------------------------------------------------
model BasicBuilder -ndm 3 -ndf 6
# --------------------------------------------------------------------------------------------------------------
# N O D E S
# --------------------------------------------------------------------------------------------------------------
# node $NodeTag $XCoord $Ycoord $Zcoord
node 1 6 0 0
node 2 6 0 1.1
node 3 6 0 2.2
node 4 6 0 3.3
node 5 5 0 3.3
node 6 4 0 3.3
node 7 3 0 3.3
node 8 2 0 3.3
node 9 1 0 3.3
node 10 0 0 0
node 11 0 0 1.1
node 12 0 0 2.2
node 13 0 0 3.3
# --------------------------------------------------------------------------------------------------------------
# R E S T R A I N T S
# --------------------------------------------------------------------------------------------------------------
# fix $NodeTag x-transl y-transl z-transl x-rot y-rot z-rot
fix 1 1 1 1 1 1 1
fix 10 1 1 1 1 1 1
# --------------------------------------------------------------------------------------------------------------
# F O R C E - B A S E D B E A M - C O L U M N E L E M E N T S
# --------------------------------------------------------------------------------------------------------------
# Geometric Transformation
geomTransf Linear 1 -1 0 0
geomTransf PDelta 3 -1 0 0
geomTransf Corotational 5 -1 0 0
geomTransf Linear 2 0 0 1
geomTransf PDelta 4 0 0 1
geomTransf Corotational 6 0 0 1
# Sections Definition used by forceBeamColumn Elements
# (飊ly if they have not already been defined on this model domain)
uniaxialMaterial Concrete06 154 -40000 -0.0023 1 1 -0.00235 3500 0.0001006 1 0.0007042
uniaxialMaterial Concrete06 155 -35000 -0.00225 1 1 -0.002375 3200 0.0001029 1 0.0007203
uniaxialMaterial Steel01 156 400000 2e+08 0.15 0 1 0 1
section Fiber 157 {
# Create the Core fibers
# patch rect $matTag $numSubdivY $numSubdivZ $yI $zI $yJ $zJ
patch rect 154 11 11 -0.200000 -0.200000 0.200000 0.200000
# Create the Cover fibers
# patch rect $matTag $numSubdivY $numSubdivZ $yI $zI $yJ $zJ
patch rect 155 2 15 0.200000 -0.250000 0.250000 0.250000
patch rect 155 2 15 -0.250000 -0.250000 -0.200000 0.250000
patch rect 155 11 2 -0.200000 0.200000 0.200000 0.250000
patch rect 155 11 2 -0.200000 -0.250000 0.200000 -0.200000
# Create the corner bars
# layer straight $matTag $numFiber $areaFiber $yStart $zStart $yEnd $zEnd
layer straight 156 2 0.00049090 0.200000 0.200000 0.200000 -0.200000
layer straight 156 2 0.00049090 -0.200000 0.200000 -0.200000 -0.200000
# Create the middle Reinforcing Bars along local z axis
# layer straight $matTag $numFiber $areaFiber $yStart $zStart $yEnd $zEnd
layer straight 156 3 0.00038010 0.200000 0.100000 0.200000 -0.100000
layer straight 156 3 0.00038010 -0.200000 0.100000 -0.200000 -0.100000
# Create the middle Reinforcing Bars along local y axis
# layer straight $matTag $numFiber $areaFiber $yStart $zStart $yEnd $zEnd
layer straight 156 3 0.00038010 0.100000 0.200000 -0.100000 0.200000
layer straight 156 3 0.00038010 0.100000 -0.200000 -0.100000 -0.200000
}
section Fiber 158 {
# Create the Core fibers
# patch rect $matTag $numSubdivY $numSubdivZ $yI $zI $yJ $zJ
patch rect 154 11 9 -0.200000 -0.075000 0.200000 0.075000
# Create the Cover fibers
# patch rect $matTag $numSubdivY $numSubdivZ $yI $zI $yJ $zJ
patch rect 155 2 15 0.200000 -0.125000 0.250000 0.125000
patch rect 155 2 15 -0.250000 -0.125000 -0.200000 0.125000
patch rect 155 11 3 -0.200000 0.075000 0.200000 0.125000
patch rect 155 11 3 -0.200000 -0.125000 0.200000 -0.075000
# Create the Top bars (face on local z positive dir)
# layer straight $matTag $numFiber $areaFiber $yStart $zStart $yEnd $zEnd
layer straight 156 6 0.00031420 -0.200000 0.075000 0.200000 0.075000
# Create the Bottom bars (face on local z negative dir)
layer straight 156 6 0.00031420 -0.200000 -0.075000 0.200000 -0.075000
}
# Force-Based Beam Column Element Definition
# element forceBeamColumn $eleTag $iNode $jNode $numIntgrPts $secTag $transfTag
element forceBeamColumn 1 1 2 3 157 3 -iter 10 1.00e-06 -mass 0.625
element forceBeamColumn 2 2 3 3 157 3 -iter 10 1.00e-06 -mass 0.625
element forceBeamColumn 3 3 4 3 157 3 -iter 10 1.00e-06 -mass 0.625
element forceBeamColumn 4 4 5 3 158 2 -iter 10 1.00e-06 -mass 0.3125
element forceBeamColumn 5 5 6 3 158 2 -iter 10 1.00e-06 -mass 0.3125
element forceBeamColumn 6 6 7 3 158 2 -iter 10 1.00e-06 -mass 0.3125
element forceBeamColumn 7 7 8 3 158 2 -iter 10 1.00e-06 -mass 0.3125
element forceBeamColumn 8 8 9 3 158 2 -iter 10 1.00e-06 -mass 0.3125
element forceBeamColumn 9 9 13 3 158 2 -iter 10 1.00e-06 -mass 0.3125
element forceBeamColumn 10 13 12 3 157 3 -iter 10 1.00e-06 -mass 0.625
element forceBeamColumn 11 12 11 3 157 3 -iter 10 1.00e-06 -mass 0.625
element forceBeamColumn 12 11 10 3 157 3 -iter 10 1.00e-06 -mass 0.625
# --------------------------------------------------------------------------------------------------------------
#
# D O M A I N C O M M O N S
#
# --------------------------------------------------------------------------------------------------------------
# --------------------------------------------------------------------------------------------------------------
# R E C O R D E R S
# --------------------------------------------------------------------------------------------------------------
recorder Node -file Node_displacements.out -time -nodeRange 1 13 -dof 1 2 3 disp
recorder Node -file Node_rotations.out -time -nodeRange 1 13 -dof 4 5 6 disp
recorder Node -file Node_forceReactions.out -time -nodeRange 1 13 -dof 1 2 3 reaction
recorder Node -file Node_momentReactions.out -time -nodeRange 1 13 -dof 4 5 6 reaction
recorder Element -file ForceBeamColumn_localForce.out -time -ele 1 2 3 4 5 6 7 8 9 10 11 12 localForce
recorder Element -file ForceBeamColumn_basicDeformation.out -time -ele 1 2 3 4 5 6 7 8 9 10 11 12 basicDeformation
recorder Element -file ForceBeamColumn_plasticDeformation.out -time -ele 1 2 3 4 5 6 7 8 9 10 11 12 plasticDeformation
logFile "ypkj.log"
puts ""
puts " __ __ __ __ _ "
puts "/ _ .| \\ _|_ / \\ _ _ _ (_ _ _ _ | _ |_ _ _(_ _ _ _"
puts "\\__)||__/ | \\__/|_)(-| )__)(-(-_) || )|_(-| | (_|(_(-"
puts " | "
puts " v2.6.0"
puts "Analysis summary"
puts ""
puts "Interval 1 : Static - [expr int(1+5)] steps"
puts "Interval 2 : Static - [expr int(1+ 400)] steps"
puts ""
puts "----------------"
puts ""
set time_start [clock seconds]
puts "Starting analysis at [clock format $time_start -format %H:%M:%S]\n"
# --------------------------------------------------------------------------------------------------------------
#
# I N T E R V A L 1
#
# --------------------------------------------------------------------------------------------------------------
puts "Running interval 1\n"
# Loads - Plain Pattern
pattern Plain 100 Linear {
load 4 0 0 -2005 0 0 0
load 13 0 0 -2005 0 0 0
eleLoad -ele 4 -type -beamUniform 0 -10 0
eleLoad -ele 5 -type -beamUniform 0 -10 0
eleLoad -ele 6 -type -beamUniform 0 -10 0
eleLoad -ele 7 -type -beamUniform 0 -10 0
eleLoad -ele 8 -type -beamUniform 0 -10 0
eleLoad -ele 9 -type -beamUniform 0 -10 0
# Dead Loads
eleLoad -ele 1 -type -beamUniform 0 0 -6.25
eleLoad -ele 2 -type -beamUniform 0 0 -6.25
eleLoad -ele 3 -type -beamUniform 0 0 -6.25
eleLoad -ele 4 -type -beamUniform 0 -3.125 -0
eleLoad -ele 5 -type -beamUniform 0 -3.125 -0
eleLoad -ele 6 -type -beamUniform 0 -3.125 -0
eleLoad -ele 7 -type -beamUniform 0 -3.125 -0
eleLoad -ele 8 -type -beamUniform 0 -3.125 -0
eleLoad -ele 9 -type -beamUniform 0 -3.125 -0
eleLoad -ele 10 -type -beamUniform 0 0 6.25
eleLoad -ele 11 -type -beamUniform 0 0 6.25
eleLoad -ele 12 -type -beamUniform 0 0 6.25
}
# recording the initial status
record
# Perform eigenvalue analysis
puts "Running eigenvalue analysis\n"
set numModes 9
# Record eigenvectors
for { set k 1 } { $k <= $numModes } { incr k } {
recorder Node -file [format "Mode_%i.out" $k] -nodeRange 1 13 -dof 1 2 3 "eigen $k"
}
set lambda [eigen -fullGenLapack $numModes]
# Calculate periods
set T {}
foreach lam $lambda {
lappend T [expr 6.283185/sqrt($lam)]
}
# Write periods file
set period "Periods.out"
set Periods [open $period "w"]
foreach t $T {
puts $Periods "$t"
}
close $Periods
# Analysis options
system BandGeneral
numberer RCM
constraints Transformation
integrator LoadControl 0.2
test NormDispIncr 1e-06 100 0
algorithm Newton
analysis Static
set Lincr 0.200000
set Nsteps 5
set committedSteps 1
set LoadCounter 0
variable strIni {}
variable testTypeStatic NormDispIncr
variable TolStatic 1e-06
variable maxNumIterStatic 100
variable algorithmTypeStatic Newton
for {set i 1} { $i <= $Nsteps } {incr i 1} {
set t [format "%7.5f" [expr [getTime] + $Lincr]]
set AnalOk [analyze 1]
if {$AnalOk !=0} {
break
} else {
set LoadCounter [expr $LoadCounter+1.0]
set committedSteps [expr $committedSteps+1]
}
}
if {$AnalOk != 0} {; # if analysis fails, alternative algorithms and substepping is applied
set firstFail 1
set AnalOk 0
set Nk 1
set returnToInitStepFlag 0
while {$LoadCounter < $Nsteps && $AnalOk == 0} {
if {($Nk==2 && $AnalOk==0) || ($Nk==1 && $AnalOk==0)} {
set Nk 1
if {$returnToInitStepFlag} {
puts "\nBack to initial step\n"
set returnToInitStepFlag 0
}
if {$firstFail == 0} { # for the first time only, do not repeat previous failed step
integrator LoadControl $Lincr; # reset to original increment
set t [format "%7.5f" [expr [getTime] + $Lincr]]
set AnalOk [analyze 1]; # zero for convergence
} else {
set AnalOk 1
set firstFail 0
}
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [format "%7.5f" [expr [getTime] + $Lincr]]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set LoadCounter [expr $LoadCounter+1.0/$Nk]
set committedSteps [expr $committedSteps+1]
}
}; # end if Nk=1
# substepping /2
if {($AnalOk !=0 && $Nk==1) || ($AnalOk==0 && $Nk==4)} {
set Nk 2; # reduce step size
set continueFlag 1
puts "\nInitial step is divided by 2\n"
set LincrReduced [expr $Lincr/$Nk]
integrator LoadControl $LincrReduced
for {set ik 1} {$ik <=$Nk} {incr ik 1} {
if {$continueFlag==0} {
break
}
set t [format "%7.5f" [expr [getTime] + $LincrReduced]]
set AnalOk [analyze 1]; # zero for convergence
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [format "%7.5f" [expr [getTime] + $LincrReduced]]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set LoadCounter [expr $LoadCounter+1.0/$Nk]
set committedSteps [expr $committedSteps+1]
} else {
set continueFlag 0
}
}
if {$AnalOk == 0} {
set returnToInitStepFlag 1
}
}; # end if Nk=2
# substepping /4
if {($AnalOk !=0 && $Nk==2) || ($AnalOk==0 && $Nk==8)} {
set Nk 4; # reduce step size
set continueFlag 1
puts "\nInitial step is divided by 4\n"
set LincrReduced [expr $Lincr/$Nk]
integrator LoadControl $LincrReduced
for {set ik 1} {$ik <=$Nk} {incr ik 1} {
if {$continueFlag==0} {
break
}
set t [format "%7.5f" [expr [getTime] + $LincrReduced]]
set AnalOk [analyze 1]; # zero for convergence
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [format "%7.5f" [expr [getTime] + $LincrReduced]]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set LoadCounter [expr $LoadCounter+1.0/$Nk]
set committedSteps [expr $committedSteps+1]
} else {
set continueFlag 0
}
}
if {$AnalOk == 0} {
set returnToInitStepFlag 1
}
}; # end if Nk=4
# substepping /8
if {$AnalOk !=0 && $Nk==4 || ($Nk == 16 && $AnalOk == 0)} {
set Nk 8; # reduce step size
set continueFlag 1
puts "\nInitial step is divided by 8\n"
set LincrReduced [expr $Lincr/$Nk]
integrator LoadControl $LincrReduced
for {set ik 1} {$ik <=$Nk} {incr ik 1} {
if {$continueFlag==0} {
break
}
set t [format "%7.5f" [expr [getTime] + $LincrReduced]]
set AnalOk [analyze 1]; # zero for convergence
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [format "%7.5f" [expr [getTime] + $LincrReduced]]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set LoadCounter [expr $LoadCounter+1.0/$Nk]
set committedSteps [expr $committedSteps+1]
} else {
set continueFlag 0
}
}
if {$AnalOk == 0} {
set returnToInitStepFlag 1
}
}; # end if Nk=8
# substepping /16
if {($Nk == 8 && $AnalOk!=0)} {
set Nk 16; # reduce step size
set continueFlag 1
puts "\nInitial step is divided by 16\n"
set LincrReduced [expr $Lincr/$Nk]
integrator LoadControl $LincrReduced
for {set ik 1} {$ik <=$Nk} {incr ik 1} {
if {$continueFlag==0} {
break
}
set t [format "%7.5f" [expr [getTime] + $LincrReduced]]
set AnalOk [analyze 1]; # zero for convergence
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [format "%7.5f" [expr [getTime] + $LincrReduced]]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set LoadCounter [expr $LoadCounter+1.0/$Nk]
set committedSteps [expr $committedSteps+1]
} else {
set continueFlag 0
}
}
if {$AnalOk == 0} {
set returnToInitStepFlag 1
}
}; # end if Nk=16
}; # end while loop
}; # end if AnalOk
if {$AnalOk == 0} {
puts "\nAnalysis completed SUCCESSFULLY"
puts "Committed steps : $committedSteps\n"
} else {
puts "\nAnalysis FAILED"
puts "Committed steps : $committedSteps\n"
}
# all previously defined patterns are constant for so on.
loadConst -time 0.0
# --------------------------------------------------------------------------------------------------------------
#
# I N T E R V A L 2
#
# --------------------------------------------------------------------------------------------------------------
puts "Running interval 2\n"
# Loads - Plain Pattern
pattern Plain 200 Linear {
load 13 1 0 0 0 0 0
}
# recording the initial status
record
# Analysis options
system BandGeneral
numberer RCM
constraints Transformation
integrator DisplacementControl 13 1 0.00132
test NormDispIncr 1e-08 100 0
algorithm Newton
analysis Static
set iDmax [list]
set iNSteps [list]
set Nsteps 50
set committedSteps 1
set IDctrlNode 13
set IDctrlDOF 1
lappend iDmax 0.021978
lappend iNcycles 2
lappend iNSteps $Nsteps
lappend iDmax 0.043956
lappend iNcycles 2
lappend iNSteps $Nsteps
lappend iDmax 0.066
lappend iNcycles 2
lappend iNSteps $Nsteps
variable strIni {}
variable testTypeStatic NormDispIncr
variable TolStatic 1e-08
variable maxNumIterStatic 100
variable algorithmTypeStatic Newton
foreach Dmax $iDmax Ncycles $iNcycles NumSteps $iNSteps {
set DispIncr [expr $Dmax/$NumSteps]; # the displacement increment for each step
set Dstepvector ""
set Disp 0
if {$Dmax<0} {; # avoid the divide by zero
set dx [expr -$DispIncr]
} else {
set dx $DispIncr
}
for {set i 1} {$i <= $NumSteps} {incr i 1} {; # zero to one
set Disp [expr $Disp + $dx]
lappend Dstepvector $Disp
}
for {set i 1} {$i <= $NumSteps} {incr i 1} {; # one to zero
set Disp [expr $Disp - $dx]
lappend Dstepvector $Disp
}
for {set i 1} {$i <= $NumSteps} {incr i 1} {; # zero to minus one
set Disp [expr $Disp - $dx]
lappend Dstepvector $Disp
}
for {set i 1} {$i <= $NumSteps} {incr i 1} {; # minus one to zero
set Disp [expr $Disp + $dx]
lappend Dstepvector $Disp
}
for {set i 1} {$i <= $Ncycles} {incr i 1} {
set currentPath 1
set D0 0.0
foreach Dispstep $Dstepvector {
set D1 $Dispstep
set Dincr [expr $D1 - $D0]
integrator DisplacementControl $IDctrlNode $IDctrlDOF $Dincr
set t [getTime]
set AnalOk [analyze 1]; # first analyze command
set D0 $D1; # move to next step
set tempexpr1 [expr abs($D0-$Dmax)]
set tempexpr2 [expr abs($D0+$Dmax)]
set tempexpr3 [expr abs($D0)]
if {($tempexpr1 < 0.0000001) || ($tempexpr2 < 0.0000001) || ($tempexpr3 < 0.0000001)} {
set currentPath [expr $currentPath+1]
}
if {$AnalOk != 0 } {
break
}
}
if {$AnalOk != 0} {; # if analysis fails, alternative algorithms and substepping is applied
set firstFail 1
set Dstep 0.0
set AnalOk 0
set Nk 1
set returnToInitStepFlag 0
set tempexpr [expr abs($Dstep)]
while {($AnalOk == 0 && $currentPath<=3) || ($tempexpr > 0.000001 && $AnalOk == 0 && $currentPath==4)} {
set controlDisp [nodeDisp $IDctrlNode $IDctrlDOF]
set Dstep [expr $controlDisp/$Dmax]
if {($Nk==2 && $AnalOk==0) || ($Nk==1 && $AnalOk==0)} {
set Nk 1
if {$returnToInitStepFlag} {
puts "\nBack to initial step\n"
set returnToInitStepFlag 0
}
if {$firstFail == 0} {; # for the first time only, do not repeat previous failed step
if {$Dmax > 0} {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DispIncr; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DispIncr
}
} else {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DispIncr; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DispIncr
}
}
set t [getTime]
set AnalOk [analyze 1]; # zero for convergence
} else {
set AnalOk 1
set firstFail 0
}
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [getTime]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set committedSteps [expr $committedSteps+1]
}
}; # end if Nk=1
# substepping /2
if {($AnalOk !=0 && $Nk==1) || ($AnalOk==0 && $Nk==4)} {
set Nk 2; # reduce step size
set continueFlag 1
puts "\nInitial step is divided by 2\n"
set DincrReduced [expr $DispIncr/$Nk]
if {$Dmax > 0} {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DincrReduced; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DincrReduced
}
} else {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DincrReduced; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DincrReduced
}
}
for {set ik 1} {$ik <=$Nk} {incr ik 1} {
if {$continueFlag==0} {
break
}
set t [getTime]
set AnalOk [analyze 1]; # zero for convergence
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [getTime]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set committedSteps [expr $committedSteps+1]
} else {
set continueFlag 0
}
}
if {$AnalOk == 0} {
set returnToInitStepFlag 1
}
}; # end if Nk=2
# substepping /4
if {($AnalOk !=0 && $Nk==2) || ($AnalOk==0 && $Nk==8)} {
set Nk 4; # reduce step size
set continueFlag 1
puts "\nInitial step is divided by 4\n"
set DincrReduced [expr $DispIncr/$Nk]
if {$Dmax > 0} {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DincrReduced; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DincrReduced
}
} else {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DincrReduced; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DincrReduced
}
}
for {set ik 1} {$ik <=$Nk} {incr ik 1} {
if {$continueFlag==0} {
break
}
set t [getTime]
set AnalOk [analyze 1]; # zero for convergence
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [getTime]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set committedSteps [expr $committedSteps+1]
} else {
set continueFlag 0
}
}
if {$AnalOk == 0} {
set returnToInitStepFlag 1
}
}; # end if Nk=4
# substepping /8
if {$AnalOk !=0 && $Nk==4 || ($Nk == 16 && $AnalOk == 0)} {
set Nk 8; # reduce step size
set continueFlag 1
puts "\nInitial step is divided by 8\n"
set DincrReduced [expr $DispIncr/$Nk]
if {$Dmax > 0} {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DincrReduced; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DincrReduced
}
} else {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DincrReduced; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DincrReduced
}
}
for {set ik 1} {$ik <=$Nk} {incr ik 1} {
if {$continueFlag==0} {
break
}
set t [getTime]
set AnalOk [analyze 1]; # zero for convergence
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [getTime]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set committedSteps [expr $committedSteps+1]
} else {
set continueFlag 0
}
}
if {$AnalOk == 0} {
set returnToInitStepFlag 1
}
}; # end if Nk=8
# substepping /16
if {($Nk == 8 && $AnalOk!=0)} {
set Nk 16; # reduce step size
set continueFlag 1
puts "\nInitial step is divided by 16\n"
set DincrReduced [expr $DispIncr/$Nk]
if {$Dmax > 0} {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DincrReduced; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DincrReduced
}
} else {
if {$currentPath == 1 || $currentPath == 4 } {
integrator DisplacementControl $IDctrlNode $IDctrlDOF -$DincrReduced; # bring back to original increment
} else {
integrator DisplacementControl $IDctrlNode $IDctrlDOF $DincrReduced
}
}
for {set ik 1} {$ik <=$Nk} {incr ik 1} {
if {$continueFlag==0} {
break
}
set t [getTime]
set AnalOk [analyze 1]; # zero for convergence
if {$AnalOk != 0} {
puts "\nTrying NR/initial\n"
test NormDispIncr $TolStatic $maxNumIterStatic 0
algorithm Newton -initial
set t [getTime]
set AnalOk [analyze 1]
test $testTypeStatic $TolStatic $maxNumIterStatic 0
algorithm $algorithmTypeStatic
}
if {$AnalOk == 0} {
set committedSteps [expr $committedSteps+1]
} else {
set continueFlag 0
}
}
if {$AnalOk == 0} {
set returnToInitStepFlag 1
}
}; # end if Nk=16
set controlDisp [nodeDisp $IDctrlNode $IDctrlDOF]
set Dstep [expr $controlDisp/$Dmax]
set tempexpr1 [expr abs($Dstep-1)]
set tempexpr2 [expr abs($Dstep+1)]
set tempexpr3 [expr abs($Dstep)]
if {$tempexpr1 < 0.0000001 || $tempexpr2 < 0.0000001 || $tempexpr3 < 0.0000001} {
set currentPath [expr $currentPath+1]
}
set tempexpr [expr abs($Dstep)]
}; # end while loop
}; # end if $AnalOk !=0
if {$AnalOk != 0 } {
break
}
}; # end i
}; # end of iDmax
if {$AnalOk == 0} {
puts "\nAnalysis completed SUCCESSFULLY"
puts "Committed steps : $committedSteps\n"
} else {
puts "\nAnalysis FAILED"
puts "Committed steps : $committedSteps\n"
}
# --------------------------------------------------------------------------------------------------------------
set hour 0.0
set minute 0.0
set second 0.0
set time_end [clock seconds]
set analysisTime [expr $time_end-$time_start]
puts "Analysis finished at [clock format $time_end -format %H:%M:%S]\n"
if {$analysisTime<60} {
if {$analysisTime==0} {
puts "Analysis time : less than one second"
} elseif {$analysisTime==1} {
puts "Analysis time : 1 second"
} else {
puts "Analysis time : $analysisTime seconds"
}
} elseif {$analysisTime<3600} {
set minutes [expr $analysisTime/60]
set seconds [expr $analysisTime%60]
if {$minutes==1} {
puts -nonewline "Analysis time : 1 minute"
} else {
puts -nonewline "Analysis time : $minutes minutes"
}
if {$seconds==0} {
puts ""
} elseif {$seconds==1} {
puts " and 1 second"
} else {
puts " and $seconds seconds"
}
} else {
set hours [expr $analysisTime/3600]
set minutes [expr ($analysisTime%3600)/60]
set seconds [expr ($analysisTime%3600)%60]
if {$hours==1} {
puts -nonewline "Analysis time : 1 hour"
} else {
puts -nonewline "Analysis time : $hours hours"
}
if {$minutes==0} {
} elseif {$minute==1} {
puts -nonewline ", 1 minute"
} else {
puts -nonewline ", $minutes minutes"
}
if {$seconds==0} {
puts ""
} elseif {$second==1} {
puts " and 1 second"
} else {
puts " and $seconds seconds"
}
}
# --------------------------------------------------------------------------------------------------------------
#
# M E T A D A T A
#
# --------------------------------------------------------------------------------------------------------------
# Number of nodes
# 13
# Elements 1D
# 12
# Elements 2D
# 0
# Elements 3D
# 0
# ForceBeamColumn
# 12
# 1 2 3 4 5 6 7 8 9 10 11 12
# ----------------------------------------------------------------------------------------------------------------------------------------------------------
#
# F R A M E L O C A L A X E S O R I E N T A T I O N
#
# ----------------------------------------------------------------------------------------------------------------------------------------------------------
#
# ID Type Local-x Local-y Local-z Literal
#
# 1 forceBeamColumn {+0.00000 +0.00000 +1.00000} {+0.00000 +1.00000 -0.00000} {-1.00000 +0.00000 +0.00000} { +Z +Y -X }
# 2 forceBeamColumn {+0.00000 +0.00000 +1.00000} {+0.00000 +1.00000 -0.00000} {-1.00000 +0.00000 +0.00000} { +Z +Y -X }
# 3 forceBeamColumn {+0.00000 +0.00000 +1.00000} {+0.00000 +1.00000 -0.00000} {-1.00000 +0.00000 +0.00000} { +Z +Y -X }
# 4 forceBeamColumn {-1.00000 +0.00000 +0.00000} {+0.00000 -1.00000 +0.00000} {+0.00000 +0.00000 +1.00000} { -X -Y +Z }
# 5 forceBeamColumn {-1.00000 +0.00000 +0.00000} {+0.00000 -1.00000 +0.00000} {+0.00000 +0.00000 +1.00000} { -X -Y +Z }
# 6 forceBeamColumn {-1.00000 +0.00000 +0.00000} {+0.00000 -1.00000 +0.00000} {+0.00000 +0.00000 +1.00000} { -X -Y +Z }
# 7 forceBeamColumn {-1.00000 +0.00000 +0.00000} {+0.00000 -1.00000 +0.00000} {+0.00000 +0.00000 +1.00000} { -X -Y +Z }
# 8 forceBeamColumn {-1.00000 +0.00000 +0.00000} {+0.00000 -1.00000 +0.00000} {+0.00000 +0.00000 +1.00000} { -X -Y +Z }
# 9 forceBeamColumn {-1.00000 +0.00000 +0.00000} {+0.00000 -1.00000 +0.00000} {+0.00000 +0.00000 +1.00000} { -X -Y +Z }
# 10 forceBeamColumn {+0.00000 +0.00000 -1.00000} {-0.00000 -1.00000 -0.00000} {-1.00000 +0.00000 +0.00000} { -Z -Y -X }
# 11 forceBeamColumn {+0.00000 +0.00000 -1.00000} {-0.00000 -1.00000 -0.00000} {-1.00000 +0.00000 +0.00000} { -Z -Y -X }
# 12 forceBeamColumn {+0.00000 +0.00000 -1.00000} {-0.00000 -1.00000 -0.00000} {-1.00000 +0.00000 +0.00000} { -Z -Y -X }
Question about ForceBeamColumn
Moderators: silvia, selimgunay, Moderators
Re: Question about ForceBeamColumn
I don find the .log and don't understand the problem, could you please detail?
Francesco Buffa
Mechanical Engineer
Corso Monte Grappa
10145 Torino
Italy
Mechanical Engineer
Corso Monte Grappa
10145 Torino
Italy