SmartAnalyze

class opstool.anlys.SmartAnalyze(analysis_type='Transient', **kargs)

Bases: object

The SmartAnalyze is a class to provide OpenSeesPy users an easier way to conduct analyses. Original Tcl version Author: Dr. Dong Hanlin, see here. Here’s the converted python version, with some modifications.

Parameters

analysis_type: str, default=”Transient”

Assign the analysis type, “Transient” or “Static”.

Other Parameters that control convergence

TEST RELATED:

testType: str, default=”EnergyIncr”

Identical to the testType in OpenSees test command. Choices see test command

testTol: float, default=1.0e-10

The initial test tolerance set to the OpenSees test command. If tryLooseTestTol is set to True, the test tolerance can be loosened.

testIterTimes: int, default=10

The initial number of test iteration times. If tryAddTestTimes is set to True, the number of test times can be enlarged.

testPrintFlag: int, default=0

The test print flag in OpenSees test command.

tryAddTestTimes: bool, default=False

If True, the number of test times will be enlarged if the last test norm is smaller than normTol, the enlarged number is specified in testIterTimesMore. Otherwise, the number of test times will always be equal to testIterTimes.

normTol: float, default=1.e3

Only useful when tryAddTestTimes is True. If unconverged, the last norm of test will be compared to normTol. If the norm is smaller, the number of test times will be enlarged.

testIterTimesMore: int, default=50

Only useful when tryaddTestTimes is True. If unconverge and norm are ok, the test iteration times will be set to this number.

tryLooseTestTol: bool, default=False

If this is set to True, if unconverge at a minimum step, the test tolerance will be loosened to the number specified by looseTestTolTo. The step will be set back.

looseTestTolTo: float, default= 100 * initial test tolerance

Only useful if tryLooseTestTol is True. If unconvergance at the min step, the test tolerance will be set to this value.

ALGORITHM RELATED:

tryAlterAlgoTypes: bool, default=False

If True, different algorithm types specified in algoTypes will be tried during unconvergance. If False, the first algorithm type specified in algoTypes will be used.

algoTypes: list[int], default=[40, 10, 20, 30, 50, 60, 70, 90]

A list of flags of the algorithms to be used during unconvergance. The integer flag is documented in the following section. Only useful when tryAlterAlgoTypes is True. The first flag will be used by default when tryAlterAlgoTypes is False. The algorithm command in the model will be ignored. If you need another algorithm, try a user-defined algorithm. See the following section.

UserAlgoArgs: list,

User-defined algorithm parameters, 100 is required in algoTypes, and the parameters must be included in the list, for example: algoTypes = [10, 20, 100], UserAlgoArgs = [“KrylovNewton”, “-iterate”, “initial”, “-maxDim”, 20]

Algorithm type flag reference

• 0: Linear

• 1: Linear -initial

• 2: Linear -secant

• 3: Linear -factorOnce

• 4: Linear -initial -factorOnce

• 5: Linear -secant -factorOnce

• 10: Newton

• 11: Newton -initial

• 12: Newton -initialThenCurrent

• 13: Newton -Secant

• 20: NewtonLineSearch

• 21: NewtonLineSearch -type Bisection

• 22: NewtonLineSearch -type Secant

• 23: NewtonLineSearch -type RegulaFalsi

• 24: NewtonLineSearch -type LinearInterpolated

• 25: NewtonLineSearch -type InitialInterpolated

• 30: ModifiedNewton

• 31: ModifiedNewton -initial

• 32: ModifiedNewton -secant

• 40: KrylovNewton

• 41: KrylovNewton -iterate initial

• 42: KrylovNewton -increment initial

• 43: KrylovNewton -iterate initial -increment initial

• 44: KrylovNewton -maxDim 10

• 45: KrylovNewton -iterate initial -increment initial -maxDim 10

• 50: SecantNewton

• 51: SecantNewton -iterate initial

• 52: SecantNewton -increment initial

• 53: SecantNewton -iterate initial -increment initial

• 60: BFGS

• 61: BFGS -initial

• 62: BFGS -secant

• 70: Broyden

• 71: Broyden -initial

• 72: Broyden -secant

• 80: PeriodicNewton

• 81: PeriodicNewton -maxDim 10

• 90: ExpressNewton

• 91: ExpressNewton -InitialTangent

• 100: User-defined0

STEP SIZE RELATED:

initialStep: float, default=None

Specifying the initial Step length to conduct analysis. If None, equal to dt.

relaxation: float, between 0 and 1, default=0.5

A factor that is multiplied by each time the step length is shortened.

minStep: float, default=1.e-6

The step tolerance when shortening the step length. If step length is smaller than minStep, special ways to converge the model will be used according to try- flags.

LOGGING RELATED:

printPer: int, default=50

Print to the console every several trials.

debugMode: bool, default=False

Print as much information as possible.

Examples

The following example demonstrates how to use the SmartAnalyze class.

Note

test() and algorithm() will run automatically in SmartAnalyze, but commands such as integrator() must be defined outside SmartAnalyze.

Example 1: Basic usage for Transient

>>> import opstool as opst
>>> ops.constraints('Transformation')
>>> ops.numberer('Plain')
>>> ops.system('BandGeneral')
>>> ops.integrator('Newmark', 0.5, 0.25)
>>> analysis = opst.anlys.SmartAnalyze(analysis_type="Transient")
>>> npts, dt = 1000, 0.01
>>> segs = analysis.transient_split(npts)
>>> for seg in segs:
>>>     analysis.TransientAnalyze(dt)

Example 2: Basic usage for Static

>>> import opstool as opst
>>> ops.constraints('Transformation')
>>> ops.numberer('Plain')
>>> ops.system('BandGeneral')
>>> protocol=[1, -1, 1, -1, 0]
>>> analysis = opst.anlys.SmartAnalyze(analysis_type="Static")
>>> segs = analysis.static_split(protocol, 0.01)
>>> print(segs)
>>> for seg in segs:
>>>     analysis.StaticAnalyze(node=1, dof=2, seg=seg)  # node tag 1, dof 2

Example 3: change control parameters

>>> analysis = opst.anlys.SmartAnalyze(
>>>   analysis_type="Transient",
>>>   algoTypes=[40, 30, 20],
>>>   printPer=20,
>>>   tryAlterAlgoTypes=True,
>>>)

Methods

StaticAnalyze	Single step static analysis and applies to displacement control only.
TransientAnalyze	Single Step Transient Analysis.
set_sensitivity_algorithm	Set analysis sensitivity algorithm.
static_split	Returns a sequence of substeps for static analysis, for use in outer analysis loops.
transient_split	Step Segmentation for Transient Analysis.

transient_split(npts)

Step Segmentation for Transient Analysis. The main purpose of this function is to tell the program the total number of analysis steps to show progress. However, this is not necessary.

Parameters

nptsint

Total steps for transient analysis.

Returns

A list to loop.

static_split(targets, maxStep=None)

Returns a sequence of substeps for static analysis, for use in outer analysis loops. It is not necessary to use this method if you already have a load sequence.

Parameters

targets: Union[list, tuple, numpy.ndarray]

A list of target displacements, the first element must be positive.

maxStep: float, default=None

The maximum step size in the displacement control. If None, targets[1] - targets[0].

Returns

segs: list

A sequence of substeps for static analysis.

set_sensitivity_algorithm(algorithm='-computeAtEachStep')

Set analysis sensitivity algorithm. Since the Smart Static Analysis may reset the integrator, the sensitivity analysis algorithm will need to be reset afterwards.

Parameters

algorithm: Sensitivity analysis algorithm, default: “-computeAtEachStep”.

Optional: “-computeAtEachStep” or “-computeByCommand”.

Return

None

TransientAnalyze(dt, print_info=True)

Single Step Transient Analysis.

Parameters

dtfloat

Time Step.

print_info: bool, default=True

If True, print info.

Returns

Return 0 if successful, otherwise returns a negative number.

StaticAnalyze(node, dof, seg, print_info=True)

Single step static analysis and applies to displacement control only.

Parameters

nodeint

The node tag in the displacement control.

dofint

The dof in the displacement control.

segfloat

Each load step, i.e., each element returned by static_split.

print_info: bool, default=True

If True, print info.

Returns

Return 0 if successful, otherwise returns a negative number.