This is the End

Emalee Berry, Drew Guingrich, Molly Vodacek, Rachel Tackett & Zhiying Liu
Project 3 Milestone
CGT 411
April 8, 2016

With final presentations approaching in just three weeks, we have finally put
the finishing touches on our crane placement program before we send it out for user
testing. Our plan was to create a simple, user friendly tool in Dynamo to help project
superintendents shorten the process and assist them when calculating the size,
location, and lifting capacity of tower cranes. Again, we designed our program to
focus mainly on the range of each crane as well as the lifting capabilities based on
the weight of the steel elements in given building. We believe we have done just
that and we are now ready to get feedback on our program. Last week, in addition
to finishing up our emerging technologies and processes paper, we also sent out our
program as well as a set of testing instructions and surveys to the companies that
have agreed to help us with testing. These include Holder Construction, Walsh
Construction, Pepper Construction and more. We conducted our usability testing
with fellow CGT and BCM students in person in a KNOY laboratory this week and are
currently compiling results. We ended up making some changes to our testing
procedures that we will go into detail later in this paper. We hope that these
updated testing procedures and surveys will help us to accurately evaluate our
crane placement tool. Our goal is to have user testing completed no later than April
13th which will give us time to evaluate all of our feedback and responses.
As previously stated, in week 11 we were able to finish our emerging
technologies paper ahead of schedule. Since Dynamo is the basis for our crane
placement program, we decided to make it the focus of our emerging technologies
paper. To briefly summarize, Dynamo is a versatile visual programming tool that
gives those with little coding knowledge, as well as experienced programmers, the
ability to manipulate information within design interfaces such as Revit. Users are
able to establish custom pieces of visual logic within Dynamo that then translates to
a command in Revit, essentially creating a custom algorithm. The visual logic

feature is designed for users with little coding knowledge so they can utilize the
graphical programming interface consisting of wires and nodes to create their
design. With this feature, users are able to directly input their own code in such a
way as to manipulate different elements. Essentially how it works, is that each node
contains its own code block with predefined functions. These nodes have individual
input and output ports that drive the users commands through a customized series
until the functions are executed. These functions serve to manipulate the input data
and then generate the desired output result.
While Dynamo has many applications, it is most commonly used as a Revit
plug-in that helps drive design and functionality of certain features. It has provided
a great deal of advancement in construction and architectural practices in recent
years. While Revit is an advanced program, it is limited in its capabilities when it
comes to producing organic shapes in building modeling. Dynamo is becoming more
commonly used for sophisticated, nontraditional building design.
We also completed our final program. It
requires the user to provide three inputs: a
crane, the steel elements and then a number
to locate where the distance from the steel to
the crane will be measured from. We originally
only planed on having the two inputs (the
crane and the steel) but learned that we had to
add an input in order to make sure that
distances between the two objects were
measured from the correct point when the crane is rotated in different orientations.

Even though Revit provides a way to schedule the weight of steel members in
a project, it would not allow us to import those parameters into Dynamo. We were
originally going to use the W value, which is the weight per foot of a beam to
calculate the values. We ended up using the volume of the beam because that
project parameter could be successfully sent into Dynamo. We then multiplied it by
a factor of 490 pounds per cubic foot to calculate the weight. This allowed us to
calculate the values of all the steel elements that had a volume associated with it.
However, it did limit us to not being able to calculate the mass of elements that
dont have volumes associated with it like custom created trusses.
The next issue we ran into was that our code would send an error when the
crane was placed too far from the building. If no elements were within the first
distance range of the crane, it would not fill any arrays and then all of the masks to
change the steel elements colors would fail. We
could not find a work around to help solve this
issue but decided that it was more of a catch for
the project leaders. If they get this error, it shows
that they are wasting a lot of crane reach
capability by placing it so far away. The image to
the right shows an example color coded output
after the simulation has been run. As illustrated, the crane is fairly close to the
jobsite (roughly 60 feet away) and the model is nearly all green with some orange
elements signifying that they are currently out of reach of the crane. This would
indicate that the superintendent can move the crane closer to encompass the whole
building.

The last thing we

experienced when finishing up
our final crane program for our
smallest crane was that we
noticed its lift capacity was more
than enough to lift all of the steel
in our sample project. When we
noticed this, we decided that it wasnt necessary to model the next two larger
cranes. Instead, we focused on adding the modifications of the boom length on the
crane we already had. In the end, we created one crane option with three different
set ups available to go with that crane. We were able to successfully load all of the
steel elements from a Revit project as well as their specific locations. We also were
able to load and place the crane on the jobsite and select that crane as the location
to measure the distance from. We were successful in incorporating factors including
the cranes specific jib lengths and reach radius, lifting capacity and weight of all
the steel elements. Using this information, we were able to simulate whether or not
steel elements on a job site could be successfully picked up based on their weight
and distance from the crane. The picture to the right shows the Dynamo file for our
smallest crane the Peiner SK 315 17.5 ton 2 Part Line with 131-foot boom length.
The other two crane files are similar except for the weight parameters of lift
capacities and there are more nodes to the right since those cranes have longer
boom lengths.
Last week we came to the realization that our original testing procedures
would have to be altered due to changes in our final product. As previously stated,
we decided to change our product to utilize one crane with three different boom

lengths instead of three vastly different cranes. Since we made this change, we
were forced to change how our testing would be carried out. Test one was kept the
same, but we ended up combining tests two and three. Test two was originally
testing for accuracy by having the user select a crane that was most similar to one
used on a previous project. However, by only using one crane in our program we
realized that the chances of that crane matching what was previously used were
very slim. Therefore, we eliminated the previous project aspect of testing. Instead,
we are testing both time and accuracy of users experience with our program on a
new construction project. Since test two and three were combined, we also
combined the survey questions for said tests.
After we finished our program and altered our testing methods, we created
our instructions for users. We came up with step by step instructions for both tests.
Because test one focuses on usability, we are having both students and
superintendents complete this test. We hope that by the end they can understand
and be comfortable with using our program. For the usability test, we began with
directions of how to download Dynamo if applicable. Next we instructed users to
open the project in Revit and then open Dynamo. We then instructed them to open
the smallest tower crane program which is the Peiner SK 315 - 17.5t - 2 Part Line 131 ft. Each of our steps have very detailed description of what users need to do
and we also provided the users some notes if certain conditions occur. Once the
Dynamo file is open, there are only two main inputs required. We instruct them to
select the structural components and then load and place the tower crane roughly
60 to 80 feet from the model and then select it as the crane location in Dynamo.
After that, they run our program and observe the color code output. According to
our expectations, most of the model should be out of reach so the elements were

changed to orange. Everything that is green is within range of the crane and also
able to be picked up based on the weight. Then, we asked users to move the crane
closer to the building (roughly 10 to 20 feet away) and run the simulation again.
They can now observe that even though the crane is extremely close to the
building, there are still orange elements that indicate that not everything is within
range of the crane. They can also observe that everything that is within range is still
green (and not red) which indicates that the weight of the elements is within the
lifting capabilities of the crane at that location. Since there are still elements are out
of range, our next instruction is change to a larger crane. We instruct them to close
the current Dynamo crane file and open the Peiner SK 315 - 17.5t - 2 Part Line - 229
ft. Users must then re-select the steel elements and crane in Dynamo and also
move the crane back to its original location 60 to 80 feet away from the building.
They then run the simulation again and can see that most of the structure turns to
green. Lastly, we instruct them to move the tower crane closer which then turns all
of the building green symbolizing that the crane is in an optimal location. Users are
finally instructed to complete the corresponding survey for test one.
As previously stated, we ended up combing test two and three into one single
test to incorporate both accuracy and time. This test is designed for experienced
project superintendents. After they finish our usability test and get familiar with our
program, we ask them to open up a new project. We then instruct them to estimate
the amount of time they believe it would take to accurately locate the placement of
a crane with their current method. Once the estimation is determined, they are to
time how long it takes to find the optimal crane location using our Dynamo
program. They can experiment with different possible locations for the crane until a
suitable site has been found. Once this site is found, the timer should be stopped.

We then instruct users to use the by-hand method to calculate values for at least
5 critical pieces of steel. They are then asked to examine calculated and simulated
results to ensure the Dynamo simulation and expected values match up. This
ensures whether or not the Dynamo program is accurate, while also evaluating if it
decreases the time it takes to determine crane location on a jobsite. Like test one,
users are also instructed to complete the corresponding survey for this test upon
completion.
So far, we have received results for our usability testing from students (test
one). We had a few computers available so students did not have to wait since the
test takes about twenty minutes to complete. From the students we have tested so
far, the results look very promising. They really seemed to understand the tool from
the instructions provided. When asked if there was anything difficult to understand,
most responses indicated no and that it was easy to follow. One question in our
survey asked about any changes that were recommended for the program. A few
students suggested using a computer that could run the program more efficiently.
We figured this would be a response but this factor is unfortunately out of our
control. One student suggested that we include a video tutorial for the instructions.
Another students response talked about adding error messages that list why the
steel cant be lifted and how to solve these issues that the user may come by. Many
of the other questions on our survey were Likert scale statements that assessed
how positive peoples experience with our program was. The highest possible rating
for these questions was a ranking of 9 (strongly agree). Most of our average scores
for each question were between 8 and 8.5 indicating that their testing experience
was positive. There was one question that had an average above this and one with
an average below. The one just below this range asked if the user would feel

comfortable using this program again without the instructions. The response to this
was 7.875. This is still a high response but its looking like there are a few people
who still dont feel fully comfortable using this program. The best way to solve this
would be to have them run through the program a few more times. The question
that had the highest rating was about the understanding of the color outputs. The
average for this question was 8.75. We were happy with this result because of the
number of color outputs that are included in the program. We thought that this
might be a potential problem for users understanding. Now that we have some
results, we can start working towards the final presentation and gathering all of our
information.
This week, we started preparing for our final presentation. We chose to start
by looking back at our Go/No Go presentation and then make changes and work
from there. Our first step was to look over the rubric and see what needed to be
included and try to find the right places for all of this new information. This
presentation will include more of our testing procedures, program details (and
demo) and testing results. We have been going over our program and making sure
that all the necessary information is in our final presentation. We have been going
back and forth about whether to do a live demo during the final presentation. We
would have to demo the program on a computer with both Revit and Dynamo which
would likely be a group members laptop. However, running our program on laptops
is not nearly as efficient as desktop computers. The time that it takes to open and
run the program might be an awkward point in our presentation since we would just
be waiting on the computer to load. This issue and a few others are some of the
things that we will be figuring during the next week when we finalize the
presentation.

We have accomplished a lot in the past few weeks and will hopefully finish
the semester out strong. Our plan for the remaining weeks is to continue preparing
for final presentations, complete our user testing, and finalize our crane placement
program. Once the user testing is completed and we have received our survey
results, we will analyze the responses and feedback and then make any necessary
changes to our program before our final presentation on April 21.
References
The Revit Connection. (2015). The Dynamo Primer. Retrieved March 29, 2016, from
http:// dynamoprimer.com/08_Dynamo-for-Revit/8-1_The-RevitConnection.html

What is Dynamo? (2015). The Dynamo Primer. Retrieved March 28, 2016, from
http://dynamo primer.com/01_ Introduction/1-2_what_is_dynamo.html

Yang, S. (2015, February 02). Dynamo and Computational BIM - Part 1: Introduction
and Resources. Retrieved March 28, 2016, from
http://the360view.typepad.com/blog/ 2015/02/dynamo-and-computationalbim-part-1-introduction-and-resources.html