1. AN EXAMPLE - BEAMCAD

/*

* BeamCAD

*

* By Hugh Jack,

*

* An Automated approach to beam design. This is an interactive program

* Designed to take input about a beam and then determine beam para-

* meters, which are displayed both graphically and numerically.

* After on screen design a hardcopy may be made on an Epson compatible

* printer. The program requires an EGA quality monitor, with an IBM

* PC compatible system.

*

* February, 9th, 1989.

*

*/

/* header files which define functions and constants */

#include “stdio.h”

#include “graphics.h”

#include “math.h”

#include “time.h”

#include “conio.h”

#include “bios.h”

/* define internal operation and error codes */

#define DONE -1

#define NO_ERROR 0

#define ERROR 1

#define REVISED 2

#define NEW 3

#define UPDATE 4

#define PRINTER_ERROR 5

/* define material types */

#define STEEL 0

#define ALUMINUM 1

#define END_MATERIALS 2

/* define beam types */

#define I_BEAM 0

#define CHANNEL_BEAM 1

#define SOLID_BEAM 2

#define HOLLOW_BEAM 3

#define L_BEAM 4

#define END_BEAMS 5

/* set corners of user input box */

#define INPUT_LEFT .03

#define INPUT_RIGHT .45

#define INPUT_BOTTOM .97

#define INPUT_TOP .85

/* miscellaneous definitions */

#define EXTENSION 20 /* standoff for dimensions */

#define DOUBLE_LINE_GAP .005 /* normalized gap between double lines */

#define X_Y_RATIO 1.408 /* Screen x to y aspect ratio */

#define PAGE_OFFSET 80 /* Output offset for printer */

#define ERROR_BIT 8 /* Printer error bit */

/* define some key codes */

#define DOWN 1

#define UP -1

#define F_1 59

#define F_3 61

#define F_4 62

#define UP_ARROW 72

#define DOWN_ARROW 80

#define ENTER 13

/* declare functions in this listing */

void box(),

calculations(),

draw_line(),

kill(),

picture(),

screen(),

text();

int enter(),

input(),

printer(),

printes(),

setup();

/* set up formats for user inputs, prompts and help prompts */

struct entry { char name[25];

double posx;

double posy;

char help1[40];

char help2[40]; };

struct entry list[8] = {{{“Beam Type :”}, .08, .18,

{“1. I-Beam 2. Channel “},

{“3. Solid 4. Hollow 5. L-Beam”}},

{{“Beam Material :”}, .08, .23,

{“1. Steel 2. Aluminum”}},

{{“Beam Thickness :”}, .08, .33,

{“Metal Plat thickness for beam “},

{“Construction”}},

{{“Beam Height :”}, .08, .38,

{“Total height of beam from top to bottom”}},

{{“Beam Width :”}, .08, .43,

{“Total width of beam from left to right”}},

{{“Span Length :”}, .08, .53,

{“Length of unsuported span to be”},

{“considered”}},

{{“Load Position Offset :”}, .08, .58,

{“Distance from left side to the Point”},

{“at which a load force is applied”}},

{{“Load Force :”}, .08, .63,

{“Total load force applied at load”},

{“position”}}};

/* set up format and structure for material description */

struct mats { char name[15];

double weight;

double modulus; };

struct mats materials[10] = {{{“Steel”}, .283, 10300000.0},

{{“Aluminum”}, .0995, 29000000.0}};

/* set up work strings and various beam names */

char work[80],

work2[20],

beams[10][20] = {{“I Beam”},

{“Channel Beam”},

{“Solid Beam”},

{“Hollow Beam”},

{“L Beam”}};

/* set up global integers */

int beam_type = I_BEAM, /* beam cross section type */

beam_material = STEEL, /* beam material used */

entry_number = 0; /* Current choice on input menu */

/* set up global double precision numbers */

double beam_width = 3.0, /* Width of beam cross section */

beam_height = 6.0, /* Height of Beam cross section */

beam_thick = 0.5, /* Thickness of metal plates */

beam_length = 120.0, /* Length of beam span */

beam_load = 0.0, /* Load force applied to beam */

beam_point = 0.0, /* displacement of applied load */

beam_area, /* calculated cross section area */

x_centroid, /* calculated x centroid */

y_centroid, /* calculated y centroid */

moment_inertia, /* Calculated moment of inertia */

x_axis, /* calculated x principal axis */

y_axis, /* calculated y principal axis */

axial_stiffness, /* calculated axial stiffness */

bending_stiffness, /* calculated bending stiffness */

beam_deflect, /* calculated beam deflection */

deflect_point, /* point of maximum deflection */

out_distance, /* calculated distance from fibres */

beam_weight, /* calculated total beam weight */

xmax, /* absolute width of screen x */

ymax; /* absolute height of screen y */

main()

/*

* EXECUTIVE CONTROL LEVEL

*

* This is the main terminal point between the various stages of setup,

* input, revision and termination.

*

* January 29th, 1989.

*/

{

static int error;

if((error = setup()) != ERROR) {

screen(NEW);

screen(UPDATE);

while((error = input()) != DONE) {

if(error == REVISED) {

screen(NEW);

screen(UPDATE);

}

}

error = NO_ERROR;

}

kill();

if(error == ERROR) {

printf(“EGA Graphics Driver Not Installed”);

}

}

int setup()

/*

* SYSTEM INITIALIZATION

*

* This will initialize an EGA monitor and then initialize, and collect

* video parameters, and initialize the printer.

*

* January 29th, 1989.

*/

{

static int driver,

mode,

error;

/* Detect EGA driver and initialize */

detectgraph(&driver, &mode);

error = ERROR;

if(driver == EGA){

error = NO_ERROR;

initgraph(&driver, &mode, ““);

}

/* Initialize printer port */

biosprint(1, 7, 0);

/* get maximum x and y screen pixel coordinates */

xmax = getmaxx();

ymax = getmaxy();

return(error);

}

void screen(int option)

/*

* SCREEN LAYOUT/UPDATE

*

* This section will set up the screen with basic titles and headings.

* The section will also update the current values of beam parameters.

*

* January 29th, 1989.

*/

{

/* If instructed then clear screen and add titles */

if(option == NEW){

/* Clear screen */

cleardevice();

/* Add titles and instructions */

draw_line(.50, 0.0, .50, 1.0-DOUBLE_LINE_GAP);

draw_line(.5 + DOUBLE_LINE_GAP, 0.0, .5 + DOUBLE_LINE_GAP, 1.0-DOUBLE_LINE_GAP);

settextstyle(SANS_SERIF_FONT, HORIZ_DIR, 4);

text(.02, .014, “Beam C.A.D.”);

settextstyle(SMALL_FONT, HORIZ_DIR, 6);

text(.31, .06, “by Hugh Jack”);

settextstyle(SMALL_FONT, HORIZ_DIR, 4);

setcolor(GREEN);

text(INPUT_LEFT, INPUT_TOP - .10, “F1 - QUIT F3 - SCREEN PRINT F4 - HARDCOPY”);

text(INPUT_LEFT, INPUT_TOP - .07, “Use UP and DOWN Cursors to select Parameter”);

text(INPUT_LEFT, INPUT_TOP - .04, “enter new paramter and press RETURN to accept”);

setcolor(WHITE);

box(INPUT_LEFT, INPUT_BOTTOM, INPUT_RIGHT, INPUT_TOP, GREEN, NEW);

}

/* If instructed then update beam information */

if(option == UPDATE){

/* Calculate new output parameters from input parameters */

calculations();

/* Show input data */

text(.05, .13, “Beam”);

sprintf(work, “Type : %s”, beams[beam_type]);

text(.08, .18, work);

sprintf(work, “Material : %s”, materials[beam_material].name);

text(.08, .23, work);

text(.05, .28, “Cross Section”);

sprintf(work, “Thickness : %.3f in.”, beam_thick);

text(.08, .33, work);

sprintf(work, “Height : %.3f in.”, beam_height);

text(.08, .38, work);

sprintf(work, “Width : %.3f in.”, beam_width);

text(.08, .43, work);

text(.05, .48, “Span”);

sprintf(work, “Length : %.3f in.”, beam_length);

text(.08, .53, work);

sprintf(work, “Load Posit.: %.3f in.”, beam_point);

text(.08, .58, work);

sprintf(work, “Load : %.3f lbs.”, beam_load);

text(.08, .63, work);

/* Print Calculated Parameters */

sprintf(work, “Beam Cross Sectional Area in^2: %.3f”, beam_area);

text(.56, .55, work);

sprintf(work, “Weight lbs.: %.3f”, beam_weight);

text(.56, .59, work);

sprintf(work, “Axial Stiffness lb. / in: %.3g”, axial_stiffness);

text(.56, .63, work);

sprintf(work, “Bending Stiffness lbs / in^2: %.3g”, bending_stiffness);

text(.56, .67, work);

sprintf(work, “Maximum Beam Deflection in.: %.3g”, beam_deflect);

text(.56, .71, work);

/* Draw cross section and loading diagrams */

picture(beam_type);

}

}

void calculations()

/*

* CALCULATE BEAM PARAMETERS

*

* The global values of the beam parameters are use to calculate

* the other output variables of the beam parameters.

*

* February, 9th, 1989.

*/

{

/* locate general centroid */

x_centroid = x_axis = beam_width / 2.0;

y_centroid = y_axis = beam_height / 2.0;

/* find moment of inertia for solid beam and later subtract

hollow sections for various beam types. */

moment_inertia = beam_width*beam_height*beam_height*beam_height/12.0;

if(beam_type == I_BEAM) {

beam_area = beam_thick*(2*beam_width + beam_height - 2*beam_thick);

moment_inertia = moment_inertia - (beam_width-beam_thick)*pow((beam_height-beam_thick), 3.0)/12.0;

}

if(beam_type == CHANNEL_BEAM) {

beam_area = beam_thick*(2*beam_width + beam_height - 2*beam_thick);

x_centroid =(pow(beam_width, 2.0) + (beam_height - 2*beam_thick)*beam_thick)/(beam_width + (beam_height - 2*beam_thick))/2.0;

moment_inertia = moment_inertia - (beam_width-beam_thick)*pow((beam_height-beam_thick), 3.0)/12.0;

}

if(beam_type == SOLID_BEAM) {

beam_area = beam_width*beam_height;

}

if(beam_type == HOLLOW_BEAM) {

beam_area = beam_thick*(2*beam_width + 2*beam_height - 4*beam_thick);

moment_inertia = moment_inertia - (beam_width - 2*beam_thick)*pow((beam_height-beam_thick), 3.0)/12.0;

}

if(beam_type == L_BEAM) {

beam_area = beam_thick*(beam_width + beam_height - beam_thick);

x_centroid = (beam_width*beam_width +(beam_height-beam_thick)*beam_thick)/2.0/(beam_height + beam_width - beam_thick);

y_centroid = (beam_height*beam_height +(beam_width-beam_thick)*beam_thick)/2.0/(beam_height + beam_width - beam_thick);

moment_inertia = (beam_width*pow(y_centroid, 3.0) - (beam_width-beam_thick)*pow((y_centroid-beam_thick),3.0)+beam_thick*pow((beam_height-y_centroid), 3.0))/3.0;

}

axial_stiffness = beam_area * materials[beam_material].modulus;

bending_stiffness = materials[beam_material].modulus * moment_inertia;

beam_weight = beam_area * materials[beam_material].weight * beam_length;

/* find deflection of beam under loading */

deflect_point = pow((beam_point*(2 * beam_length-beam_point)/3.0), .5);

beam_deflect = beam_load*(beam_length - beam_point)/(3.0*bending_stiffness*beam_length)*pow(deflect_point, 3);

}

int input()

/*

* INPUT MANAGER

*

* User input functions are handled through this subroutine. These

* functions include numerical input and checking, watching function

* keys, and issuing proper feedback for executive control.

*

* January 28th, 1989.

*/

{

int up_down,

error,

flagger,

count;

double x,

y,

inpoff;

char in;

error = 0;

/* set flag for cursor movement */

up_down = 0;

/* Do boxes and prompts for current input */

x = list[entry_number].posx;

y = list[entry_number].posy;

box(x-.01, y+.045, x+.30, y-.015, GREEN, NEW);

text(INPUT_LEFT+2*DOUBLE_LINE_GAP, INPUT_TOP+4*DOUBLE_LINE_GAP, list[entry_number].name);

text(INPUT_LEFT+2*DOUBLE_LINE_GAP, INPUT_TOP+.05, list[entry_number].help1);

text(INPUT_LEFT+2*DOUBLE_LINE_GAP, INPUT_TOP+.08, list[entry_number].help2);

inpoff = textwidth(list[entry_number].name)/xmax+.01;

work[0] = 0;

count = 0;

/* Loop while numbers are being entered */

setcolor(WHITE+BLINK);

/* cursor marker */

text(INPUT_LEFT+inpoff+(count+1)/100.0, INPUT_TOP+.02, “_”);

setcolor(WHITE);

/* screen for too many chars, and no control keys */

while((count < 12) && ((in = getch()) != ENTER) && (in != 0)) {

if(((in >= ‘0’) && (in <= ‘9’)) || (in == ‘.’) || ((in == ‘-’) && (count == 0))) {

/* update input string */

work[count] = in;

count++;

work[count] = 0;

/* update screen input line */

sprintf(work2, “%c”, in);

text(INPUT_LEFT+inpoff+count/100.0, INPUT_TOP+.02, work2);

/* Cursor update */

setcolor(WHITE+BLINK);

text(INPUT_LEFT+inpoff+(count+1)/100.0, INPUT_TOP+.02, “_”);

setcolor(WHITE);

setcolor(BLACK);

text(INPUT_LEFT+inpoff+(count)/100.0, INPUT_TOP+.02, “_”);

setcolor(WHITE);

}

/* beep in case of input error */

else { printf(“\007”);}

}

/* look for control and cursor keys */

if(in == 0) {

in = getch();

if(in == DOWN_ARROW) up_down = DOWN;

if(in == UP_ARROW) up_down = UP;

if(in == F_1) error = DONE;

if(in == F_3) {

if(printes() == ERROR) {error = PRINTER_ERROR;}

else {error = REVISED;}

}

if(in == F_4) {

if(printer() == ERROR) {error = PRINTER_ERROR;}

else {error = REVISED;}

}

count = 0;

}

/* Check for numerical input error */

if((count > 0) && (count < 12)) {

error = enter();

up_down = DOWN;

}

if(count == 12) error = ERROR;

/* Clear input box and indicate error if they have occured */

box(x-.01, y+.045, x+.30, y-.015, BLACK, NEW);

box(INPUT_LEFT, INPUT_BOTTOM, INPUT_RIGHT, INPUT_TOP, GREEN, UPDATE);

if((error == ERROR) || (error == PRINTER_ERROR)) {

printf(“\007”);

if(error == ERROR) {

error = ERROR;

text(INPUT_LEFT+2*DOUBLE_LINE_GAP, INPUT_BOTTOM-.05, “INPUT ERROR - (Hit any key to clear)”);

}

if(error == PRINTER_ERROR) {

error = REVISED;

text(INPUT_LEFT+2*DOUBLE_LINE_GAP, INPUT_BOTTOM-.05, “PRINTER ERROR - (Hit any key to clear)”);

}

getch();

box(INPUT_LEFT, INPUT_BOTTOM, INPUT_RIGHT, INPUT_TOP, GREEN, UPDATE);

}

/* update to new menu choice */

entry_number = entry_number + up_down;

if(entry_number < 0) entry_number = 7;

if(entry_number > 7) entry_number = 0;

return(error);

}

int printer()

/* BEAM DUMPER

*

* This routine will prepare the screen and dump it to an EPSON type

* printer. This will not do the printing, but will use the routines

* PRINTES() to do the printing.

*

* February 2nd, 1989.

*/

{

static double xx,yy;

/* Do the time sort of thing */

time_t timet;

struct tm *times;

time(&timet);

times = localtime(&timet);

/* Clear input boxes on current screen */

xx = list[entry_number].posx;

yy = list[entry_number].posy;

box(xx-.01, yy+.045, xx+.30, yy-.015, BLACK, NEW);

box(INPUT_LEFT-2*DOUBLE_LINE_GAP, INPUT_BOTTOM, INPUT_RIGHT+2*DOUBLE_LINE_GAP, INPUT_TOP-.15, BLUE, UPDATE);

box(INPUT_LEFT-2*DOUBLE_LINE_GAP, INPUT_BOTTOM, INPUT_RIGHT+2*DOUBLE_LINE_GAP, INPUT_TOP-.15, BLACK, NEW);

box(DOUBLE_LINE_GAP, 1 - DOUBLE_LINE_GAP, 1 - DOUBLE_LINE_GAP, DOUBLE_LINE_GAP, BLUE, NEW);

/* Add design date to screen */

text(INPUT_LEFT, INPUT_TOP-.05, “Design Date :”);

text(INPUT_LEFT, INPUT_TOP, asctime(times));

return(printes());

}

int printes()

/* SCREEN DUMPER

*

* This routine will copy the screen to an EPSON type

* printer. This will constitute a hard copy output. This routine was

* prepared with the help of a basic routine written by Peter Budgell and

* Bernard Julien. The basic operation is to read a pixel from the

* screen and then print it.

*

* February 2nd, 1989.

*/

{

static int x, y, z, count, bit, error;

/* Continue if no error */

if((error = ((int)(biosprint(2, 7, 0)) & ERROR_BIT)) == 0) {

/* Prepare printer */

biosprint(0, 27, 0);

biosprint(0, ‘A’, 0);

biosprint(0, 8, 0);

for(y = 0; y < (int)xmax; y = y + 8) {

biosprint(0, 27, 0);

biosprint(0, ‘L’, 0);

biosprint(0, (int)(2*(ymax+PAGE_OFFSET))%256, 0);

biosprint(0, (int)(2*(ymax+PAGE_OFFSET))/256, 0);

for(x = 0; x < PAGE_OFFSET; x++) {

biosprint(0, 0, 0);

biosprint(0, 0, 0);

}

for(x = (int)ymax; x > 0; x--) {

count = 0;

bit = 1;

for(z = 7; z >= 0; z--) {

count = count + bit*(getpixel(y+z, x) != BLACK);

bit = bit + bit;

}

biosprint(0, count, 0);

biosprint(0, count, 0);

}

biosprint(0, 13, 0);

biosprint(0, 10, 0);

}

error = NO_ERROR;

}

else error = ERROR;

return(error);

}

int enter()

/*

* ENTRY CHECKER

*

* This routine will use the previous input value to determine input

* validity, and update valid inputs. The value will be taken from

* the WORK string and then considered for the current input.

*

* January 28th, 1989.

*/

{

double f_result;

int i_result,

error;

/* Prepare for analysis */

f_result = atof(work);

i_result = atoi(work);

error = ERROR;

/* check for no value */

if(work[0] == 0) error = NO_ERROR;

if(error == ERROR) {

/* Update beam type */

if((entry_number == 0) && (i_result > 0) && (i_result < L_BEAM+2)) {

error = NO_ERROR;

if(beam_type != i_result-1) error = REVISED;

beam_type = i_result-1;

}

if((entry_number == 1) && (i_result > 0) && (i_result < ALUMINUM+2)) {

error = NO_ERROR;

if(beam_material != i_result-1) error = REVISED;

beam_material = i_result-1;

}

if((entry_number == 2) && (f_result > 0.025) && (f_result < beam_width/2) && (f_result < beam_height/2)) {

error = NO_ERROR;

if(beam_thick != f_result) error = REVISED;

beam_thick = f_result;

}

if((entry_number == 3) && (f_result > beam_thick*2.0) && (f_result < 60.0)) {

error = NO_ERROR;

if(beam_height != f_result) error = REVISED;

beam_height = f_result;

}

if((entry_number == 4) && (f_result > beam_thick/2.0) && (f_result < 60.0)) {

error = NO_ERROR;

if(beam_width != f_result) error = REVISED;

beam_width = f_result;

}

if((entry_number == 5) && (f_result > 0.0) && (f_result < 200.0) && (f_result >= beam_point)) {

error = NO_ERROR;

if(beam_length != f_result) error = REVISED;

beam_length = f_result;

}

if((entry_number == 6) && (f_result >= 0.0) && (f_result <= beam_length)) {

error = NO_ERROR;

if(beam_point != f_result) error = REVISED;

beam_point = f_result;

}

if((entry_number == 7) && (abs(f_result) < 10000000.0)) {

error = NO_ERROR;

if(beam_load != f_result) error = REVISED;

beam_load = f_result;

}

}

return(error);

}

void text(double x, double y, char *text)

/*

* Text Utility

*

* A routine to make text statements more readable, by allowing entry in

* normalized coordinates.

*

* January 28th, 1989.

*/

{

outtextxy(x * xmax, y * ymax, text);

}

void draw_line(double x1, double y1, double x2, double y2)

/*

* Line Utility

*

* A routine to simplify line statements by allowing normalized calls.

*

* January 30th, 1989.

*/

{

line((int)(x1*xmax), (int)(y1*ymax), (int)(x2*xmax), (int)(y2*ymax));

}

void box(double x1, double y1, double x2, double y2, int color, int refresh)

/*

* Box Drawer

*

* This routine will simply draw a box with double lines , or erase

* the contents.

*

* January 28th, 1989.

*/

{

int temp_color;

temp_color = getcolor();

setcolor(color);

/* Draw outer box */

draw_line(x1, y1, x2, y1);

draw_line(x2, y1, x2, y2);

draw_line(x2, y2, x1, y2);

draw_line(x1, y2, x1, y1);

/* Draw inner box */

draw_line(x1 + DOUBLE_LINE_GAP, y1 - DOUBLE_LINE_GAP, x2 - DOUBLE_LINE_GAP, y1 - DOUBLE_LINE_GAP);

draw_line(x2 - DOUBLE_LINE_GAP, y1 - DOUBLE_LINE_GAP, x2 - DOUBLE_LINE_GAP, y2 + DOUBLE_LINE_GAP);

draw_line(x2 - DOUBLE_LINE_GAP, y2 + DOUBLE_LINE_GAP, x1 + DOUBLE_LINE_GAP, y2 + DOUBLE_LINE_GAP);

draw_line(x1 + DOUBLE_LINE_GAP, y2 + DOUBLE_LINE_GAP, x1 + DOUBLE_LINE_GAP, y1 - DOUBLE_LINE_GAP);

/* Erase box contents if flag set */

if(refresh == UPDATE) {

setfillstyle(SOLID_FILL, BLACK);

floodfill((int)(((x2 + x1)/2.0)*xmax), (int)(((y1 + y2)/2.0) * ymax), color);

}

setcolor(temp_color);

}

void picture(int draw_beam)

/*

* Beam Drawer

*

* This section will produce all beam graphics and dimensions

*

* January 30th, 1989.

*/

{

static int x_s,

x_e,

y_s,

y_e,

cx1,

cx2,

cx3,

cx4,

cx5,

cx6,

cy1,

cy2,

cy3,

cy4,

cy5,

cy6,

x_offset,

y_offset,

x_c_offset,

y_c_offset;

static double scale_x,

scale_y,

px,

py,

de,

offset;

x_s = xmax/2 + 3*EXTENSION + 40;

y_s = ymax/2 - 15;

x_e = xmax - 5;

y_e = 22 + EXTENSION;

if(x_axis != x_centroid) y_e = y_e + EXTENSION;

if(y_axis == y_centroid) x_s = xmax/2 + 2*EXTENSION + 40;

if(beam_width < beam_height){

scale_x = (x_e - x_s) / beam_height / X_Y_RATIO;

scale_y = (y_e - y_s) / beam_height;

};

if(beam_width >= beam_height){

scale_x = (x_e - x_s) / beam_width / X_Y_RATIO;

scale_y = (y_e - y_s) / beam_width;

};

cx1 = x_s;

cx2 = x_s + (int)(scale_x * beam_thick);

cx3 = x_s + (int)(scale_x * (beam_width - beam_thick) / 2);

cx4 = x_s + (int)(scale_x * (beam_width + beam_thick) / 2);

cx5 = x_s + (int)(scale_x * (beam_width - beam_thick));

cx6 = x_s + (int)(scale_x * beam_width);

cy1 = y_s;

cy2 = y_s + (int)(scale_y * beam_thick);

cy3 = y_s + (int)(scale_y * (beam_height - beam_thick) / 2);

cy4 = y_s + (int)(scale_y * (beam_height + beam_thick) / 2);

cy5 = y_s + (int)(scale_y * (beam_height - beam_thick));

cy6 = y_s + (int)(scale_y * beam_height);

x_c_offset = cx1 + scale_x * x_centroid;

y_c_offset = cy1 + scale_y * y_centroid;

x_offset = cx1 + scale_x * x_axis;

y_offset = cy1 + scale_y * y_axis;

setcolor(WHITE);

/* Title for cross section */

if(x_axis != x_centroid)

{outtextxy(cx1 - EXTENSION, cy6 - 2*EXTENSION-15, “BEAM CROSS SECTION”);}

else {outtextxy(cx1 - EXTENSION, cy6 - EXTENSION-15, “BEAM CROSS SECTION”);}

/* Title for beam deflection */

text(.54, .76, “EXAGERATED BEAM DEFLECTION (simple supports)”);

setcolor(CYAN);

if(draw_beam == I_BEAM) {

moveto(cx1, cy1);

lineto(cx6, cy1);

lineto(cx6, cy2);

lineto(cx4, cy2);

lineto(cx4, cy5);

lineto(cx6, cy5);

lineto(cx6, cy6);

lineto(cx1, cy6);

lineto(cx1, cy5);

lineto(cx3, cy5);

lineto(cx3, cy2);

lineto(cx1, cy2);

lineto(cx1, cy1);

}

if(draw_beam == CHANNEL_BEAM) {

moveto(cx1, cy1);

lineto(cx6, cy1);

lineto(cx6, cy2);

lineto(cx2, cy2);

lineto(cx2, cy5);

lineto(cx6, cy5);

lineto(cx6, cy6);

lineto(cx1, cy6);

lineto(cx1, cy1);

}

if(draw_beam == SOLID_BEAM) {

moveto(cx1, cy1);

lineto(cx1, cy6);

lineto(cx6, cy6);

lineto(cx6, cy1);

lineto(cx1, cy1);

}

if(draw_beam == HOLLOW_BEAM) {

moveto(cx1, cy1);

lineto(cx6, cy1);

lineto(cx6, cy6);

lineto(cx1, cy6);

lineto(cx1, cy1);

moveto(cx2, cy2);

lineto(cx2, cy5);

lineto(cx5, cy5);

lineto(cx5, cy2);

lineto(cx2, cy2);

}

if(draw_beam == L_BEAM) {

moveto(cx1, cy1);

lineto(cx6, cy1);

lineto(cx6, cy2);

lineto(cx2, cy2);

lineto(cx2, cy6);

lineto(cx1, cy6);

lineto(cx1, cy1);

}

/* Draw beam for bending display */

line((int)(.60*xmax), (int)(.90*ymax), (int)(.60*xmax), (int)(.88*ymax));

line((int)(.90*xmax), (int)(.90*ymax), (int)(.90*xmax), (int)(.88*ymax));

if(fabs(beam_deflect/beam_length) > 0.00001) {

de = beam_length/6.0*beam_deflect/fabs(beam_deflect);

for(px = 0.0; px <= deflect_point; px = px + beam_length/200){

py = ((de-de*pow(((deflect_point -px)/deflect_point), 2.0))/beam_length) * (.1) + .88;

putpixel((int)((.6+px/beam_length*.3)*xmax), (int)(py*ymax), CYAN);

putpixel((int)((.6+px/beam_length*.3)*xmax), (int)((py+.02)*ymax), CYAN);

}

for(px = deflect_point; px <= beam_length; px = px + beam_length/200){

py = ((de-de*pow(((px-deflect_point)/(beam_length - deflect_point)), 2.0))/beam_length) * (.1) + .88;

putpixel((int)((.6+px/beam_length*.3)*xmax), (int)(py*ymax), CYAN);

putpixel((int)((.6+px/beam_length*.3)*xmax), (int)((py+.02)*ymax), CYAN);

}

}

else {

line((int)(.60*xmax), (int)(.90*ymax), (int)(.90*xmax), (int)(.90*ymax));

line((int)(.60*xmax), (int)(.88*ymax), (int)(.90*xmax), (int)(.88*ymax));

}

/* Fill Beam Cross section if thick enough */

setfillstyle(LTSLASH_FILL, 7+beam_material);

if(((cx2-cx1) > 2) && ((cy1 - cy2) > 2)){

floodfill(cx1 + 1, cy1 - 1, CYAN);

floodfill(cx1 + 1, cy6 + 1, CYAN);

}

setcolor(RED);

/* Beam Length Dimension */

line(xmax*.60, ymax*.90 + 3, xmax*.60, ymax*.90 + EXTENSION);

line(xmax*.90, ymax*.90 + 3, xmax*.90, ymax*.90 + EXTENSION);

line(xmax*.60, ymax*.90 + 10, xmax*.90, ymax*.90 + 10);

sprintf(work, “%.3f in.”, beam_length);

text(.61, .94, work);

/* Force Position Location */

offset = .30 * (beam_point / beam_length) + .60;

line(xmax*.6, ymax*.88 - 3, xmax*.6, ymax*.88 - EXTENSION);

line(xmax*offset, ymax*.88 - 3, xmax*offset, ymax*.88 - EXTENSION);

line(xmax*.6, ymax*.88 - 10, xmax*offset, ymax*.88 - 10);

line(xmax*offset, ymax*.88 - 3, xmax*offset -3, ymax*.88 - 8);

line(xmax*offset, ymax*.88 - 3, xmax*offset +3, ymax*.88 - 8);

sprintf(work, “%.3f in.”, beam_point);

text(offset+.01, .84, work);

sprintf(work, “%.3f lb.”, beam_load);

text(offset, .79, work);

/* Beam Width Dimension */

line(cx1, cy1+3, cx1, cy1 + EXTENSION);

line(cx6, cy1+3, cx6, cy1 + EXTENSION);

line(cx1, cy1 + 10, cx6, cy1 + 10);

sprintf(work, “%.3f in.”, beam_width);

outtextxy(cx1 + 10, cy1+15, work);

/* Height and Thickness Dimensions */

settextstyle(SMALL_FONT, VERT_DIR, 4);

line(cx6+3, cy1, cx6+EXTENSION, cy1);

line(cx6+3, cy6, cx6+EXTENSION, cy6);

line(cx6+10, cy1, cx6+10, cy6);

sprintf(work, “%.3f in.”, beam_height);

outtextxy(cx6 + EXTENSION, cy1-10-textwidth(work), work);

/* Draw Thickness Dimension for all but solid beam */

if(beam_type != SOLID_BEAM) {

line(cx1-EXTENSION, cy1, cx1-3, cy1);

line(cx1-EXTENSION, cy2, cx1-3, cy2);

line(cx1-10, cy1, cx1-10, cy1+15);

line(cx1-10, cy2, cx1-10, cy2-15);

sprintf(work, “%.3f in.”, beam_thick);

outtextxy(cx1-15, cy2-10-textwidth(work), work);

}

/* Principal and centroid y axis dimensions */

line(cx1-EXTENSION, cy1, cx1-2*EXTENSION, cy1);

line(cx1-EXTENSION-3, y_offset, cx1-2*EXTENSION, y_offset);

line(cx1-EXTENSION-10, cy1, cx1-EXTENSION-10, cy1+15);

line(cx1-EXTENSION-10, y_offset, cx1-EXTENSION-10, y_offset-15);

sprintf(work, “%.3f in.”, y_axis);

outtextxy(cx1-EXTENSION-15, y_offset-10-textwidth(work), work);

if(y_axis != y_centroid) {

line(cx1-2*EXTENSION, cy1, cx1-3*EXTENSION, cy1);

line(cx1-2*EXTENSION-3, y_c_offset, cx1-3*EXTENSION, y_c_offset);

line(cx1-2*EXTENSION-10, cy1, cx1-2*EXTENSION-10, cy1+15);

line(cx1-2*EXTENSION-10, y_c_offset, cx1-2*EXTENSION-10, y_c_offset-15);

sprintf(work, “%.3f in.”, y_centroid);

outtextxy(cx1-2*EXTENSION-15, y_c_offset-10-textwidth(work), work);

}

settextstyle(SMALL_FONT, HORIZ_DIR, 4);

/* Principal and centroid x axis dimensions */

line(cx1, cy6-3, cx1, cy6 - EXTENSION);

line(x_offset, cy6-3, x_offset, cy6-EXTENSION);

line(cx1-EXTENSION, cy6-10, cx1, cy6-10);

line(x_offset, cy6-10, x_offset+EXTENSION, cy6-10);

sprintf(work, “%.3f in.”, x_axis);

outtextxy(x_offset + 10, cy6-EXTENSION, work);

if(x_axis != x_centroid) {

line(cx1, cy6-EXTENSION-3, cx1, cy6 - 2*EXTENSION);

line(x_c_offset, cy6-EXTENSION-3, x_c_offset, cy6 - 2*EXTENSION);

line(cx1-EXTENSION, cy6-EXTENSION-10, cx1, cy6-EXTENSION-10);

line(x_c_offset, cy6-EXTENSION-10, x_c_offset+EXTENSION, cy6-EXTENSION-10);

sprintf(work, “%.3f in.”, x_centroid);

outtextxy(x_c_offset + 10, cy6 - 2*EXTENSION, work);

}

/* Draw Center Line */

setcolor(YELLOW);

setlinestyle(CENTER_LINE, 0, NORM_WIDTH);

line(x_offset, cy1+5, x_offset, cy6-5);

line(cx1-5, y_offset, cx6+5, y_offset);

/* Draw Centroid Line */

setcolor(MAGENTA);

setlinestyle(DASHED_LINE, 0, NORM_WIDTH);

line(x_c_offset, cy1+5, x_c_offset, cy6-5);

line(cx1-5, y_c_offset, cx6+5, y_c_offset);

setlinestyle(SOLID_LINE, 0, NORM_WIDTH);

/* Restore original Color */

setcolor(WHITE);

}

void kill()

/*

* Close Graphics Routines

*

* This will deinitialize the graphics routines initialized earlier.

*

* January 20th, 1989.

*/

{

closegraph();

}

?