
Now we’re ready to convert the OpenSeesPy code in our Jupyter Notebook over to our `analyseStructure()` function. You can download the Jupyter Notebook for reference from [the original tutorial](/posts/introduction-to-opensees-and-openseespy) - although you don’t strictly need it to code along with this project.

<Callout type="success" heading="New to OpenSeesPy?">
	If you’re not familiar with OpenSeesPy, it would be a good idea to take a short
	detour over to my tutorial, *[An Introduction to OpenSees and OpenSeesPy for 2D
	Truss Analysis](/posts/introduction-to-opensees-and-openseespy)* to cover the
	basics before continuing here.
</Callout>

## 6.1 Building the analysis function

Our `analyseStructure()` function will take the following input arguments:

- Young’s modulus, `E`, provided by the user.
- The element cross-sectional area, `A`, provided by the user.
- The `nodes` and `members` arrays, generated by the `processGeometryFile()` function we defined in the previous lecture.
- The `restraints` array generated by `computeRestraintArray()`, defined in the previous lecture
- The `forces` array, generated by `computeForceArray()`, also defined in the previous lecture.

It will return the following arrays:

- `mbr_disp` will contain the x and y displacements at each end of each member - this will be useful when building our deflected shape plot.
- `mbr_forces` will contain the axial force in each member.
- `node_disp` will contain the x and y displacements of each node - this duplicates the information contained in `mbr_disp` but this format is different and will be convenient for later use.
- `reactions` contains the x and y components of the reaction force at the restrained nodes.

Now, all we need to do is fill in the bit in the middle! This ends up being pretty easy because we have so much of the prep work done :) We can more or less just copy across the OpenSeesPy commands; in summary the flow of operations is as follows:

- Initialise the OpenSeesPy model
- Define the nodes for the structure
- Define an appropriate material
- Define the elements
- Define the boundary conditions
- Setup a basic time-series and load pattern
- Apply the loads
- Run the analysis

All of the steps above just use standard OpenSeesPy commands so I won’t labour them too much, remember, I have a full intro tutorial if you need it.

Our function, at this stage, looks like the following:

#### `analysis.py`

```python
#Perform the analysis

def analyseStructure(E, A, nodes, members, restraints, forces):

	E = E*10**9 #Convert from GPa (supplied nby user) to N/m^2

	## INITIALISATION====================
	ops.wipe() # Remove any existing model
	ops.model('basic', '-ndm', 2, '-ndf', 2)

	## STRUCTURE DEFINITION==============
	# Define nodes
	for i, n in enumerate(nodes):
		ops.node(i+1, float(n[0]), float(n[1]))

	# Define uniaxial material (Elastic matID E)
	ops.uniaxialMaterial("Elastic", 1, E)

	# Define elements
	for i, mbr in enumerate(members):
		ops.element("Truss", i+1, int(mbr[0]), int(mbr[1]), A, 1)

	# Define boundary conditions
	for r in restraints:
		ops.fix(int(r[0]),int(r[1]),int(r[2]))

	## LOAD DEFINITION====================
	ops.timeSeries("Constant", 1) # Create TimeSeries with a tag of 1
	ops.pattern("Plain", 1, 1)

	# Create the nodal load - command: load nodeID xForce yForce
	for f in forces:
		ops.load(int(f[0]), float(f[1]), float(f[2]))

	## ANALYSIS============================
	ops.system("BandSPD") # create SOE
	ops.numberer("RCM") # create DOF number
	ops.constraints("Plain") # create constraint handler
	ops.integrator("LoadControl", 1.0) # create integrator
	ops.algorithm("Linear") # create algorithm
	ops.analysis("Static") # create analysis object
	ops.analyze(1) # perform the analysis

	## EXTRACT RESULTS=====================
	#...
	#...
	#...

```

Within this function, we still need to extract the results and package them for return. This is handled in a fairly standard way by appending values into lists in much the same manner we’ve seen already. Member displacements are extracted as follows:

#### `analysis.py`

```python
def analyseStructure(E, A, nodes, members, restraints, forces):
	#...
	#...
	#...

	# Member displacements
	mbr_disp = []
	for mbr in members:
		node_i = int(mbr[0]) #Node number for node i of this member
		node_j = int(mbr[1]) #Node number for node j of this member

		ux_i = ops.nodeDisp(node_i, 1) #Horizontal nodal displacement
		uy_i = ops.nodeDisp(node_i, 2) #Vertical nodal displacement
		ux_j = ops.nodeDisp(node_j, 1) #Horizontal nodal displacement
		uy_j = ops.nodeDisp(node_j, 2) #Vertical nodal displacement

		# Append the displacements for this member to the list
		mbr_disp.append([ux_i, uy_i, ux_j, uy_j])
```

Member forces are identified for each member, converted to kN, rounded to 2 decimal places and appended to the `mbr_forces` array as follows:

#### `analysis.py`

```python
def analyseStructure(E, A, nodes, members, restraints, forces):
	#...
	#...
	#...

	# Member forces
	mbr_forces = []
	for i, mbr in enumerate(members):
		mbr_forces.append(round(ops.basicForce(i+1)[0]/1000,2))
```

Nodal displacements are next,

#### `analysis.py`

```python
def analyseStructure(E, A, nodes, members, restraints, forces):
	#...
	#...
	#...

	#Nodal displacements
	node_disp = []
	for i, n in enumerate(nodes):
		ux = round(ops.nodeDisp(i+1, 1),5) #Horizontal nodal displacement
		uy = round(ops.nodeDisp(i+1, 2),5) #Vertical nodal displacement
		node_disp.append([ux, uy])
```

And finally, we process the reactions. Note that the code block below also includes the function’s `return` statement and so it completes our `analyseStructure()` function.

#### `analysis.py`

```python
def analyseStructure(E, A, nodes, members, restraints, forces):
	#...
	#...
	#...

	#Reactions
	reactions = []
	ops.reactions() #Calculate reactions
	for i, r in enumerate(restraints):
		R = ops.nodeReaction(int(r[0]))
		Rx = round(R[0]/1000,2)
		Ry = round(R[1]/1000,2)
		reactions.append([r[0], Rx, Ry])

	return mbr_disp, mbr_forces, node_disp, reactions
```

## 6.2 Reporting results to the user

<Callout type="warning" heading="Showing results to the user">
When building a VIKTOR app, we can generate a range of different visualisation types, e.g. `DataView` and `ImageView` are the two we’ll use in this project but there are many other options.

To generate these visualisations, we import the required entity from `viktor.views` and define it as a decorator to the function that will actually produce the visualisation.

So, for example, we’re going to produce a collapsable table of results that will show nodal displacements, member forces and reactions. To do this, we define a `DataView` decorator and then define a function below it - we’ll call ours `createResultsData()`. This function will crunch the numbers, compile the data we want to show and then return a `DataResult()`, which is what the end user will see - here’s the basic structure:

```python
@DataView("Results Data", duration_guess=1)
def createResultsData(self, params, **kwargs):
	#…code to generate the data
	#…
	#…
	#…
	return DataResult(…data to visualise)
```

We’ll follow a very similar process each time we want to generate a new visualisation.

</Callout>

We’ll start by importing the required elements at the top of `app.py`:

#### `app.py`

```python
from viktor.views import DataGroup, DataItem, DataResult, DataView
```

Note that `DataItem` `DataGroup` will be used as building blocks for `DataResult`. Next, we define the decorator and associated function within the `Controller()` class and initialise three empty lists to store our data.

#### `app.py`

```python
@DataView("Results Data", duration_guess=1)
def createResultsData(self, params, **kwargs):
	data_items_disp = []
	data_items_force = []
	data_items_reactions = []

	#...
	#...
	#...
```

Next, we need to call the functions that process the user data and also execute the structural analysis. But, before we do this, we want to put some checks in place to make sure that we only try to execute this workflow if:

- Some geometry has been uploaded
- At least two supports have been defined
- None of the restraints that have been specified are just empty table rows

Without these checks, our app will try and run without sufficient data and will return an error. We can add these checks into our function next:

#### `app.py`

```python
@DataView("Results Data", duration_guess=1)
def createResultsData(self, params, **kwargs):
	data_items_disp = []
	data_items_force = []
	data_items_reactions = []

	#Only attempt workflow if geometry uploaded and at least two supports defined
	if params.tab_2.section_2.geometry_file and len(params.tab_2.section_3.table_restraints)>1:

		#Make sure there are no 'None' restraint values
		if all(item.col_2 is not None for item in params.tab_2.section_3.table_restraints):

			#...
			#...
			#...
```

If we’ve made it past these checks, we can call the various processing functions we’ve written over the past two lectures:

- `processGeometryFile()` to get the `nodes` and `members` arrays
- `computeRestraintArray()` to get the `restraints` array
- `computeForceArray()` to get the `forces` array

These arrays can then be passed as arguments into `analyseStructure()` along with the Youngs modulus and cross-sectional area stored in the `Parametrization()`. Our function should now look like this:

#### `app.py`

```python
@DataView("Results Data", duration_guess=1)
def createResultsData(self, params, **kwargs):
	data_items_disp = []
	data_items_force = []
	data_items_reactions = []

	#Only attempt workflow if geometry uploaded and at least two supports defined
	if params.tab_2.section_2.geometry_file and len(params.tab_2.section_3.table_restraints)>1:

		#Make sure there are no 'None' restraint values
		if all(item.col_2 is not None for item in params.tab_2.section_3.table_restraints):
			nodes, members = processGeometryFile(params.tab_2.section_2.geometry_file)
			restraints = computeRestraintArray(params.tab_2.section_3.table_restraints)
			forces = computeForceArray(params.tab_2.section_4.table_loads)
			mbr_disp, mbr_forces, node_disp, reactions = analyseStructure(params.tab_2.section_1.E, params.tab_2.section_1.A, nodes, members, restraints, forces)

			#...
			#...
			#...
return
```

Your code should now be running and solving your structure - but you won’t yet be seeing anything in your app’s UI. This is because we haven’t compiled the results and returned a `DataResult()` from the function yet.

## 6.3 Compiling the results

We now need to build a `DataItem()` for each individual result and collect these into a list (the empty lists we defined at the start of the function).

We then pass this list to another `DataItem()` as a subgroup. This generates a `DataItem()` subgroup for displacements, member forces and reactions.

These DataItem subgroups are collected into a `DataGroup()`, which is then passed as the argument to the `DataResult`, which is what must be returned from the `createResultsData()` function.

This is an example of something that’s easier to understand when you see it in code!! I’ll show the full function below, but focus your attention on what happens after we call `analyseStructure()`.

#### `app.py`

```python
@DataView("Results Data", duration_guess=1)
def createResultsData(self, params, **kwargs):
	data_items_disp = []
	data_items_force = []
	data_items_reactions = []

	#Only attempt workflow if geometry uploaded and at least two supports defined
	if params.tab_2.section_2.geometry_file and len(params.tab_2.section_3.table_restraints)>1:

		#Make sure there are no 'None' restraint values
		if all(item.col_2 is not None for item in params.tab_2.section_3.table_restraints):
			nodes, members = processGeometryFile(params.tab_2.section_2.geometry_file)
			restraints = computeRestraintArray(params.tab_2.section_3.table_restraints)
			forces = computeForceArray(params.tab_2.section_4.table_loads)
			mbr_disp, mbr_forces, node_disp, reactions = analyseStructure(params.tab_2.section_1.E, params.tab_2.section_1.A, nodes, members, restraints, forces)

			for i, d in enumerate(node_disp):
				resultString = f"Ux: {d[0]} mm, Uy: {d[1]} mm"
				data_items_disp.append(DataItem(f'Node {i+1}', resultString))

			for i, mbr in enumerate(members):
				resultString = f'{mbr_forces[i]} kN'
				data_items_force.append(DataItem(f'Member {i+1} (nodes {mbr[0]} to {mbr[1]})', resultString))

			for i, r in enumerate(reactions):
				resultString = f'Rx: {r[1]} kN, Ry: {r[2]} kN'
				data_items_reactions.append(DataItem(f'Node {r[0]}', resultString))

	data_group = DataGroup(
		DataItem('Displacement','', subgroup=DataGroup(*data_items_disp)),
		DataItem('Member Forces','', subgroup=DataGroup(*data_items_force)),
		DataItem('Reactions','', subgroup=DataGroup(*data_items_reactions))
	)

	return DataResult(data_group)
```

At this point, your app should be capable of solving a structure and showing the analysis results to the user, Fig. 1.

<Image
	src="/images/courses/using-viktor-to-build-a-shareable-truss-calculator-app/converting-our-openseespy-script/img1.png"
	alt="Results visible to the user in the right-hand side of the app UI. | EngineeringSkills.com"
	width="1200"
	height="675"
	caption="Fig 1. Results visible to the user in the right-hand side of the app UI."
/>

In the next lecture, we’ll continue to improve the user experience by generating some plots of the structure and its response to the loading.


Please log in to continue