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 or list, 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

Algorithm type flag reference

Flags	Algorithm
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:

debugMode: bool, default=False

If True, print as much information as possible. If False, the progress bar will be used. If False, a log file named ‘.SmartAnalyze-OpenSees.log’ will be generated to store the information printed by OpenSees.

printPer: int, default=50

Print to the console every several trials. This is only useful when debugMode = True.

Examples

The following example demonstrates how to use the SmartAnalyze class.

Note

• test() and algorithm() will run automatically in SmartAnalyze;

• Static analysis only supports displacement control;

• Commands such as integrator() must be defined outside SmartAnalyze for ransient analysis.

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)  # Dynamic analysis requires external settings
>>> analysis = opst.anlys.SmartAnalyze(analysis_type="Transient")
>>> npts, dt = 1000, 0.01
>>> # Tells the program the total number of steps, which is necessary for outputting a progress bar
>>> segs = analysis.transient_split(npts)
>>> for _ 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=[0.5, -0.5, 1, -1, 0]  # Load Profile
>>> analysis = opst.anlys.SmartAnalyze(analysis_type="Static")
>>> segs = analysis.static_split(protocol, 0.01)  # Use a step size of 0.01 to segment the profile.
>>> 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",
>>>    tryAlterAlgoTypes=True,
>>>    algoTypes=[40, 30, 20],
>>>    tryAddTestTimes=True,
>>>    testIterTimesMore=[50, 100],
>>>    relaxation=0.5,
>>>    minStep=1e-5,
>>>    printPer=20,
>>>)

Methods

StaticAnalyze	Single step static analysis and applies to displacement control only.
TransientAnalyze	Single Step Transient Analysis.
close	Close the class.
set_sensitivity_algorithm	Set analysis sensitivity algorithm.
static_split	Returns a sequence of substeps for static analysis.
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.

Parameters

targetslist, tuple, or np.ndarray

Target displacements. First element should be ≥ 0.

maxStepfloat, optional

Maximum step size. If None, uses difference between first two targets.

Returns

segslist of float

Sequence of substeps to reach each target displacement.

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)

Single Step Transient Analysis.

Parameters

dtfloat

Time Step.

Returns

Return 0 if successful, otherwise returns a negative number.

StaticAnalyze(node, dof, seg)

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.

Returns

Return 0 if successful, otherwise returns a negative number.

close()

Close the class.

Returns:

None