Each load case applied to a structural model is contained by the LoadCases collection stored within the Frame object.  This collection is referenced via the LoadCases property of the Frame object.  Alternatively, this collection can be accessed directly from the Multiframe Application object via its LoadCases property.  The properties and method of the LoadCase object are summarised in the table below.

The Application, Frame, Index and Index properties in addition to the Delete method are common to many objects and are described in Chapter 2.

Load cases are categorized as static, combined or self-weight.  While each of these is defined by slightly different information, the LoadCase object is used to describe all three types of cases.  The type of a load case is defined when it is created and cannot be changed.  If the user accesses a property of the LoadCase object that is not relevant to the type of the load case, an error will be returned.

Each LoadCase object in this collection stores all the loads applied to the frame by that load case.  These loads are contained within one of four collections that store the joint loads, prescribed displacements, elements loads or thermal loads.

The name of a load case is referenced via the Name property of the LoadCase object that stores the name of the load case as a string.

The type of a particular load case can be determined from the Type property of the LoadCase object.  This property is an enumerated value of type mfLoadCaseType with values of mflcStatic, mflcSelfWeight and mflcCombined.  Each of the different load case types are described below.  As noted above, this is a read only property as the type of load case cannot be changed from that allocated when the load case was created.

The ElementLoads, NodeLoads, PrescribedDisps and ThermalLoads properties provide access to the collections storing the applied loads.  The use and content of these collections is dependent upon the type of the load cases.  This is described in subsequent sections of the chapter.

A static load case is created by adding a load case to the LoadCases collection using the AddCase method of this collection.  When adding the load case it must be specified as a load case of type mflcStatic.  For example,

Dim myCase as Multiframe.LoadCase

Set myCase = MyFrame.Loadcases.AddCase(mflcStatic,”Live Load”)

As both of the parameters are optional, and the default type of load case is static, this code could have been replace by

Dim myCase as Multiframe.LoadCase

Set myCase = MyFrame.Loadcases.AddCase()
myLoadCase.Name = “Live Load”

All of the loads forming part of this load case are stored in the NodeLoads, NodePreDisps, ElementLoads and ThermalLoads collections.  Loads may be added or removed from this load case by adding or deleting loads in the appropriate collection.  Examples of adding each of the different loads are provided subsequent sections of this chapter.

Adding a new load case of type mflcSelfWeight to the LoadCases collection creates a self-weight load case.

Dim myCase as Multiframe.LoadCase

Set myCase = myFrame.Loadcases.AddCase(mflcSelfWeight,”Self Weight”)

A self-weight load cases is defined by the accelerations applied in each of the global directions.  These values may be accessed via either the Acceleration or Accelerations properties.  The Acceleration property takes a single parameter identifying the global direction and provides access to each of the individual components.  For example

Dim accel as Double

‘Setting accelerations
myLoadCase.Acceleration(1) = 0.0              ‘Set x-component
myLoadCase.Acceleration(mfDOFy) = 0.0  ‘Set x-component
 
’ Accessing loadcase factors
accel = myLoadCase.Acceleration(3)     ‘Get z-component

Alternatively the accelerations may be accessed via the Accelerations property which is a variant property containing an array of 3 doubles, each value representing a component of the acceleration.

Dim myAccels as Variant

’Set components of acceleration
myFrame.LoadCases(4).Accelerations = Array(0.0,-9.81,0.0) 

’Get acceleration components
myAccels = myFrame.LoadCases(4).Accelerations

The ElementLoads collection of a self-weight load case contains the distributed loads representing the self-weight of each element in the frame to which the self-weight is applied.  This collection is managed by the Multiframe application and is automatically updated as the structure is changed.  As such, loads cannot be added or removed from this collection.  In fact, no loads may be added to the other loading collections in this type of load case and these will always remain empty.

Adding a new LoadCase object of type mflcCombined to the LoadCases collection creates a combined or factored load case.

Dim myLoadCase as Multiframe.LoadCase

Set myLoadCase = MyFrame.Loadcases.AddCase(mflcCombined,”DL + LL”)

The factors for each of the static or self-weight load cases that are combined to define this load case are specified using the Factor property of the LoadCase object.  This property takes a single variant parameter that identifies the load case to which the factor is to be applied.  This variant may be either the index of the load case, the name of the load case or even another LoadCase object as demonstrated below

Dim factor as Double

’ Setting loadcase factors
myLoadCase.Factor(2) = 0.8                                 ‘By index
myLoadCase.Factor(“Live Load”) = 1.5          ‘By name
myLoadCase.Factor(myFrame.LoadCases(2)) = 1.5 ‘By LoadCase object

’ Accessing loadcase factors
factor = myLoadCase.Factor(2)                              ‘ By index
factor = myLoadCase.Factor(“Live Load”)                    ‘ By name
factor = myLoadCase.Factor(myFrame.LoadCases(2))    ‘ By object

The load case factors may also be accessed via the Factors property of the LoadCase object.  This variant property returns an array of values representing the factors applied to each load case contained within the frame.  For example;

Dim myFactors as Variant

myFactors = myFrame.LoadCases(4).Factors            ‘Get factors
myFrame.LoadCases(4).Factors = Array(1.0,1.0,1.5)   ‘Set factors

The NodeLoads, NodePreDisps, ElementLoads and ThermalLoads collections of a combined load case contain the factored loads from each of the load cases contributing to the combined case.  These collections are maintained by the Multiframe application with loads been automatically updated when loading in one of the base load cases is changed.  As such, loads cannot be added or removed from these collections.