Process

MCDA Seed Allocation

1. Initial location	2. Attraction	3. Final location


The location of the seed agents is calculated by looking at the static environmental data: Entrance access, street noise, sky view factor, etc.	The different seed agents are attracted to each other, based on the connectivity matrix. They ‘walk’ around, until they have reached an ideal location based on internal attraction and external data.	The seed agents have reached an equilibrium.

Input

Static env-data, preference and connectivity matrix

Output

Seed agent positions

Code

def select-neighbours:
circumvent the encountered bug

def distance-lattice:
calculate the euclidian distance from the seed agent to every voxel

for each agent:
for each voxel:
check if voxel is available:
calculate ‘grade’ (based on env-data and agent preference)
append best voxel to agent list

while t < threshold:
for each agent:
calculate a closeness lattice to the seed voxel
select-neighbours:
check which neighs are available:
grade those neighs on dist and env-data
append best voxel to agent list
remove previous voxel of this agent
t += 1

Spatial behaviours: Squareness

If there is the need for a space to be more rectangular, instead of free-form, the squareness algorithm can be used.

Pseudocode
Input Voxelized envelope, squareness preferences
Output
Impacts the growing algorithm

Code
For each agent (during the growth process):
Find the free neighbours based on the chosen stencil,
Check if the agent has free neighbouring voxels
Check if those neighbours are also neighbours of the previous agent

For those voxels that were neighbours to the previous agent, increase the voxel value (the more often a voxel has been a neighbour of an agent, the more the voxel value increases)

Select the neighbour with the highest voxel value
Set the selected neighbour as unavailable
The selected neighbour is now the new agent

Spatial behaviours: Distance between functions

Pseudocode
Input Location of new agent
Output
Keep-distance-lattice

Code
field = [list of neighbours in a given radius]
For i in field:
keep-distance-lattice[ loc + i ] = agent-ID

### Later on, when determining neighbours

if keep-distance[neighbour-location] == agent-ID or -1:
Sneighbours . append(neighbours-location)

Spatial behaviours: Maximum building depth

1. 2. 3.

Three directions are filled. All four directions are filled. If there is one direction with only three voxels remaining, the fourth voxel is made unavailable.

Pseudocode
Input Agent locations
Output
Updates to avail-lattice

Code
For each voxel-location of agent:
check if all voxels in given distance are occupied in x and y axis:
check how many axes don’t have a n+1th voxel:
if amount is 1:
make remaining n+1th voxel unavailable

Spatial behaviours: Roof light

Pseudocode
Input New agent locations
Output
Updates to avail-lattice

Code
roof-light = [ list of functions that do not want voxels above them ]

if agent-id in roof-light:
avail-lattice[ neigh-3d-loc[0], neigh-3d-loc[1]] , 2: ] = -1

MCDA Growth algorithm

1. Starting the growth 2. Growing 3. Finished growth

All the agent seeds are evaluated and their best neighbour is chosen based on the static env-data and closeness to other agents. This is done with the connectivity and preference matrix For each agent, the algorithm evaluates every voxel and calculates all the possible neighbors. The best one is chosen. The max. number of voxels per agent has been reached, the division of the spaces has ended.

Pseudocode
Input Static env-data, preference and connectivity matrix
Output
Occupation lattice

Code
while t < threshold:
for each agent:
check if max. amount of voxels has been reached
for each agent location:
find neighs:
check which neighs are available:
grade those neighs on dist and env-data
append best voxel to agent list
t += 1

Shafts and corridors growth

1. Selecting voxels to evaluate 2. Finding mean voxels 3. Mean voxels again 4. Corridor growth

Not all the voxels need a shaft to be placed. The garden for instance would be strange to take into account. For every function in de occupation lattice, a certain amount of voxels are set, based on the size of each function. Each function has at least 1 mean voxel so that later on corridors can grow and acces all functions. From the previous mean voxels, new mean voxels are calculated, that will become the shafts inside the new lattice. Each shaft is connected on the ground floor to the other shafts. Also second corridors grow from each mean voxel to their closest shaft.

Pseudocode
Input Occupation lattice
Output
Shafts and corridors lattice

Code
Make a boolean lattice for all important voxels from the occupation lattice

For each agent:
calculate a number of mean voxels based on the agents occupation

For each mean voxel:
calculate 6 new mean voxels for shaft placement

For each mean voxel:
calculate the closest distance to a shaft
set this path as a corridor

For each shaft:
calculate the 2 closest distances to another shaft on the ground floor
set these paths as corridors

export the shafts and corridors lattice

1.	2.	3.

Three directions are filled.	All four directions are filled.	If there is one direction with only three voxels remaining, the fourth voxel is made unavailable.

Pseudocode
Input	Agent locations
Output	Updates to avail-lattice
Code	For each voxel-location of agent: check if all voxels in given distance are occupied in x and y axis: check how many axes don’t have a n+1th voxel: if amount is 1: make remaining n+1th voxel unavailable

1. Starting the growth	2. Growing	3. Finished growth


All the agent seeds are evaluated and their best neighbour is chosen based on the static env-data and closeness to other agents. This is done with the connectivity and preference matrix	For each agent, the algorithm evaluates every voxel and calculates all the possible neighbors. The best one is chosen.	The max. number of voxels per agent has been reached, the division of the spaces has ended.

1. Selecting voxels to evaluate	2. Finding mean voxels	3. Mean voxels again	4. Corridor growth


Not all the voxels need a shaft to be placed. The garden for instance would be strange to take into account.	For every function in de occupation lattice, a certain amount of voxels are set, based on the size of each function. Each function has at least 1 mean voxel so that later on corridors can grow and acces all functions.	From the previous mean voxels, new mean voxels are calculated, that will become the shafts inside the new lattice.	Each shaft is connected on the ground floor to the other shafts. Also second corridors grow from each mean voxel to their closest shaft.