Structural Finite Element Analysis User’s Guide

Now that you have downloaded and installed Scilab, the Structural Finite Element Analysis (SFEA) program, and got it up and running, how do you use it. Well that’s what we want to go through at this point. What you should see on your desktop are two blank screens. The one on the left will provide the user input controls while the one of the right will graphically depict the structure being analyzed. If this is not the case then you should read here first.

Getting Started: The File Menu

In the left screen there is a ‘File’ menu. If you click it you will see that you can select ‘New’ or ‘Close’. ‘Close’ is pretty obvious. ‘New’ will give you a sub-menu of three choices: Beam, Frame, or Truss. To make clear the difference, in this program an element of a beam supports transverse and moment forces, a frame supports axial, transverse and moment forces, and a truss element supports axial and transverse forces.

To give an example of why this might be important, consider a simple cantilever beam with a non-orthogonal loading. (In other words, the load does not meet the beam’s longitudinal axis at 90 degrees) Now although it is a ‘beam’ due to its form and positioning, since the load will produce an axial force in the structure, it is not a ‘beam’ with regard to the methodology of this program. If you were to analyze this structure, you would select ‘Frame’.

Once you make this selection, the left window will populate the controls. You will notice that there are two frames. The top frame walks the user through the step-by-step acquisition of the necessary data. The bottom frame contains the controls for obtaining the results of node displacements, support reactions, and elemental or member forces.

Entering Node Data

Now that the controls are up, the user simply starts at the top left and goes across and down just like reading text. Start by entering the number of nodes in the text box at the top and then click the ‘Node Coordinates’ button. This brings up a dialog box that asks the user if they want to enter the nodes ‘Singularly’, ‘By Sets’, or ‘From File’. ‘Singularly’ means manually enter the node coordinates one at a time. ‘By Sets’ means the user will enter some criteria about the nodes that is repetitive and the computer will determine the nodes for you. This is a helpful function when you are entering a large number of nodes that follow some consistent pattern with regard to their geometric arrangement. ‘From File’ means the user can open and import the coordinates from a user created text file that contains all the node coordinates.

Singularly

If the user selects this method, a new dialog box will open to let the user input the node coordinates.

The number of rows in the dialog box will dynamically correspond to the number of nodes the user entered would be in the structure.

By Sets

If the user selects this method, another dialog will appear to ask the user how many sets they have to enter. This is a simple integer input.

After entering the number of sets, another dialog box will be displayed to obtain the set data from the user.

The rows in the dialog box correspond to the number of sets. For each set the user must enter the node number to start with, how the node     number for each subsequent node should increment from the beginning node, the beginning x-y coordinate for the first node, the x and y distance each subsequent node will increment from the previous one, and how many nodes in the set.

For example if I was analyzing a simple cantilever beam and I wanted to divide the beam into 20 separate elements, then I would have 21 nodes. Since I would space the nodes out evenly along the length of the beam, I could enter those nodes by sets without having to enter them one at a time. If the length of the entire beam is 120 inches (10 feet), then I would have 20 elements each 6 inches long. So in entering the data by sets in the dialog above I would input: node number start = 1, node number increment = 1, x start = 0, y start = 0, x increment = 6, y increment 0, number of nodes in set = 21. The program would generate 21 nodes starting at the x-y coordinate (0,0) and at every 6 inches horizontally for the full length of the beam.

From File

If the user selects this method, a standard Windows dialog box will open where you can search in the file tree structure to find the text file containing the node coordinates data. The text file should be formatted with one node coordinate per line starting with the x-coordinate followed by a space followed by the y-coordinate.

Which ever method the user selects, once the data has been provided to the program, it will output the node coordinate matrix to the Scilab console. The user can verify the correct coordinates numerically there. Additionally, the nodes will be plotted graphically in the second SFEA window. This allows the user to verify the nodes visually.

Entering Support Reactions Data

Once the nodes have been entered, the user can set the boundary conditions for the structure by pushing the ‘Select Reactions’ button. A dialog box will then open and allow the user to select the support type at each node.

Notice the default node type is free, so the user only has to define those nodes which are supports. An ‘X-Roller’ allows rotation and movement in the y-direction but no movement in the x-direction. Likewise a ‘Y-Roller’ allows rotation and movement in the x-direction but no movement in the y-direction. A pin allows rotations but no x or y movement. Finally a fixed support allows no movement at all.

Once the user defines the node types, the node type matrix will be displayed in the Scilab console and the structure plot will be modified with different symbology for different node types as seen below. The symbols are from left to right, free, x-roller, y-roller, pin, and fixed.

Entering Member or Element Data

Once the nodes and reactions are defined the user can input the members that run between the nodes. In much the same way as the entry of the nodes, the user will enter the number of members in the textbox in the SFEA first window and then push the ‘Member Data’ button. As with the nodes, a dialog box will permit the user to input the data ‘Singularly’, ‘By Sets’, or ‘From File’.

Singularly

If the user selects this method, a dialog box will appear to allow the user to input the data for each member. The data required are the start node number, the end node number, the member’s cross-sectional area (A), the member’s modulus of elasticity (E), and the member’s moment of inertia (I).

By Sets

In the same way as with node entry, the ‘By Sets’ method of member entry allows the user to systematically enter a large number of members with repetitive characteristics. With regard to member entry, each member of a set must have the same A, E, and I.

From File

As before, this allows the user to load the member data from a text file on the computer. The format of the file should be one member per line with each line having: start node number-space-end node number-space-A-space-E-space-I

Once the member data is entered, this data is output to the Scilab console as the connectivity matrix. Also the members will be plotted in the SFEA plot window.

Entering Applied Loads

There are two aspects to the entry of the loads that affect the structure. To understand this fully, let’s define some of the terminology. The first piece of information to enter in the SFEA first window control is the ‘Number of Load Types’. A load type is typically something like dead loads, live loads, wind loads, seismic loads, etc. These are each different load types. If a structure was going to have each of these load types listed then it would have 4 load types. Another term in the program is ‘Number of Load Combinations’. A load combination is a linear combination of the form:

Where each ‘x’ is a load type and each ‘A’ is a load factor. A load factor is something that is typically used in Load and Resistance Factor Design (LRFD) as a form of scaling factor or safety factor. So for example we might have:

Where D stands for dead load and L stands for live load. In many structural applications and building codes there are sets of multiple load combinations and corresponding load factors. Each of these combinations must be calculated and the worst case scenario is then selected for design. The SFEA program provides the capacity for this type of analysis.

Load Types and Loads

Once the user enters the number of load types and pushes the ‘Loads’ button,  a dialog box that allows the entry of the different loads for each type will appear.

Each row in the dialog box corresponds to each node in the structure. Consequently you can enter a horizontal, vertical, and moment load at each node. After pressing ‘OK’ another identical dialog box will appear for the next load type.

The loads matrix will be displayed in the Scilab console after entry. Each column of the matrix is a different load type. The rows follow the following pattern. Each node has 3 potential loads therefore the first 3 rows correspond to the 3 loads on node 1. The next 3 rows correspond to node 2 and so on. Therefore there should be 3N rows where N is the number of nodes. Additionally, the order of the loads in each set of 3 rows is the same as it is entered in the dialog box: horizontal, vertical, moment.

Load Combinations and Factors

As discussed above, the number of load combinations and load factors are often listed in manuals or code books. Once the number of combinations is entered and the user pushes the ‘Load Factors’ button, the following dialog box appears.

Here the user enters the load factors that correspond to each load type for each combination.

Once this data is entered the load factors will be displayed to the Scilab console as well as the ultimate loads. The ultimate loads are the maximum loads at each node calculated from all the given loads, load combinations, and load factors. Also, the ultimate loads will be depicted in the plot window on the structure with red lines or curves. The line goes from the node in the direction of the force. A semicircular curve around the left side of a node is a positive moment according to the right-hand rule while a curve around the right side of a node is negative.

Find Displacements

At this point the structure is fully defined and graphically displayed in the plot window. Now when the user pushes the ‘Find Displacements’ button, the displacements vector will be displayed in the Scilab console and the new displaced shape of the structure will be plotted in blue. The displacements vector follows the same convention as discussed above with the loads matrix. The first 3 rows correspond to the horizontal, vertical, and angular displacements of node 1. The second 3 for node 2 and so on.

Find Reactions

When the user presses this button next, the reactions vector is displayed in the Scilab console. Again, as with the loads and displacements you have the horizontal, vertical, and moment reactions for each node starting with node 1 and going down.

Find Member Forces

Finally when the user pushes this button, the local member forces matrix is displayed in the Scilab console. Each column corresponds to a member. Column 1 for member 1 and so on. The first 3 rows are the horizontal, vertical, and moment forces on the member at the starting node while rows 4,5, and 6 are the forces on the member at the ending node. It is important to understand that these forces are with reference to the member’s local axis. The local axis for each member has its origin at the starting node with the horizontal or x-axis directed toward the ending node. The vertical or y-axis is then appropriately orthogonal to the local x-axis.

I hope this user’s guide has been helpful and provided sufficient information or answers to your questions. However if you are still stuck or want further information just let me know in the comments.

The Bisection Method using Scilab

 

Recently, I have really been enjoying learning to use Scilab which is an open-source mathematics software that works alot like Matlab. Specifically we have run into some design problems in water and wastewater engineering that involved solving for variables that are described implicitly by an equation and cannot be solved through typical algebraic means. For example:

This cannot be solved directly for x. So how can we find the value of x that will satisfy the equation? Well this is where the numerical analysis technique of the bisection method comes in. The bisection method is a bounded or bracketed root-finding method. In other words, it will locate the root of an equation provided you give it the interval in which a root is located.

The search for the root is accomplished by the algorithm by dividing the interval in half and determining if the root is in one half or the other. Then it divides that interval in half and so on until it gets within a specified relative error. Below I have entered my code for this algorithm. If you save this file as Bisection_Method.sci in a scilab/modules/…/macros folder and execute it in the SciNotes editor, you can then use it by entering a command in the console like:

root = Bisection_Method(‘x-sinx-3’,0,6.5,0.5)

The first passed parameter is the function equation itself solved such that f(x) = 0. The second parameter is the lower end of the interval while the third is the upper end. The final parameter is the percent relative error that the algorithm much reach with the solution before it terminates and gives a result.

Please feel free to download Scilab for free here and copy this code and use it. Let me know if you have any troubles or if you find a problem with the code.

 

//The Bisection Method is a bracketed root locating method. Therefore
//the user must input the lower and upper bounds on the interval where
//the root is to be located. 
//func_expression - must be a string containing the function expression
//with the variable written as 'x'.
//es - is the relative percent error criterion that must be met for the
//method to terminate.
function [root]=Bisection_Method(func_expression, x_lower, x_upper, es)
    x = x_upper;
    fu = evstr(func_expression); //evaluate the function at x_upper
    x = x_lower;
    fl = evstr(func_expression); //evaluate the function at x_lower
    //***********************************************************
    //test to see if there is a root in the interval
    if (fu*fl >= 0) then
        root = 'no root in interval given';
    else
        //there is a root in the interval
        exact_solution = 'notfound';
        ea = 100;
        xr_new =(x_upper + x_lower)/2;
        //*******************************************************
        //iteratively progress toward to root until it is found or it
        //is approximated with a relative error less than required
        while ea > es & exact_solution == 'notfound',
            x = xr_new;
            fr = evstr(func_expression);
            x = x_lower;
            fl = evstr(func_expression);
            //***************************************************
            if(fl*fr < 0) then
                x_upper = xr_new;
            elseif(fl*fr > 0) then
                x_lower = xr_new;
            elseif(fl*fr == 0) then
                root = xr_new;
                exact_solution = 'found';
            end //of if statement
            //***************************************************
            //calculate the approximate relative error for the iteration
            xr_old = xr_new;
            xr_new =(x_upper + x_lower)/2;
            ea = abs((xr_new - xr_old)/xr_new)*100;
        end //of while loop 
        //*******************************************************
        //if error criterion has been met but the exact answer has not
        //been found, set the root to the adequate approximation.
        if (exact_solution == 'notfound') then
            root = xr_new;
        end //of if statement
        //*******************************************************      
    end //of if-else statement
    //***********************************************************
endfunction

Calculus Applied to Manufacturing Design

Suppose you are in the can manufacturing industry. Your job is to create cans according to the specifications of canned goods suppliers who will put their products in your cans and distribute them for sale. Now suppose one of those canned good suppliers comes to you and says, “We need a can that can contain a 300 mL volume of our product. Joe Shmoe says he can provide us these cans for $X. What can you do?” If you want the canned good suppliers business you will have to underbid Joe. (Provided you can’t sale them on some other facet of your company, i.e. service, quality, etc.) How will you do it? Where can you cut cost? What is the most inexpensive can you can make to satisfy the spec? In the real world this is a very complex question because it involves labor, facility, process, and material expenses along with several others. For the sake of this exercise however, we will use the principle of the derivative to optimize our can design in order to minimize material cost.

Now let’s assume you are set up to produce a standard cylindrical can with a top and a botttom. (I realize the canned goods supplier will have to add their product before the top is sealed and I realize that actual cans have a small lip on the top and bottom, but for the sake of simplicity…) To minimize the cost of the cans we want to minimize the amount of material used. But what shape cylinder will contain the required 300 mL but use minimal material? A short fat can or a tall thin can? How “tall” or how “short”?

First, realize the total material for the can can be determined by finding the area of the metal. For a cylinder this is the area of the bottom plus the area of the top plus the area of the side.

We can rewrite the area of the top and bottom as:

If you imagine removing the top and bottom, cutting the side along a vertical line, and laying it out flat you can see that the area of the side is the area of a rectangle with the length of one side equal to the height of the can and the length of the other side equal to the circumference of the top or bottom. So its area is:

Putting this all together, the total area of a can is given by:

Now the volume of the cylinder is given by:

If we rearrange this expression for the height, h we get:

Now we substitute this into our expression for the area to eliminate the h and make the whole thing in terms of 1 variable. (r – because the volume is given to us in the spec)

This equation tells us how much area a can has of a particular volume with any radius. With this in hand we can now use the derivative to optimize (maximize or minimize) the can design and find out which radius will give us the smallest area and thus the most inexpensive (as far as material costs go) cylindrical can that can contain the prescribed volume. Taking the derivative of the area equation using the power rule we have:

Now we set this equal to zero to find the minimum area. Solving for r we get:

Knowing that the volume is 300 mL our radius is:

Putting this back in our equation for h we get a height of:

These are the dimensions for our can of minimum material. Below I have tabulated and graphed some other values for the radius and associated heights that yield the necessary volume and show that the resulting surface area is larger than our optimized design.

One other beautiful thing about this technique is that I have a general formula for an optimized cylindrical can for any volume. I can just put in whatever the specification says and get my design.

Although this is greatly simplified, I hope this provides another demonstration of the real world applicability of these techniques.

Interview with Engineering Because

Recently, I had the honor of being interviewed by Nayema Chowdhury at Engineering Because. They have done numerous interviews with engineers and engineering students from all around the world. They also have an online community as part of their website that allows you to meet some of these people. You can check out the site and read my interview here.

The Beauty of Openness and Real-Time

Lately I have been repeatedly impressed by the interaction and utility of Twitter. I have also been asked by numerous folks what the point of Twitter is and why I would waste my time with it. I hope to point out two areas that have struck me lately about what is really distinct and valueable about Twitter.

First I love what I call the “Openness” of it. With Facebook I can only interact with my “friends” or group-mates. With LinkedIn I can only interact with my “connections” unless I want to put someone in the awkward position of formally facilitating an introduction. Both have these barriers to meeting new people. Then you have Twitter. With Twitter I can interact with anyone, anywhere, anytime. It is such a great platform for finding or being found by new and interesting people and connecting with them.

Second, if you follow the right people and monitor your stream, you can get real-time information about what is going on anywhere. An excellent example of this is the other day I started getting updates in my feed about an accident here in town. People were warning others about it so that they could avoid the traffic congestion. They provided information about its exact location, what lanes were blocked, photographs from smartphones, highway cameras, and news coverage. Shortly AFTER I noticed this trending topic in my feed, we got a call to go and investigate the accident. Well now because of Twitter we had all this real-time data prior to even going to the site to investigate. Obviously we have to be objective and base our investigation and analysis on evidence and facts, not tweets, but the data was useful nonetheless.

I’m sure these are just some of the benefits of Twitter. Do you know of some others? Please share them in the comments. Do you agree with the two I pointed out?

Basic Derivative Rules

Previously we have discussed how a derivative is found using the limit, why the derivative is useful, and how to find it. Now to attempt to simplify or shortcut the derivative finding process, we will look at some general rules that can be used instead of going through the entire limit step-by-step every time.

The first derivative we will look at is the derivative of a linear function in slope-intercept form.

Where m is the slope and b is the y-intercept. Using the limit definition for the derivative we have:

Therefore the derivative of any linear function is, as we would expect, equal to the slope of that line. The next derivative we will look at is a special case of the linear function. If the slope is zero then the linear function is a constant function.

As above, the derivative of a linear function is its slope therefore the derivative of a constant function is also equal to the slope which is zero.

The next rule we can look at is a single independent variable raised to any power. Hence this rule is often called the Power Rule.

Applying the limit process we obtain:

Notice how we used the Binomial Theorem to expand the first term in the numerator. At this point I want us to notice a certain pattern in the coefficients that can be seen in Pascal’s Triangle. The first coefficient will always be 1 (c1=1). This can be seen by looking at the left edge of the triangle. Every first number is 1. Secondly if you look at the diagonal row parallel to, directly adjacent to, and to the right of this first row of 1’s, you notice that the numbers count sequentially as you descend the horizontal rows of the triangle: 1, 2,3,4,5,..etc. These numbers correspond to the second coefficient in the binomial expansion. If we label the horizontal row of the very first 1 at the top of Pascal’s Triangle zero and then incrementally as we go down the triangle, the second row will provide the coefficients for the binomial squared, the third row for the binomial cubed, the forth row for the binomial to the fourth power, and so on such that the nth row gives the coefficients for the binomial to the nth power and the second coefficient will be n also (c2=n). From here we have:

So you can see that the derivative of any variable to an exponent is equal to that same variable times the original exponent to the power of one less than the original exponent. For example:

In summary we can use the following rules to make our lives easier with regard to finding derivatives.

Next time we’ll look at some more helpful derivative rules.

The Binomial Theorem and Pascal’s Triangle

A binomial is a polynomial of two terms. Hence the bi- prefix. In general form it looks something like this: (a+b). If we multiply two of these together we obtain:

If we multiply three we have:

With four we have:

If we look at this examples we start to see some patterns. The number of terms in the result of 2 binomials multiplied together is 3, of 3 binomials is 4, and of 4 binomials is 5. The first term in the binomial starts in the first term of the result to the power equal to the number of multiplied binomials. Its power then successively decreases by 1 as you move through each term left to right and it is not present in the last term. In a similar manner, the second term of the binomial is found in the last term to the power equal to the number of multiplied binomials. Its power then term-by-term decreases from right to left and is not present in the first term. The coefficients at first seem to have no particular pattern besides they seem mirrored or symmetrical (1,2,1 or 1,3,3,1 or 1,4,6,4,1). In general, we can write these binomial expansions or the binomial theorem as:

where the c’s represent the coefficients.

A useful and interesting tool for determining the coefficients of a binomial expansion is Pascal’s Triangle. Blaise Pascal’s original triangle is seen in the image at the beginning of this post. We will look at and discuss the triangle in the following form.

One way of looking at how this triangle is formed is by starting with the single 1 by itself at the top of the triangle. If you add this 1 to the nothing or unseen zero on it’s left, you get 1 and this is placed under the intersection of the top 1 and this unseen zero. Likewise, the top 1 and the unseen zero to the right are added and result in the 1 to the right in the second row. The process continues all the way down the triangle adding two adjacent numbers and placing the result under those number’s intersection.

If you look carefully, you will see that the coefficients for the binomial multiplication can be found in the rows of Pascal’s Triangle. For instance the third row corresponds to the coefficients of the binomial to the power of 2, the fourth row to the power of 3, and the fifth row to the power of 4. So if we want to find the coefficients for the binomial to the power of 10, we just look at the 11th row and we have them.

Maximizing and Minimizing

In the last post about the derivative we emphasized its utility with some examples about how it can be used to find some relationships between position, velocity, and acceleration or to maximize profit and minimize cost in numerous different practical situations. Well now I want to discuss that in more depth and provide an example. Last time we used the following definition for the derivative (or slope) using the limit:

With this we can find the exact slope at any point on a curve. Now consider the following graph. Each of the red lines represents the slope at that point with a tangent line

Consider what the slope of such a tangent line would be at a minimum or maximum on a curve. That’s right, the line would be flat and horizontal like this:

Therefore the slope at these points is zero. With this geometrical understanding of a minimum or maximum we can find the derivative and then determine where the derivative (or slope) is equal to zero.

Now let’s consider an example function that relates the production level of a manufacturer to the potential revenue per unit. Obviously we want to maximize revenue so the key will be to find the maximum. Here is the function:

Now you might ask, “Well how in the world did we know this tells us about this relationship?” The short answer is that after some experimenting by the company at various different production levels and measuring the resultant revenue, the corresponding data points were plotted and the following function was mathematically obtained as a best-fit approximation to describe those data points. (More on this in a future post.) So assuming this is the correct function that we are working with, let’s first find the derivative.

Now this derivative gives us the slope at any point along the curve of the original function above. Where does this new function equal zero? This is the same as finding the roots of the equation which is a typical problem in algebra. Here is how it’s done based on our example.

Now if we put these two production level values into the original function it will tell us the revenue produced. Here are the results.

Therefore production level 2 provides the maximum revenue potential. (The root zero is an interesting point called an inflection point. But that’s another topic.) To demonstrate that this process has in fact located the maximum, here is a table of revenue values at other production levels and a graph of the function.

Next time we will look more in depth at the derivative and some basic rules or short-cuts we can use so that we don’t have to go through the entire limit process every time we want to find the derivative.

The Derivative and Why You Should Care

The first post in this series discussed the idea of the limit. And we tried to present it in a fairly simple, intuitive manner. We also discussed how a lot of the difficulty people ascribe to to calculus is due to the symbology. Above in the header you will see 4 different ways of writing the first derivative. However don’t be dismayed, just stick with me and we’ll see the derivative is not really that bad. Now with reference to the limit you might ask, what does getting really close to some point of anomaly have to do with derivatives? And what is a derivative anyway? And why should I care about all this math-ese? I suppose to motivate you to read on, I will first speak toward the usefulness of this concept.

The derivative allows us to consider the way one quantity or variable responds with regard to another quantity or variable. For instance, consider distance and speed. The more distance I cover in a period of time, the greater my speed. (For more on the relationship between distance, time, speed and acceleration see this post.) Or how about manufacturing: the less material I waste, the less my costs. Or maybe fuel economy: at a low speed I consume a lot of fuel. At a really high speed I consume a lot of fuel. But at some optimum intermediary speed, I maximize my fuel economy. Or maybe designing a structure for maximum strength with minimum weight. Or an electrical system that delivers adequate power with minimum infrastructure. All of these problems and many more utilize the concept of the derivative to arrive at their solutions.

Now with the hope that you are sufficiently convinced of its usefulness, let’s look at what exactly and derivative is. Again, I want to present it in such a way that you can intuitively grasp the idea. Take a look at the following graph.

Now the red line represents the function or the relationship between the input or independent variable, x, and the output or dependent variable, y. There are two of these key points that we want to look at. First at x=a, the function value is y=f(a). We use generic symbols so it will work for any function at any point. We will take a look at a particular function shortly to try and see this less abstractly, but for now let’s continue on. The second point is at x=a+h we get y=f(a+h). Now suppose we are curious to find the slope of the function curve (red line) at the point (a,f(a)) (the line labeled T). A rough approximation could be made by finding the slope of the line between the two points we mentioned. Recall that the slope of a line is equal to the rise divided by the run. The rise then will be equal to the difference in the two y-values, in particular f(a+h) – f(a). The run will be the difference in the x-values, in particular a+h-a which is equal to h. Therefore the approximate slope could be written as:

Now look at the graph and imagine that the point (a+h, f(a+h)) moved closer and closer and closer to the point (a,f(a)). Wouldn’t this give us a better approximation of the slope at (a, f(a))? I bet you have already noticed what concept I’m alluding to. That’s right, the limit. If we use the limit to bring the two points closer and closer together (in fact we will bring them so close together that the distance between them approaches nothing) we will have the exact slope at the first point. This is how we write that:

Now I promised an example so let’s look at a simple one. Let’s use:

Using the definition above we have:

So just like that we have found the slope or derivative of the function x squared which is 2x (“a” was just used above for a particular point, but it could really be any point “x”). In this same fashion we can find the derivative or slope of any function (provided it’s continuous – more on that later.)

But now you might say, “What does finding slope have to do with all the useful stuff you talked about at first?” We will dig into that next time.

Fluid You Can Walk On

In fluid mechanics we learn about the viscosity of a fluid. In an intuitive way we know that viscosity has to do with the rate at which a fluid will flow. For instance water will flow much more easily and quickly out of a cup than something like oil or honey. Therefore we would say that honey is more viscous. In engineering terms, we define viscosity (more precisely, absolute or dynamic viscosity) as

the constant of proportionality between the shearing stress and the rate of shearing strain.

With solids we talk about the shear modulus of elasticity, G,  as being the slope or constant of proportionality between the shear stress and shear strain. Since fluids will theoretically infinitely shear strain under a constant shear stress (which is the definition of a fluid) we must compare shear strain rate instead of shear strain. And much like with solids, the slope of the graph is often a straight line and thus a constant. This slope or constant is the absolute viscosity. Fluids with this linear type of behavior are called Newtonian Fluids.

Now this is where the interesting part comes in. Not all fluids act in this nice neat fashion. This other group of fluids are called Non-Newtonian Fluids and there are two categories. The slope of the shear stress / shear strain rate graph for Non-Newtonian Fluids is called the apparent viscosity and it changes at every point along the graph. The first group of Non-Newtonian Fluids are called shear thinning fluids or pseudoplastic fluids. With shear thinning fluids, the apparent viscosity decreases as you increase the rate of shear strain. In other words, the faster you push through it, the easier it will be. Latex paint is an example of this type of fluid. The second group is called shear thickening fluids or dilatants. These are the opposite of the other group in that the faster you push through the fluid, the harder it is to push. This results in the odd but fascinating phenomenon you can see in the following video clips.

Walking on Fluid

http://youtu.be/f2XQ97XHjVw

Make Your Own Non-Newtonian Fluid at Home

http://youtu.be/hvJikar9Vqk?t=5s