
Now that the user is able to upload a geometry file and indicate how the structure should be both restrained and loaded, we need to convert this data into a format that our OpenSeesPy analysis code will understand. We’ve defined three scripts in our `dataIO.py` to handle this processing,

- `processGeometryFile()`
- `computeRestraintArray()`
- `computeForceArray()`

In this lecture, we’ll complete these functions.

## 5.1 Parsing the geometry file

Let’s focus on the `processGeometryFile()` function in `dataIO.py`. We’ll think about where and when it gets called, once we’ve understood what the function actually does.

In summary, this function will read the uploaded geometry file (passed as the argument called `input` to the function), line-by-line. If the current line is defining a nodal position, we’ll add the coordinates contained in that line to a `nodes` list.

If the current line is a member definition (defined by the node numbers at each end of the member), we’ll add those node numbers to a `members` list. Once we’ve processed all lines in the file, we’ll convert the `nodes` and `members` lists to NumPy arrays and return them at the end of the function (returning them back to wherever the function was called from).

Here is the complete function:

#### `dataIO.py`

```python
#Convert contents of user geometry file to ndarrays
def processGeometryFile(input):
	#Initialise containers
	nodes = []
	members = []

	#Initialise flags to indicate which type of line we're reading
	reading_nodes = False
	reading_members = False

	#Open file
	with input.file.open(encoding='utf-8') as file:
		#Process line-by-line
		for line in file:
			line = line.strip()

			#Check what type of line we're parsing and update flags
			if "NODES" in line:
				reading_nodes = True
				reading_members = False
				continue
			elif "MEMBERS" in line:
				reading_nodes = False
				reading_members = True
				continue

			# Create node if line is a node definition and append to nodes list
			if reading_nodes and line:
				parts = line.split(',')
				if len(parts) == 2: # Ensure there are exactly two elements
					x, y = map(int, parts)
					nodes.append([x, y])

			# Create member if line is a member definition and append to members list
			if reading_members and line:
				parts = line.split(',')
				if len(parts) == 2: # Ensure there are exactly two elements
					node_i, node_j = map(int, parts)
					members.append([node_i, node_j])

	return np.array(nodes), np.array(members)
```

Again, for now, let’s not worry about anything outside the scope of this function. We’ll tie everything together soon!

## 5.2 Processing the restraint table data

Next up we can write a function to convert the restraint information into a 2D NumPy array. We’d like to end up with every restraint being defined in a single array that contains three numbers,

- The first indicates the node number the restraint applies to.
- The second is either `1` or `0` indicating restraint or not, in the x direction.
- The third is also either `1` or `0` indicating restraint or not, in the y direction.

So, for example, a pin at node 5 would be indicated by the following NumPy array,

```python
[5, 1, 1]
```

We would then like to have all individual `restraint` arrays collected into a _‘parent’_ `restraints` array (note `restraint` versus `restraints`). For our structure, pinned at node 1 and restrained in the y-direction (vertical) at node 5, the complete restraints array should look like…

```python
[
	[1, 1, 1], #Pin at node 1
	[5, 0, 1]  #Vertical (y) restraint only at node 5
]
```

We’ll again assume that `computeRestraintArray()` takes the user-defined table data as an input argument and then processes it, one table row at a time, building a `restraint` list to represent each row and then adding these `restraint` lists to the parent `restraints` list. When each row has been processed, the final `restraints` list is converted to a NumPy array and returned to wherever the function was called from. Here’s the complete function:

#### `dataIO.py`

```python
#Convert restraint user input into ndarray
def computeRestraintArray(inputData):
	restraints = [] #Initialise the list
		for row in inputData:
			node = row["col_1"] #Access col_1 from this row
			support = row["col_2"] #Access col_1 from this row

			"""
			Note that we specified the names col_1 and col_2 when we defined the
			table in our Parametrization() class in app.py
			"""

			restraint = []
			restraint.append(node) #Add the node number to the current restraint list

			#Convert strings to numbers and add to current restraint list
			if support == "Pin":
				restraint.extend([1,1])
			elif support == "X-Roller":
				restraint.extend([0,1])
			elif restraint == "Y-Roller":
				restraint.extend([1,0])

		restraints.append(restraint)

	return np.array(restraints)
```

## 5.3 Processing the loading table data

Finally, we can complete the `computeForceArray()` to generate a 2D NumPy array containing the `x` and `y` force components applied to each loaded node. This function is very similar to the one we just defined for restraints and follows the same steps.

#### `dataIO.py`

```python
#Convert force user input into ndarray
def computeForceArray(inputData):
	forces = []
	for row in inputData:
		node = row["col_1"]
		if node != None:
			fx = 0 if row["col_2"]==None else row["col_2"]
			fy = 0 if row["col_3"]==None else row["col_3"]
			force = [node, fx, fy]
			forces.append(force)

	return np.array(forces)
```

We’ll put these functions to one side for now and in the next lecture we’ll move on to porting our OpenSeesPy script into the `analyseStructure()` function in `analysis.py`.

Once we’ve done this, we’ll test it along with everything we’ve just written in this lecture.

💡 Don’t forget to commit your code!


Please log in to continue