Additional Information
See the adjacent Software Information
links for general details regarding LUSAS software products and
options.
LUSAS Programmable Interface
The LUSAS Programmable Interface
(LPI) allows the customisation and automation of modelling and results
processing tasks and creation of user-defined menu items, dialogs and
toolbars as a means to access those user-defined resources. It can
also be used for transferring data between LUSAS and other software
applications, and to control other programs from within LUSAS Modeller,
or control LUSAS Modeller from other programs.
With LUSAS
LPI, any user can automate the creation of complete structures, either
in LUSAS or from third-party software, carrying out design checks,
optimising members and outputting graphs, spreadsheets of results and
custom reports. Because everything carried out by a user is recorded
in a LUSAS Modeller session file, anything that LUSAS can do can also
be controlled by another application via the LUSAS Programmable
Interface. This means that you can view and edit a recorded session,
parameterise those commands, turn them into sub-routines, add loops
and other functions to the scripts and create utilities, or a totally different
application or program - using the proven core technology of LUSAS.
LPI
languages and uses
By using any ActiveX compliant scripting language, such as VB.Net, C#, VBScript, C++, Python, Perl, JScript etc.
to access LUSAS facilities and functionality, you can:
- Create user-defined menu items, dialogs and toolbars
- Interrogate all aspects of a LUSAS model
- Customise modelling operations
- Create parameterised models
- Automate repetitive
tasks
- Import CAD geometry and properties
- Make direct links to Microsoft Word / Excel, or other programs for import or export of data
- Perform simple / codified design checks, and when used with automated iterative analysis, optimise structural member sizes and configurations, slab reinforcement quanties, etc.
- Control other programs from
LUSAS, and control LUSAS from other programs
LUSAS script files
In their simplest form
script files are used to store a sequence of LUSAS commands for later
playback. Some examples of use include the creation of start-up
templates to pre-load the Attributes Treeview of the LUSAS Modeller
user interface with selected attributes for a particular analysis; the
setting of default mesh or material types, or preferred colour
schemes; or defining specific model orientations for use when saving
model views for use in reports.
When LUSAS is run, a
session file is created recording each step of the model generation in
Visual Basic Script (.VBS) - one of the most commonly used and easily
understood languages. Editing of a session file can be used to define
a similar model with new parameters. When the script is re-run in
LUSAS, a new user-defined model can be easily and rapidly generated
from the parameters defined. A Macro Recorder facility in LUSAS also
provides the means to record a sub-set of commands for a task, for
saving and re-use. User-generated scripts can be controlled by
creating dialogs that may include parametric variables, check boxes,
drop-downs etc.
Varied uses of scripts
include reading of geometric data, such as column dimensions, section
properties and span lengths / storey heights etc., from a spreadsheet
to automatically build multi-span bridge or building models; rapid
generation of parametrically-idealised wind farm base structures, or
for automating the creation of numerous load combinations and
envelopes; and for slicing through a model to create results for
multiple loadcases, which can be automatically plotted on graphs and
in reports.
A set of example
scripts are provided in LUSAS to assist in the understanding of
standard concepts including file handling, how to access LUSAS
geometry / attribute data, and how to import / export data from / to
Microsoft Word or Excel, or other programs.
Visual Basic, as well
as JScript, Python and Perl are known as interpreted languages -
meaning that there is no need for compilers to be used.
Component technology
| The
LUSAS Programmable Interface allows interfacing with other
compatible Windows programs through a Component Object Model
(COM) interface. This defines a set of rules by which two
programs can communicate and allows controlling those programs
as if they were part of LUSAS Modeller. LUSAS can also be used
as a component of another system (running transparently if
required) providing modelling capabilities, analysis solutions
and results viewing and processing options for that
application.
Examples
include controlling external programs for inputting data into
LUSAS, such as importing CAD geometry and properties for data
sharing, as well as for exporting data for post-processing
uses, such as exporting results into cells in a spreadsheet
for additional calculations to be carried out. Typical uses of
LUSAS as a component of another system include using LUSAS as
a part of an automated BIM design system to allow customised
design checks to be made within LUSAS before saving selected
model / results data in a BIM platform, such as REVIT or
Bentley. |
LUSAS being used
to provide results for a third-party application. |
This more advanced
customisation and use of LUSAS can make use of VB.NET, which (along
with C# and C++ languages) requires compiling before use. However, the
main benefit of using these languages over interpreted languages, such
as VB Scripting, is that they are more powerful and provide standard
plug-ins, controls and libraries of subroutines - avoiding the need to
write them in-house.
Programmable Interface Architecture
LUSAS provides a .NET
project template (also known as a plug-in), which can be customised by
users to ‘interrogate’ LUSAS Modeller. This allows the exchange of
design report data with particular Microsoft applications; the
exchange of geometry design and results data with BIM platform
software; and exchange of FE related and any customised data with
third-party software applications.
Overall, LUSAS provides
a rich programmable interface, with hundreds of programming interfaces
(each having associated subroutines) that provide an LPI user with
total control over all aspects of a LUSAS model - and not just for the
attribute and geometric data. As an example, it is possible to use the
interfaces to query a model and extract element results, perform
design code-related calculations, and then either export those results
into a spreadsheet format, or to make them available within LUSAS
Modeller to enable contouring of those results using standard results
processing and viewing facilities.
LUSAS Material Model
Interface
In addition to the
accessing and customising LUSAS Modeller via the LUSAS Programmable
Interface, user-defined material models (written in Fortran) can be
compiled and built into a customised LUSAS Solver executable by using
the LUSAS Material Model Interface (LUSAS MMI).
Case study: Optimised steel dome
modelling
FEA Korea wrote VB scripts to
automatically model and optimise the members in a chosen steelwork
dome arrangement on behalf of its client, Samsung Engineering and
Construction. Roof types supported by the software wizard included a
flat truss roof, a vaulted roof, and also circular, oblate, and
elliptical domes.
Span lengths and dimensional data are
user-defined for a chosen roof type. A preliminary LUSAS analysis is
used to assign initial section properties for each member based upon a
specified initial stress ratio. Optimisation target parameters are
then defined. From user-defined values, loadings appropriate to the
chosen design code are created and applied automatically to the
relevant parts of the model. A stress check and a displacement check
then take place to see if member sizes need to be increased from their
initial sizes, prior to saving the resulting member sizes as a
possible set for use. An iterative procedure than checks to see if any
members can be reduced in size before saving a set of minimum member
sizes as an optimum result.
For serviceability checks a model is
automatically converted into one with elements suitable for either an
eigen buckling analysis where buckling checks can be carried out for
distributed, concentrated or user-defined loadings, or for one
suitable for either a material, geometric, or material and geometric
nonlinear analysis. Graphs, diagram plots, and reporting can be output
for code-checked results, deflections, connections and many other
results quantities.
Other case studies
Other case studies on which LUSAS
scripting has been used to carry out automation and customisation
include:
Associated webinar
Back to Top
|
|
Software Information
|
