- Welcome, everyone, to Wednesday Nite at the Lab.
I'm Tom Zinnen.
I work here at the UW Madison Biotechnology Center.
I also work for UW-Extension Cooperative Extension,
and on behalf of those of folks and our other co-organizers,
Wisconsin Public Television, the Wisconsin Alumni Association,
and the UW-Madison Science Alliance.
Thanks again for coming to Wednesday Nite at the Lab.
We do this every Wednesday night, 50 times a year.
Tonight, it's my pleasure to introduce to you Arman Pazouki.
He was born in Tehran, Iran, where he got his undergraduate
degree and his first master's degree.
That was in mechanical engineering.
In 2009, he came to Madison to study at the University of
Wisconsin-Madison where he got a master's degree in
engineering mechanics, and then, recently, his PhD in
mechanical engineering.
He's now an assistant scientist in the laboratory of
Professor Dan Negrut.
Tonight, he's going to talk with us about high powered
computation to speed truck design, which, in a state like
Wisconsin where we design and build really, really big trucks,
I think it's going to be an interesting story to hear how fast
computers help speed truck design.
Please join me in welcoming Arman Pazouki to
Wednesday Nite at the Lab.
(applause)
- I would like to thank Tom for providing me with this
opportunity to come here and talk about my research in high
performance computing, which is going to be useful for truck
design and many applications involving multi-body dynamics,
which I will describe what are those.
And, also, I would like to thank all of you for taking the time
and attending this presentation.
So, here I would like to talk about and share ideas about how
fast computers are going to be useful for engineering
applications, in general, and in multi-body dynamic simulations,
truck design, granular material, and problems like that
in particular.
My name is Arman Pazouki.
I'm an assistant scientist at the Simulation Based Engineering
Laboratory at the University of Wisconsin-Madison.
So, in my talk I will, first,
I will describe a little bit of high
performance computing, fast computers and such,
and how they are relevant to engineering applications and how
they are relevant in today's world in general.
And then, particularly since we do a lot of dynamics,
I will talk about applications in dynamics
and about the algorithms
that are required to join these.
Further, I will talk about engineering applications using these
algorithms and such and about the validation, which is an
important part of our work.
So, I would like to admit two facts at the beginning.
One, so my talk includes two key words; computation
and truck design.
So, when I decided to choose a major in my undergrad, I just
made sure that I chose a major that didn't have anything to do
with computation.
And now here I am. [laughter]
And the second thing is truck design.
So, truck design, I have to talk about a lot of components until I
reach that point, which is going to be the end of my talk, close to
the end of my talk, and I have to speed up somewhere.
So when I speed up, my Tehran accent kicks in, and I hope you
guys don't have any problem in that regard.
So, at the beginning I would like to thank the work of my
colleagues, and many people who have contributed to the
results I'm going to show today.
Many of them are my colleagues at Simulation Based
Engineering Laboratory, and many of them have already
graduated, got job, went to industry.
There are some collaborators from overseas.
University of Parma in Italy, Alessandro and other collaborators
in the US in industries and academia and such.
So, to open up my talk, I would like to show this picture.
Many of you probably know what is this.
This shows actually a five megabyte hard drive in 1956.
To give you an idea, like, what does that mean?
So, you see here, this small guy here?
It's a four terabyte hard drive.
We can buy it now online for $120 probably, and it's 80,000
times larger than the hard drive you see here.
What interests me here is, well, everything has developed.
We cannot say, well, this is super amazing.
But one thing that amazes me here is you see here the jeep.
It looks kind of similar these days.
You see airplane. We have airplane.
People dress up kind of similarly.
But one thing has changed a lot, and it's this hard drive.
Well, it's not very professional to open up my talk
about high performance computing by talking about hard
drive because hard drive is not the main component
of computation.
The main components are processors, and how we want to
compute or how fast we want to process mathematical
application or numbers and such.
So, we want to do calculation fast.
What does calculation mean in terms of machine language?
Everything that is composed of, like addition, multiplication,
division, these are basic operations.
Other calculations rely on these types of basic applications.
Like if you want to sort an array, if you want to do a logarithm
and such, at the end of the day you have to kind of split it not as
a programmer but the machine, the compiler, kind of splits it into
basic operations.
And then we like to know how much would you have
to pay to do about one million calculations in one second.
So, it turns out that in 1961 one required 17 million IBM
machines to do one million operations per second.
Usually, in terms of computational language, people use the term
floating point operation per second or flop per second.
So one million flops would require 17 million IBM machines.
And taking care of the inflation rate and such, that would
probably be about $8.3 trillion in today's money.
In 2000, you only needed to spend like $1,000 to do the same
amount of calculation.
And in today's world, in 2015, it only takes eight seconds of
computing to do the same amount of calculation.
So everything is changing super fast.
That needs to be translated into programming.
How to use the hardware, the available hardware.
So, the reason of this fast change is the change in the
microprocessor or transistors industry.
Transistors have become-- engineers have managed
to put more and more transistors into a unit area.
And this is actually in accordance to a Moore's Law.
Scientist Gordon Moore, more than 50 years ago, discovered
a rule that says every two years the number of
transistors you can fit into the same area doubles up.
So this is kind of suggested exponential rate.
So it means in 2011 the transistors characteristic line
was 32 nanometer, and then in 2013 22 nanometer,
and this trend is going to continue further and further
until it hits the physical limit of the Moore's law.
And the physical limit is, well, we cannot go smaller than an
atom used for computation.
That's the physical limit.
So, is it going to happen in 2020?
I mean, that physical limit is very small.
It's like 0.1 nanometer.
It's suggested in the paper.
We have time to reach that, but in practice we
may reach some physical limit earlier than that.
So, but, well, there are some good news that people
are working on other alternative architecture to replace
that sort of trend.
So after we hit the physical limit, some other
architecture will come in.
So this means two things.
First thing is, well, you can include more
and more transistors in the same area, you can have
faster computers, or you can have the same amount of
performance but reduce the size of the processor
and make a smaller and smaller processor.
So, what does increasing the size of the processor buy you?
So, it gives us more computational power.
We can process more complicated problems.
Back in the day, we wouldn't be able to imagine
solving a problem involving lots of moving bodies
and interacting with each other and such, but today that
opens up an opportunity to revisit those sorts of problems.
And then, for instance, today we can have processor
that have 5.6 million processors, 5.6 billion transistors
and the characteristic length of that processor is
22 nanometer, but if we want a project Moore's law,
which has maintained it's accuracy for more than 50 years
very interestingly, if we want a project that into
the future in 2017, we will have 50 cores as opposed
to 18 cores.
2021 we will have about like 200 cores.
And, therefore, this is an opportunity.
We have to look in advance.
And then, on the other side, we can just
have the same power.
For example, the high end processor I showed
in the previous slide with more than five billion
transistors has a characteristic, it's length
is about like 12 millimeters.
For example, we can imagine it as a square of 12 millimeters
each side.
But later on, in 2021, that length will decrease,
and it will be about like five millimeter each side.
So, we can use the highest end processor today in
a cell phone in 2021, and we can do computation we
are able to do today on a machine, a desktop machine,
we can do it on a cell phone or on a watch.
So, on the other side, there's another trend.
This shrinking of the size of the problems have
resulted in some other trends.
So, back in the day, people would use graphics
card in a computer.
Graphics card is a unit, in addition to whatever
computer brings to the picture, is a unit to
process the graphics.
For example, if we want to play a game, computer game,
graphics card takes care of refreshing the frames.
Each graphic card has a lot of cores.
These cores, each one of them would take care of one pixel
on the screen.
It would update it, give data back to the machine,
or calculate something to update the screen.
But now it turns out that we can use this graphics card
to do computation.
And now scientists are using that.
They make the problem kind of simple, composed
of simple building blocks, like they can decompose
the problem they have into basic operations like addition,
multiplication, and such, and then launch these problems
onto graphics card, and graphics card can do these
sorts of computation very fast.
That's what, for example, we do as part of our high
performance computing.
And I will show some results how these sorts of accelerators
can help us.
How about the memory?
I talked about hard drive, I talked about processor,
but what about memory?
Actually, it turned out that most of the applications
are bound by the memory transaction.
So if we want to do a computation, we have to grab data.
If we want to add two numbers, we have to first grab them
and then add them and return the result back to the user.
This transaction is sometimes way more expensive than doing
the computation.
So to do one GPU global memory access, it takes 400 cycles.
Like, 400, like we have to wait about 400 seconds as
a characteristic time scale.
But if you want to do, for example, 32 add/multiply
operations, we can do it in one cycle.
So this also suggests something for the engineers.
Engineers need to grab data and do as much calculation they
can do on that data, and then return the data.
We cannot access the data wherever we want whenever we want.
It has to be kind of pattern.
We grab two numbers, do 10 operations, more than 10,
and then we return it to the user.
The good news is same as the processing speed, the memory
access speed is also increasing.
It's not as fast as processing speed, but it's going well.
But the good news is also there is a concept of 3D
memory which is coming very quickly, very fast in
the near future, and then it speeds up the memory
transaction a lot.
So, where do we stand in this high performance
computing arena as a lab in mechanical engineering?
So we have a computer cluster.
It is on the fourth floor of the mechanical engineering building.
It's composed of a lot of CPU nodes.
And by node I mean a computer box that includes everything
you need to calculate things.
And then we have a lot of them.
Like 14 of them.
So if we have a problem we can either use one of those or
we can decompose the problem.
Each one of those can compute part of the problem, and then
grab the data attached to them and send it back.
And the computer cluster also has a lot of GPU nodes.
They had a graphic card and then we can use them as an
accelerator to further speed up the simulation.
Among these cores, two of them are really powerful.
I will talk about one of them, shown here, later.
The entire thing is called Euler.
This one powerful node is called Lagrange, and I will
describe it further.
So, in general, our cluster has about 50,000 GPU
scalar processors, about 1200 CPU cores, and 2.7 terabyte
of RAM, and it gives us about 40 teraflops double
precision computational speed.
40 teraflops.
So to see, what's that?
So to see where does this stand, I will give you an example.
So, before that, so let me talk about this powerful node
I mentioned earlier.
So it's one node is like the computer you might put
under your desk.
This is the same size.
It has three GPU cards.
It has one Intel Xeon Phi, and then it has
two Intel processors.
So it is Xeon Phi and the GPU cards are accelerators.
They are not essential to the system.
They are complementary, but we can use them
to accelerate the system.
And two Intel Xeon processors.
And then 64 gigabytes of RAM.
And the theoretical peak flop rate is about seven
million megaflops, or seven teraflops.
It cost us about $20,000 to build it in 2013.
2013.
So two numbers are important; seven million megaflops
or seven teraflops and 20,000 and 2013.
So, here is an IBM BlueGene/L set up by
Argonne National Lab.
In 2007, it would give about 5.7 teraflop.
A little bit less than what I showed in the previous slide.
And, in 2007, it cost $1.4 million.
So, what somebody couldn't use in 2007, that would
be privilege of only a few research labs, and now a lab like
us can afford it with $20,000.
The price would be a lot cheaper probably in today's price.
And we can do the same computation, we can get
the same performance as 2007 IBM BlueGene/L.
Argonne National Lab didn't stop there.
They set up another supercomputer.
It's called MIRA or BlueGene/Q.
It's about 1,000 times faster, and it is the fifth fastest
supercomputer in the world.
So I don't have the price for this one.
But it can do eight million billion operations
in one second.
So here is how the supercomputers are changing.
This kind of exponential rate, so because this is,
the vertical access is 10, each grid becomes
10 times larger.
So they are kind of increasing faster and faster because
of the Moore's law.
Every two years the power becomes twice as big as
the previous two years.
So here are the five fastest supercomputers listed here.
And, well, we can expect this trend goes on and on for a
couple of years until we hit the physical limit
of Moore's law.
So, in terms of how the supercomputers are
placed in today's world.
Well, mostly the people who use high performance computing,
they rely on supercomputer, like Euler I showed earlier.
Supercomputer that has many nodes separated and
the nodes communicate with each other,
transfer data back and forth.
A portion of the supercomputers are those so-called
massively parallel processing, or MPP.
And they are one big unit.
It's not composed of several units.
It's one big unit has everything you want.
So, it's only unit.
There is not much of communication with other units.
Therefore, you can expect that it shares more performance.
It performs much better.
But, again, having those types of supercomputers would
be a lot more expensive.
In terms of who uses supercomputers.
So, the big three players are academia,
national labs, and industry, and it turns out that
industry owns a lot of supercomputers.
In terms of performance share, in the left plot,
so research labs share more performance.
They own only 26%, but they share 50%.
Industry only 20%, although they own like 42%
of the supercomputers.
And then academia about the same.
So, just two things.
The first one would be problems in industry are complicated.
You can have supercomputer, but it's a little hard
to use it efficiently.
The second thing would be in industry there is a
gap between like supercomputing knowledge
and harder resources.
So this suggests some opportunity for jobs in the future.
So there would be a lot of opportunity in supercomputing
because those industries need people to make this 20%
portion a lot larger and kind of compatible with
what they own.
So, how are supercomputers changing?
So, within the past couple of years it seems the emergence
of accelerators, like graphics processing unit, the graphics
processing unit share more and more of the computing power.
So people started to look into that a lot more.
So a lot of computations are now performed
on graphics processing unit.
So, what will happen when the Moore's law fails,
or doesn't fail, I mean hits the physical limit?
So one opportunity, first off all, this is not going to
happen in like two or three years.
It's going to be at least a couple of years,
and by that point engineers will be able to solve many,
many problems that they couldn't imagine.
But parallelism provides and opportunity to use
the resources, the existing resources, without any
improvement in the hardware, using them efficiently
to solve new problems.
This is one thing, and this trend will continue until
we hit the power wall.
So, we have the same, we have the constant hardware,
but we are going to add to that.
We can add as much as we can supply power to that.
And this trend will continue.
People need to rewrite software to efficiently
use those hardware.
And then, further into the future, there is the prospect
of using tunnel transistors and photonics
and quantum computing.
So, long story short, the future looks bright.
I would like to quote this frame of Stanley Kubrick's
movie 2001: A Space Odyssey.
This shows a monolith.
It came, it changed the world, whenever it appeared
there was a new generation and such.
I would like to, some people might said this might be a TV.
I would like to think that's a supercomputer.
It's like every generation it's going to improve
the way people can do computation and such.
So, from now on I'm going to talk about multi-body dynamics,
which is the main component of our work.
So, to start, first of all I would like to describe what
does multi-body dynamics mean.
So it means we have dynamics, we have something
that are moving, and they are connected to each other.
So, for example, this tire is connected to the chassis with
some joint or CV joints, axle and such, and everything
is put into one picture to solve a meaningful problem.
And everything needed to solve that problem was
discovered more than 300 years ago by Newton and Euler.
It's called Newton-Euler Equations of Motion.
So, equations are there.
So, what can be our contribution?
It has been there for 300 years.
So, is it going to be hard to have a contribution?
Can we change the equations?
We are not going to change the equations.
The equations have proved correct for years and years
and years in this scales that we are working on.
The thing is to use those equations sometimes we
have to simplify the problem.
For example, if we have a revolver joint, we are going to
neglect the geometry of the joint.
If we have like a ball joint, for example, here,
we are going to just assume it doesn't have any geometry.
It's some relation between two points.
A point of like this axle and of a point of the other axle.
Geometry is neglected.
But geometry is important in many applications.
Like, for example, you see the Mars Rover here.
The way the wheels are designed and the geometry of
the entire object or the geometry of the grains themselves,
are they going to be spherical, are they going to be
elliptical, are they going to be like rocky grains and such?
All of them are important.
And the total operations depends totally on all
sorts of small, not very small details.
So, how does it translate?
How does geometry translate in terms of equations?
So whenever we have something, some problems like
in the previous slide,
whenever we have to objects, the two objects can
have contact with each other.
And it matters where do they contact.
So if, for example, I have this object, it matters if I push
it from the end or I push it from the beginning
or I push it from the middle.
So it totally matters that where does the force
apply because at the end of the day we need to
calculate the contact force and send this contact force
to the engine, find other forces, and find
the motion of the object.
Well, it turns out that commercial softwares fail
to do these sorts of applications.
A lot of questions have been there for 300 years,
not actually the contact, but two solve a meaningful problem
with contact, commercial softwares fail.
Here you can see one commercial application.
It's a bucket.
It's about like 30 balls without any specific geometry,
just rounded ball with one radius each, and they
fall into a bucket.
We want to model three seconds of this process,
and to do that it turns out we need to do the computation
for about 100 seconds.
It takes 100 seconds of the computer to do three
seconds of the actual process.
And not only that, if we want to have a meaningful problem
like the Mars Rover I showed earlier,
the Mars Rover, to give you some scale of how many
particles we need to simulate those sorts of problems,
one cubic meter of sand includes one billion particles.
Here this software solves 30 in one second.
If this software wants to use one million,
one billion is, say, is impossible.
This software wants to do one million.
One million takes this about 5,000 years,
if you want to use this software.
So, it's totally impossible.
No matter how much we wait for the Moore's Law
to double up every year, it's not going to happen
in the foreseeable future.
And there are other open problems in dynamics
that need some extra effort in terms of engineering.
So there are applications in granular dynamics.
Problems are becoming more like many-body
dynamics instead of multi-body dynamics.
There are some applications that bodies
have frictional contact.
They interact with each other.
They impact with each other, like sand.
There are other bodies that have flexibility or they
deform, like, for example, we have beans.
Everything is not perfectly rigid.
And then we might have interaction with a fluid.
They fall into the water.
How are we going to solve that problem with
direct numerical simulation?
And in terms of application, the list goes on and on.
Here, you can see a lot of application.
In farming, there is many applications of
multi-body dynamics in only this picture.
The truck, how it interacts with this granular bed or
rocky bed and how the farming material comes into the truck.
Are they designed good enough so that they don't clog?
And in pharmaceutical industry there are applications.
If we want to go further, it can be used to simulate
avalanche dynamics or landslide and a lot.
So that's the beauty of hypervised computing.
If you make sure that you can solve some of these problems,
then you can look at, okay, what types of problems
are there that we haven't looked at in the past?
So, we can just define problems that we will never think of.
So we can just push the boundaries of the computation.
So, the common sense says most of the problems in today's
world have a lot of degrees of freedom.
So if we have like one million objects, so each object
can move in three directions in space.
So it needs three components.
It can also rotate in three directions.
Six components.
If we have one million, we probably have four million contact.
Each contact needs three components.
So, at the end of the day, one million bodies needs
about 20 million, 30 million degrees of freedom to
describe the entire system.
So problems of one million degrees of freedom have
20 million degrees of freedom, degrees of freedom to solve.
So, these types of problems oftentimes require
a lot of compute power.
That's how the computers become relevant.#
Okay, we have computer, we have dynamic, we have problem,
how are we going to connect them?
So, say assuming we have this problem, multi-body
dynamics, not many-body dynamics.
It includes only less than 60 components, say.
So, if you want to formulate this problem,
one way is to do pen and pencil.
But is it really feasible to do pen and pencil?
We want to write one equation for each joint.
Like we say, okay, tire one is interacting with the chassis
because it has a revolver joint over there.
We need one equation, and we need another equation.
We have to write, okay, one equation for one and do one equation.
We cannot do that with pen and pencil.
We need to figure out some way so that we define a problem,
everything is done automatically under the hood.
This is more important when we have millions
of degrees of freedom.
Nobody can write them with pen and pencil.
Everything needs to be done automatically.
So, this is how it defines our understanding
in today's computation world.
We are working on an open source software called Chrono,
which is a research grade computational
software to do multi-physics modeling, many-body dynamics,
and so on and so forth.
The goal is to advanced the state of art in the simulation
in many-body dynamics, and then use
the emerging hardware technology, we don't know in
two years what kind of CPU is going to
be out there, what kind of memory model will be out there,
so the business of us as a developer is to just be up
to date with the hardware grab them efficiently.
And then after we've developed this software,
we want to attack, like open meaningful problems
in engineering, like granular dynamics.
Like, say, for example, truck design,
which I will show later.
Chrono relies on several foundations.
It has advanced modeling part to relate the equations
of motion and define them so that a computer can solve them.
It has proximity computation, which I'll describe later,
and then solution algorithms, how we want to define
the problems, how we want to improve the problem,
how we want to solve the problem.
And then the main composition, if we have a big
problem like truck that goes through the water
and it interacts with like, say, for example, rocks at
the basin, at the bottom of the sea, they
are different problems.
We can send part of the problem to one computer
and part of the problem to one computer.
Not only that, each sub-physics can be split into different
domains in computational world, and then
the results can be put together.
So, what does modeling mean?
The first component of Chrono.
So, it means we have the problem, in an ideal world
everything is composed of molecules.
Can we model everything?
Can we model, for example, this wall with
a bunch of molecules.
It's in physical because it's composed of
a lot of molecules.
If we could, we could describe most of the phenomena
with just molecules and solve it.
But we have to go on a scale up.
We have to, for example, if we have water, we need
some model to describe the motion of water.
If we have rigid body dynamics, we need some
model to describe that.
If we have flexible body, we need some model to describe that.
So this is where the modeling comes.
Modeling is good as long as it provides us a solution
in a physical time.
We want to solve the problem in less than, say, 12 hours.
We want to launch a problem and get the results
the next day.
We don't want to wait forever.
I should mention that we follow and open source philosophy.
Whatever we develop, it's going to be free for everybody
under BSD3 license, which is one of
the most permissive license.
Everybody is welcome to use it and we actually
encourage everybody to use it.
They can use it the way they want.
They can just even neglect crediting us and such.
So, talking about modeling, one would be, for
example, having a bunch of rigid bodies.
Say, for example, this selective laser centering machine.
So, in selective laser centering, there is powder,
a lot of powder involved.
Powder is composed of grains.
Each grain is a rigid body.
And then the machine comes, split the powder in
a surface, and then some rays heats the grain,
melts some of the grain, so it creates
one layer of the object.
And then again another layer powder, another laser beam,
and then another layer of the object.
And this process is done and done and done
until the entire object is built.
So, we want to model this process using Chrono capability.
Here is some of the results.
So, we have this roller.
It comes and splits up the powder.
You want to have a smooth surface so that when we
heat it with rays we don't get unwanted effect.
So, it is one sort of modeling.
Then we can, modeling that we can measure
the smoothness of the surface and such.
There is another application in 3D printing.
So, somebody came to us, a professor in polymer
engineering, Professor Oswald,
came to us and said we want to model, we want to
3D print a dress, and the dress is huge.
It doesn't fit into the 3D printing machine.
So what can we do?
We can do inverse engineering.
So we can, first, model that.
We can throw it into a bucket that fits into the machine.
We can 3D print only this bucket, and then we
can give the data to the printer.
The printer prints this, and then when we
open it up, it will be the dress.
The only problem would be, okay, these components
may stick to each other when we model that.
So that's not a big deal in modeling because if these are
the real particles we can, in the numerical world,
we can expand them a little bit so they are this.
And then, so when we model them, we make sure
that there's always some gap between
the particles so they won't attach.
So once we model this, we give the data, we print it,
there won't be an issue.
Another physical modeling would be, okay, what if we have,
say, cohesive material, like a snowball.
Like you can see here.
It looks like wet snow.
We can also have different types of
cohesion in the material.
Like more stronger cohesion.
Like here or here.
So this is another part of the modeling, and it turned out,
actually, that using the model we're actually implementing
right now it won't be hard to have this extra feature.
So we were using that.
Or we want to extrude some foam into a bucket,
like what you see here.
Again, this is simple rules of multi-body dynamics without
one small factor we added called cohesion or addition
between the particles, and now we can have foam.
Here is another example.
A truck comes and cuts through, say, for example,
snow and such.
We use both multi-body dynamics and cohesive material.
It looks more like moving the knife over the butter,
but it's probably the same principle but we can have,
we can simulate even that process.
There might be other applications such as, other modeling
components such as deformable bodies.
You can see here a ball falls onto the grass, for example.
The grass is a bit like flexible bodies.
They are not rigid anymore.
They are not described by molar equation
in their basic form.
So they are described, actually, by these
sorts of equations.
And this is another components of
the simulation engineering.
We can have both deformable bodies and some constrain.
For example, ball joint.
They're attached there.
We can have them.
We can have, say, for example, if we want to model a tire,
maybe these beams are not enough.
We have to look into some other modeling techniques.
So, we decompose the tire with a bunch of other
elements, deformable elements.
These are the components I'm describing because all
of these components eventually will be useful in
designing a complicated problem like truck.
What if we have fluid?
Again, we want to have rigid bodies, like this floating
object you see here, and we want them to
be pushed by the fluid.
They get influenced from the fluid.
And not only that, they also push back the fluid.
They influence back the fluid.
If we have a large rigid body here, we want them to
clog the fluid or prevent the motion of the fluid.
We want this two-way coupling between them.
So, again, it turns out, okay, these equations invented
more than 300 years ago.
These are different sets of equations needed to solve
for the fluid, and we need to kind of, these equations
are also invented a long time ago.
But a little bit of work has only been done to couple them
and solve meaningful problems involving both of them.
So here shows an application.
For example, we have a bunch of rigid body
fluid flexible bodies.
The fluid is cut to show the rigid body motion;
the rigid body motion are also cut to show
the motion of the flexible bodies.
They interact.
All of them together impact each other,
and they impact other things.
So, we do discrete simulation.
Our simulations are composed of all them, most of
them are in terms of discrete systems.
We have a problem.
We have a granular material.
It's composed of a lot of grains.
So, we need to find their interaction.
First of all, we need to know who interacts with what.
So, knowledge is sometimes taken for granted.
We have to kind of translate it into the machine language.
For example, if you go to the library and want to
find a book, one way is, okay, I have the name of the book.
I can go shelf by shelf, one by one, look at each title,
and find the book I want.
But, well, this is not what we do.
We go, okay, we see the code of the book, or the number.
We go, okay, is between these two numbers.
We go to that shelf, and then it is between
these two numbers.
It is in that shelf, and then we just look all
the books in this one, not all of them.
So, similarly, we need to kind of translate it into machine
language when we want to find a near particle.
So if we have a particle, we want to find the nearest one.
We can, the same idea, we can decompose the system,
the space, and then look only the nearby spaces.
It turns out that, okay, this is the plot I showed earlier,
composed of one million bodies.
Using this trick I showed in the previous slide,
we can get some linear trend.
So we can expect to solve a one million problem
in less than a day or two days.
Much faster.
So, we have to look at, like we have the supercomputing
power, but we also have to look at algorithms.
We have to figure out the ways to use
the supercomputing power.
One step further, we all solve this problem
on a GPU, graphics processing unit.
So if we do that, what's the speed we can get compared to
solving this problem on your machine?
Your machine is like a block, say, for example, this big,
and it's composed of one GPU like this big inside it.
And then using that small unit, we can get, if we use it
efficiently, we can get up to, for this specific problem we
can get it up to 160 times faster speed.
So a problem that would take 160 days,
now it takes like one day to solve.
So, the next component is algorithms.
How efficiently to leverage computational resources.
The key word here is efficiency.
So we can leverage computational power,
but we want to use it efficiently.
The key word is important because of another reason
too because efficiency, so just like optimization,
we want to do it in a faster time.
The fastest speed.
And it turns out that our problems translate
into kind of a minimization problem.
I hate to show this slide.
It has a lot of equations.
I won't go through them.
Personally, this is my job to look at this equation,
but whenever I look at that, I don't feel as good
as looking at that animation.
So the bottom line here is, okay, we have those
equations from 300 years ago, but we have also equations
for these joints and such, and we have a couple of
equations which rely on the geometry of the objects,
with contact and such.
So it turns out that those ugly looking equations,
at the end of the day they will be some sort of
simple nice looking optimization problem.
It's a quadratic optimization in terms of engineering,
and apparently it is one of the easiest problems to solve.
So at the end of the day, instead of solving that problem,
we have to solve this optimization problem.
By optimization I mean finding the minimum of this function.
And wherever that minimum happens, the valley of that
function happens, that's where we have the other solution.
So, finding the valley of a function.
We are walking on a hilly mountain.
The idea is to find the valley of that hilly mountain.
One way to find it is to have a simple rule.
I move, each time I want to move, I move towards
the direction that decreases my altitude.
I go a little further down.
That is the simplest rule.
Well, we can do it a little bit, so that may result
in some sort of trial and error.
So this is the contours of the elevation.
If I want to do that step, I have to go
a little bit each time.
I have to do a lot of steps.
But it turns out that with some other more advanced
algorithms I can do that much faster, and it
results in a lot better results.
So this is how we want to minimize the function
with blindly stepping through the mountainous area.
If I do it with a little bit of trick, I can decrease
the valley of the function much faster.
So instead of doing, say, for example, 400 iterations
to find a solution, I need to only do 20
iterations to find a solution.
And that's where I want to have my solution.
And with that, we can solve now a lot of good problems.
So, for example, if we have granular material, there
is an experiment, it's a famous experiment.
If you shake them, at the end of the day some
patterns appear on the granular material.
It's kind of honeycomb.
And we did the same experiment in computational world,
and you can see some patterns appear and such.
So, another application is like we have a couple of
other problems, a lot of rigid bodies, different shapes.
It's like blocks compared to that commercial solution
which was only like spheres.
Here we have a bunch of blocks or a bunch of spheres
or ellipsoids and such.
They flow over this rocky area, and they kind of want to
go through the holes and such and fill this in
and interact with each other.
And then, here is another application.
I will skip to that sort of in the interest of time.
So I'm getting closer to our real application,
which is truck design.
Here is truck vehicle moving over granular material.
So, to save computer power, we generate and throw
away unessential parts of the domain.
The track shoes have some weird geometry but
the software is designed in a way that can
handle any geometry.
It can handle (mumbles) and such.
So, here you can see a problem composed
of one million objects.
Remember that number I gave at the beginning,
like 5,000 years.
Now we manage to solve that problem using the technique
and the using the pilot programming and the graphics
processing unit in less than two days.
Now here is another problem.
Now this is another level of parallelism.
Each sub-domain colored here, each one of them is
processed by a different segment of the computer cluster.
And at the end of the day, they stick to each other,
they communicate with each others,
and they solve this problem.
Now, let's go to truck design and Chrono in vehicle
mobility and terramechanics.
So, vehicle mobility is an open problem.
There are lots of problems in this area that
haven't been discovered yet.
And then the vehicle must be designed so that if
the conditions or if the scenario changes,
we can find a solution.
We cannot do these sorts of things in experiments.
Experiments are expensive.
Setting up an experiment, if I want to give you a number,
there was somebody in oil industry, they said,
oh, I want to move a ship through ice,
through a basin of ice.
Modeling that in a scaled down basin,
just setting up the simulation, it would take
about a day, or something like that,
and it would cost $50,000 for one experiment.
So now, oh, we figured out we did a mistake
in some parts of the experiment.
We didn't measure some number.
If we want to do that, another $50,000.
But if you have a framework to do this stuff,
a lot of them we can do, we can save a lot of money
and we can do lots of search for best design
and optimal design and such.
So, one of the vertical components relying on
the Chrono components is Chrono vehicle.
It is some, it's composed of some subcomponent
designed so that we can solve problems like this.
A vehicle that goes over a rocky mountain,
a vehicle that goes through water or on sand
or something like that.
So, it's part of the Chrono toolkit designed for wheeled
and tracked vehicle, like the track shoes I showed earlier.
It's a middleware, which means it's not a problem,
it's not kind of a software that everybody
can pick up and use.
Some sort of knowledge is required,
we can pick up and solve it somehow.
It's, again, open source.
We stick to the open source philosophy.
Everybody can use it, if they can do so,
and they are welcome.
And we kind of, again, encourage everybody
and we help everybody to use that.
And all of the dependencies are, so staying in the open
source area requires that everything that you rely on
should be open source too.
If you use one component that is not open source,
if the vendor of that component says I cannot release that,
then you can not release the entire core.
So the Chrono vehicle includes a lot of
components to solve the problem.
It has a different suspension system.
They are already there.
If we want to solve the problem, we just need
to pick up and change a little bit.
That subcomponent, for example the suspension,
and then if we want to do steering a subsystem,
driving can be four-wheel drive or two-wheel drive.
Like the brakes and wheels, the wheels can be
deformable, they can be rigid, and such.
The graphics or the visualization is also something like
this where a programmer uses it.
You see something like that.
It's a fast visualization.
Here is another alternative.
Both of them, the first one and this
one are both of them open source.
Everybody can use it or deliver it in their software.
Here is some example of using this Chrono vehicle framework.
It shows a truck, a vehicle that is moving over
a pass, and then it breaks.
You see what kind of forces or acceleration or
what is the maximum speed it attains.
You can measure all the forces you want.
You can do this scenario in different other ways.
For example, if there's a double lane change,
in this problem it goes, it changes the lane,
it goes back to the lane.
We want to see what types of force that causes.
For example, here, you see the change
in the forces and such.
So, the user can define scenario.
The framework is there.
Here is another scenario.
The vehicle goes over a non-smooth pass.
It's kind of a hilly mountain.
You can see, okay, what is the right comfort.
How much motion the driver sees in this scenario or
what type of force the driver sees and things like that.
Then, these were all on hard floor.
A lot of interest in off-road mobility.
Like, for example, we want to see how this vehicle
moves on a slope composed of rocky material.
So if you change the slope, you go like different distance.
Your speed changes. Your power changes.
The forces change and such.
Here I talked about like the cohesive material.
So we can have that, and we can have the vehicle.
The components are there.
Some engineer just needs to put them together
and solve this problem over some sort of material that are
kind of muddy material and see different forces.
Here is like how the vehicle moves over sand and such.
So, apparently, it doesn't go as fast as it used
to go on the hard floor.
It may even get stuck in this sand and, like,
granular pebble material.
Here is another source of visualization.
Now, if we have data, we can extract any sort
of information we want from that.
We can color them based on the height of the grain.
We can color them based on the stress.
We can color them based on any other
information that already exists.
That's another part of simulation.
We have data.
Data are just numbers, and we have to kind of use high
performance computing to process them to see
what can we get out of that.
Here is a similar scenario.
The vehicle goes over granular material and goes on a slope.
It's a kind of sandy mountain, for example.
And, in this case, it's gets stuck here.
Now we can have smooth, we can have kind of
textured granular terrain, and then we can measure
the acceleration of the chassis and such.
There might be other scenario involving not only rigid body,
there might be fluid, like the vehicle wants
to go through the water.
This is how we solve the water, through a lot of
smaller domains, and then the vehicle goes through them.
Here the power was not enough.
It gets stuck into the water.
We can have flow of water in one direction to see
if they change the motion of the vehicle and such.
And then, another component is how we're
going to automate the simulation.
So, here, via collaboration with another open
source software company called Open Source
Robotics Foundation, we just stick the two software
to each other to solve a problem.
This vehicle just follows this red path.
It is designed to do so.
It captures the view, and then it processes it.
It sees, okay, I'm a little off, now I need a little bit of
steering toward the right, for example, to stay
on the path and move on.
So, we do a lot of work on the validation side.
So I just showed you engineering application, but they
are meaningless as long as we prove they
give us good numbers.
Sometimes we can validate the real problem.
If some collaborator comes, says, okay,
I have data for this vehicle.
We use that, we simulate that, we say these match.
Sometimes we have to go like split
the problems into subdomains.
One of the validation cases we had was opening up a gap.
Like five micron glass beads come out.
We measure the flow rate here in the experiment,
and we measure the flow rate here in the simulation,
and we see how well they match.
Here is the flow rate measured.
They kind of match in a very good way.
Another validation we performed was cratering.
If there is an object hitting the granular bed, how much
does that go into the granular material depending on
the size of the object, depending on the speed of
the object, friction, type of the material
and so on and so forth.
Here you see a couple of materials.
One of the students in the lab shows wood,
Teflon, so on and so forth.
For each of them, we get a different trend.
And, apparently, the distance that it goes into is kind
of a weird equation of diameter and speed and such.
We managed to reproduce the same equation
A little bit off in terms of value, but the trend
and the dependency of the variables I interestingly similar.
Another type of validation is we want to measure if
we have a bunch of sand, they don't flow,
like they don't spread entirely.
They just form a cone, and, therefore, we want
to measure something similarly.
We want to measure, like if we have a bunch of soil samples
if we push it and pull in the other direction, how much
force we need depending on the pushing force.
So, again, here are the experimental results.
Here are the numerical results produced here.
The other famous experiment is cone penetrometer.
And so people like drop this cone and they see
how much it penetrates into the granular material.
And we simulated it with similar simulation framework.
Another test is tri axle test.
A bunch of granular material, we push it from one side
and then there is pressure from the other side and we
measure stress, how much force are between
the particles and such.
Here is another one.
Kind of a real problem.
This excavator digs into granular material, and then,
so we are regenerating the actual process here.
Then, at the end of the day, we want to see how much force,
for example, we can measure here with sensors or with,
like, computation with our software.
And, so, again, here are the plots.
If we use different numerical approaches
and they match with each other.
In other types of simulation we are moving
a wheel over granular material.
We want to capture the motion under the wheel and so on.
Here I show some plots, and here is the simulation.
Here is the experiment, and this was done in
collaboration with another group of researchers.
And depending on if the wheel is like kind of toward you,
you see some pattern formation.
If it is like zero slip wheel, it's a different pattern,
and then if it is positive slip or driven wheel,
it's a different pattern.
So, again, these are the problems we are working on.
In the fluid side, similarly we have a bunch of validations.
I will skip through that in the interest of time.
Here we have suspension going through the channel.
As they go through the channel they try to spread
into the channel.
Some of the particles go toward the wall,
some of the particles go toward the center,
and we manage to get similar results with experiment here.
So, I would like to conclude my talk by acknowledging
the work of my colleagues.
I showed a lot of their works today.
Here is current colleagues of mine in
Simulation Based Engineering Laboratory.
Other collaborators from University of Parma, from
University of Iowa.
And then, to summarize my talk, we are
committed to open source philosophy.
We like to generate software that is useful for everybody.
We encourage that. We help people to use that.
Some of the applications you already saw here.
There are other applications we haven't think of.
People are welcome to use that.
And then we are committed to, a lot of our
effort goes to validation.
We are committed to provide software that provides
meaningful results, not just a bunch of numbers
and nice animations.
And, with that, I would like to conclude my talk,
and thanks again for your attendance, and I wish
you good night tonight.
[applause]