Skip to main content
Engineering LibreTexts

20: Program Design Project

  • Page ID
    43120
  • This section details the design project in the computer portion of the class (classes). This will represent the computer laboratory. Like the general engineering laboratory, teams will consist of 4 to 5 students (group work is requirement in most engineering courses, so no you can't do it alone ).

    Here you will write a computer program that is substantial in a team of 4 to 5 students (if circumstances make it less then this then instructor will make adjustments). The main objective of this laboratory is to learn how to write a program as a team that is more "real world" than academic. A report (with test examples) would accompany the program along with mini-manual. For academic purposes all individuals in a team will write their own report and mini-manual. In the "real world" a report could be written by just one member of the team, but academically that does not teach anything to the other members of the team. Hence the requirement herein.

    The program must be able to run. Since there needs to be tests a non-functioning program would not meet the criteria. Reality means that in order to meet the functionality criteria a team may have to modify what they output and comment out sections that don't work. A report would include what your team actually had working and what your team failed to get working. There is no shame in failing on part of the assignment as the point of this is to teach and getting something is better than getting nothing.

    So the laboratory will test:

    • Your understanding of engineering (or scientific) programming
    • General programming, documentation of programming, and testing of programming
    • Teamwork
    • Report writing (which is to be done by each individual of the team)

    Assignment:

    • Write a program (in a language of your choice) that investigates or models an engineering or science principle and/or project. The project is the team's decision with approval by the instructor. The whole group needs to participate (pop "visits" will be asking each team member to show what they are doing). As a guideline each student should write approximately 5 pages of code (this is not a hard and fast rule).
    • Make sure the program is functional.
    • Comment the program in appropriate places (not every where).
    • TEST the program (each member of the team should do this separately - this assures everyone understands the program).
    • Write a report that includes introduction, body with results and discussion, and conclusion. Each student should write their own report. A report should be about 3 pages (with figures) or longer, but not thesis size, please.
    • Write a user manual that describes how to run the program. Discuss both input and outputs. Each student should write there own user manual.

    Examples of programs done in the past:

    Please note that in many cases simplifications had to be made to meet the time constraints in the academic world or to fit with the current mathematical and scientific understanding of the students (team). Simplifications were done by an experienced professor, not the students (it is not the job of the student to do this; though the students should as a group be following along and asking questions, if necessary). However sometimes no simplifications were made because the students wanted more of a challenge.

    • Motion of car simulation using simplified Navier-Stokes Equations (simplified by instructor)
    • Simulation of four stage rocket – different rocket simulations have been done multiple times
    • Simulation of simple car crashing
    • Simulation of car considering tires on various road surfaces
    • Simulation of stopping distance for different breaking systems (disk, magnetic, drum, etc.)
    • Simulation of flow in a various pipes
    • Simulation of a wind tunnel (or particle simulation with obstructions, if you wish)
    • Simulation of an ECG of the heart through Fourier series
    • Simulation of an ECG of the heart through Daubechies wavelets
    • Simulation of greenhouse warming through radiative forcing (tk/tcl was used for graphic widgets in this project)
    • Simulation of a multibody problem (simplified by instructor)
    • Simulation of the heat on the nose cone of the shuttle using finite elements (NOT Simplified! Awesome work)
    • Simulation of Earthquake (p and s waves)
    • Simulation of ground water flow (Darcy’s Law) – this has been done multiple times; each different; one went on to be used at a job site
    • Simulation of baseball pitches (including curve, sinkers, etc.) - this has been done multiple times always with different ideas
    • Simulation of parachute dude – a major extension of the program presented herein
    • Simulation of a hydrodynamic system: a real reservoir (not simplified) that is energy efficient and produces electricity in an environmentally friendly way

    The choice of program is the team's choice. Examples are only given to guide your thinking, not to be chosen from. Many other project ideas were done that are not listed here.

    To further help with the project idea, a pseudocode of a parachute extension is present below.

    Parachute Dude Extension (pseudocode):

    function (time,velocity) = paraperson(type_of_parachute, object_type,initial_time, final_time,initial_velocity, gravity,time_step,parachute_descriptor,mass_descriptor)
    
    double pararect, paracirc,parahole
    double saila,sailb
    double generic double rocket, probot,pload
    class parachute_descriptor ::length,width,radius,out_radius,in_radius,material_type
    class mass_descriptor ::vararg(mass_pieces),vararg(distributed_force_pieces)
    
    switch type_of_parachute
        case {“rectangular”}
            drag = pararect(length,width,material_type) 
        case {“circular”}
            drag = paracirc(radius,material_type) 
        case {“circularwhole”}
            drag = parahole(out_radius,in_radius,material_type)
        case {“parasail_a”}
            drag = saila(out_radius,in_radius,material_type)
        case {“parasail_b”}
            drag = sailb(out_radius,in_radius,material_type)
    endswitch 
    
    switch(object_type)
        case {“generic human”} 
            [center_of_mass,distribution_force_vector]=generic(mass_descriptor)
        case {“rocket”} 
            [center_of_mass,distribution_force_vector]=rocket(mass_descriptor)
        case {“payload_robot”} 
            [center_of_mass,distribution_force_vector]=probot(mass_descriptor
        case {“payload_drop”} 
            [center_of_mass,distribution_force_vector]=pdrop(mass_descriptor)
    endswitch 
    
    [time,velocity]=parap(initial_time,final_time,initial_velocity,drag,center_of_mass,distribution_force_vector,gravity,time_step)               %This would run the program that the equations for parachute dude
    end paraperson
    
    

    Example of pseudocode shell to get drag coefficient given choices made when running program....

    function drag_local = pararect(length,width,material_type)
       % Equations to get drag for this rectangular parachute
    end pararect
    
    ....other drag functions...
    

    Example of pseudocode shell to get center of mass of your object and the distribution of forces

    function [center_of_mass,distribution_force_vector]=rocket(mass_descriptor)
        %Equations to get center of mass and your distribution of forces
    end rocket
    
    ...other center of mass and force distribution functions...
    

    Example of how you might want to run this in octave.

    octave:1> [time,velocity] = paraperson(type_of_parachute, object_type,initial_time, final_time,initial_velocity, gravity,time_step,parachute_descriptor,mass_descriptor) 
    octave:2> prettyplot(time,velocity)