. as; E
.v . a .... ...
u . .7... .2
$43.??? .6?
. .

.Mmama, ..., .m» was .m... .

4. . r.

.35 , . .

. ...; . 2......“ .

.... haggcnd.

..urn’anr

Akfrimunw... .

. M959. 5...“.

......

II I
a! z

4 u:
Akin
......

 

 

"If! . .r. . .
9...». .. mimw

.P.l\

MP
.9:

‘4.

 

.1?! x . . .
kit u.

. .7 ..

...“waxug . . HI...
.’v.§n)‘4 .

.1.

h‘“
t 4
...:w.§tt§ {3.3
...uawumnruanﬂ 1..
1...... r.
ff.

xxcl.‘ :7 in:
.. (Gillan)

..lr

. «admin
7...... Infill..-
) 2411.3..«3
.|.Lan!D!

14%;“.

.. . ....

2.3.5.
...

<3 - if.
1...!!!"
>I,.\ . ‘3’... .... IA
50. ib‘vxnnk: 5"
n.3,!"vl2312i.
. iii.- A ~II .
39%;... l r .
'L. ’2»‘.

v. . xl.0

.I 2".

.u... r. ...», -.,
. a: ... ..."...thﬂosSLLLhmmn...‘ ...}...isiflthi z. ! I i,
...... -... ...ut)..i.z.§nﬁﬂu»n.15gﬁunﬂ!new11..wmmﬂﬁu.
, . . l .3... .th9g 1.. L.
..-- . «$92....

I‘lI

 

w.
1,.‘r'ﬂ‘313
-~-‘.‘t\.‘

‘3)

R 95.

IMillillllllllllllI
L! :3 *2 A W

n' . -. .,. c4 .1.
-,. 1. ~ , _,‘ t ,."I\
E13; ' 95‘3“" h wtfgi‘...’

'f‘jg
University

 

 

 

 

Thisistoceiﬁfythntthe

thesis entitled
Internet-Based Design/Manufacturing Process Management

presented by
Hun Gu
has been accepted towards fulﬁllment

of the requirements for
may“ inMsszlmiss

W game,

Major mfasor
Date N92, 9. 1292
0-7639 MS U is at 407m ActiaI/Equd Opportunity Institution

Internet-Based Design/Manufacturing Process Management
By

Hua Gu

A DISSERTATION

Submitted to
Michigan State University
in partial fulﬁllment of the requirements
for the degree of

MASTER OF SCIENCE

Department of Material Science and Mechanics

1999

ABSTRACT

INTERNET-BASED DESIGN/MANUFACTURING PROCESS
MANAGEMENT

By

Hua Gu
Competition in mechanical engineering today demands ever-faster product
development, hence ever-shorter design cycles, which may be achieved by eﬁ'rciently
rearranging design and manufacturing processes. The necessity of such management
depends on adjusting design process to accommodate constraints and frequently
updating them to make full use of the new design tools and methodologies. Meanwhile,
it is also a trend that design and manufacturing processes or activities are modularized

and integrated in a geographically distributed environment.

In response to the growing demand for a robust infrastructure that coordinates
design and manufacturing activities, this thesis presents a web-based engineering
framework, which coordinates various CAD/CAM and FEM systems, provides product
data relationships, and integrates with manufacturing processes. In this thesis, the
current capabilities of the framework are demonstrated in conjunction with benchmark
studies on functionally gradient materials (FGMs) design, and the design and
manufacturing of a gearbox In FGMs design, a design approach is represented using the
framework to obtain the distribution of the reinforcing phase that minimizes the stresses

in axisymmetric bodies subjected to temperature gradients and pressure differentials. In

the design and manufacturing process of a gearbox, the framework autonomously
performs a series of stress and fatigue analyses and searches for a set of parts that satisfy
various requirements. It is also veriﬁed that the framework is capable of integrating
seamlessly the design results with manufacturing operations by selecting cutting tools,
machining conditions, and sequence of operations. The framework enables users to check
the results ranging from graphical display of the design to the CNC code generated to

machine the designed shafts.

© Copyright 1999 by Hua Gu

All Rights Reserved

To my wife Ying

Acknowledgements

I would like to take this opportunity to express my appreciation to a number of

people, without whom my thesis could never have been completed

First, my sincere gratitude goes to my advisor, Dr. Patrick Kwon. Dr. Kwon has
been my advisor since my enrollment at Michigan State University. He has taught me
many things in mechanics and manufacturing. He provided me with valuable guidance,
the inﬂuence of which on my personal and technical development will be carried forward
into my future endeavors. Second, I cherish very much the advice from my co-advisor,
Dr. Moon-Jung Chung. Dr. Chung provided valuable advice in the computer science
domain helping me with my cross-disciplinary research. I would also like to thank
Dr. Ronald Averill for giving me advice and encouragement, and for serving as member

of my thesis committee.

It is also a very pleasant experience to work with my fellow students,
Dave Kcyes, Behr Markus, Kuk-Jin Lee, and Lihua Chen. I sincerely appreciate the

help, encouragement, and friendship from them.

Last, but not least, I proudly share this accomplishment with my wife, Ying Sun.

I would also like to thank her for her everlasting support, patience, and love.

vi

Table of Contents

List of Tables ................................................................................ x
List of Figures ............................................................................... xi

Chapter 1. Introduction 1
1.2. Engineering Design 2
1.3. Concurrent Engineer 4
1.4. Manufacturing Process 5

1.4.1 Introduction .................................................................. 5
1.4.2 Machining Process Automation 6
1.5. CAD, CAM and Integrated CAD/CAM 7
1.5.1 Computer-Aided Design (CAD) 7
1.5.2 Computer-Aided Manufacturing 8
1.5.3 CAD/CAM Integration 9
1.6 Mechanics Analysis Process ......................................................... 10
1.7 The Internet 10
1.7.1 Data Communication 10

1.7.2 Networking and Internet 11

Chapter 2. Process Management for Design/Manufacturing and Mechanics
Analysrs l3

211ntroductron 13
2.2. Automated Design/Manufacturing Process and Mechanics Analysis... . .. . . . 15
2.3. Why Java 18
2.4 State of the Art ......................................................................... 21

vii

2.5 The MIDAS System ....................................................................

Chapter 3. Design/Manufacturing Process Management Framework
3.1. Introduction
3.2. System Architecture
3.3. System Cockpit
3.4. External Tools
3.5. Representation ofa Process Flow

3.5.1 Basic Elements ofA Process
3.5.2 Process Grammar ......................................................................................

Chapter 4. Benchmark I -- Gearbox Design and Manufacturing ...............
4.1. Overview
4.2.1. Pre-selectron
4.2.2. Gear/Pinion/Shaft Selection
4.2.3. Material Selection
4.2.4. Static Analysis
4.2.4.1. Static Forces
4.2.4.2. Stress Analysis
4.2.5. Bearing Selectron
4.2.6. Fatigue Analysrs
4.2.6.1. Surface Factor ..
4.2.6.2. Size Factor
4.2.6.3. Reliability Factor
4.2.6.4 Goodman line and Stress Concentration
4.3. Manufacturing
4.3.1. Solid Modeling
4.3.2. Manufacturing

4.4. Conclusions

viii

21

23
23
23
24
27
33
33
35

37
37
4o
40
41
45
46
46
49
52
54
55
56
56
57
60
6o
63
63

Chapter 5 Benchmark II - Design of Functionally Gradient Materials ....... 64

5.1 Introduction ............................................................................. 64
5.2 Eﬁ‘ective Properties .................................................................. 65
5.2.1 Elastic Properties ............................................................ 65
5.2.2 Thermal Expansion Coefﬁcient ............................................ 67
5.2.3 Thermal Conductivity ....................................................... 67
5.2.4 Homogcnization of Inhomogeneous Properties .......................... 68
5.3 Formulation ........................................................................... 69
5.4. Materials ............................................................................... 72
5.5 "Multiple-version" Process Flow .................................................... 72
5.6 Thermal Loading and Internal Pressure ............................................. 75
5.6.1 Thermal Loading ............................................................. 75
5.6.2 Internal Pressure .............................................................. 76
5.7 Conclusions ............................ . ................................................. 77

Chapter 6. Conclusions 78
6.1. Contributions 78
6.2. Future Work ................................................................................................. 80

Appendix A. Sample HTML File Used to Invoke the Remote Servers
and the MIDAS Framework’s Java Applet ............................. 84

Appendix B. Sample Unix Shell Scripts Used to Invoke Remote Servers
Through CGI ................................................................ 85

Appendix C. Major Applet Class ......................................................... 87
Appendix D. Sample Code of the Interface Between the Framework and Tools ...94
Appendix E. Sample Execution Procedure and the Input/Output ..................... 124

References ..................................................................................... 127

ix

List of Tables

Table-1 Material Factors .................................................................... 41
Table-2 Pressure vs (Df ...................................................................... 41
Table-3 Pitch vs maximum operational tangential tooth load ......................... 42
Table-4 Radial and Thrust Factors ......................................................... 54
Table-5. k, - R relationship ................................................................ 56
Table-6 Room temperature properties of matrix and reinforcement ................... 72
Table—7 Second-phase distribution functions used ...................................... 73

List of Figures

Figure-1. Basic module in the design process (after Asomow) 3
Figure-2. Model of Concurrent Engineering (after Dieter) 4
Figure-3. Product Development Steps 5

Figure-4. Types of Process Management Systems (after Klein) l4

Figure-5. Automated Design/Manufacturing Element 17
Figure-6. System Cockpit 24
Figure-7. Communication Model 31

Figure-8. Graphical Representation 33
Figure-9. Selector and Database 34
Figure-10. An Example ofthe Process Grammar 35

Figure-11. Graphical ofa Logical Task 35

Figure-12. 2-stage Parallel Gear Systems 37
Figure-l3. Two-stage Parallel Gearbox Illustrative Diagram 38
Figure-14. A overall design-manufacturing process ﬂow diagram of gearbox ...... 39
Figure-15. Pressure Angle 42
Figure-16. Concatenation of Gear/Pinion Database and the Shaft Database ...... 45
Figure-l7. Forces and Moment Exerted on a Helical Gear and its Shaft 46
Figure-18. Combined Loading Decomposition ofa Shaft 47
Figure-19. Cross section of a shaft and stress distribution on it ....................... 50

Figure-20. Stresses in the combined loading ............................................. 50

xi

Figure-21. Stresses at Dangerous Points 52

Figure-22. The ﬁllet radius of the bearing ring .......................................... 54
Figure-23. Goodman line .................................................................. 57
Figure-24. Interpolation process .......................................................... 58
Figure-25. Solid modeling processes ...................................................... 62
F i gure-26 FMGs design ﬂow chart created by the framework ......................... 74
Figure-27 Temperature ﬁelds in three type of FGMs ................................... 75
Figure-28 von Mises stress in three types of FGM ...................................... 76
Figure-29 von Mises stress in FGMs subjected to internal ........................... 77

xii

Chapter 1

Introduction

1.1 Design

What is design? A dictionary shows a deﬁnition which stated that to design is to
fashion after a plan. The essence of a design process is to create something, in one way or
another, that has never been. In most cases, an engineering designer practices design

following that deﬁnition[1 ].

From a general point of view, most design problems are typically open-ended and
ill-structured. Design problems are open-ended because they usually have more than one
acceptable solution. Unlike in many mathematical and analytical problems, the quality of
uniqueness, or best solution, simply does not apply. Design problems are ill-structured
because their solutions cannot normally be found by routinely applying a mathematical
formula in a structural way[2]. Design problems possess these two characteristics
because the challenge imposed on design is not only simply to create something that
accurately reﬂects the existing domains. It is also necessary to provide for the creation of
new domains and to simultaneously produce and transform objects and regularities of the

world that we are concerned with[3].

Given that design has such characteristics, it is no surprise that no single
universally acclaimed sequence of steps properly describes a workable design process.
However, we still can see that most design processes share certain common steps in its
approaches or strategies which include:

. Recognition of a need

. Deﬁnition of a problem

. Synthesis and conceptualization

. Analysis and optimization

. Evaluation

. Presentation of the optimal Design
Since we have mentioned that design problems are ill-structured, the above steps may be
carried out either sequentially or simultaneously . Moreover, feedback of each step may

lead to an iteration which is akin to most kinds of design processes.

1.2 Engineering Design
In general, we can call any design problem which is involved in any engineering

activity an engineering design. It is perhaps the most important and biggest subset in the

design realm.

Engineering design has some unique features. At very abstract level, we can
adopt the deﬁnition articulated by Dym and Levitt:
Engineering design is the systematic, intelligent generation and evaluation of

specifications for artifacts whose form and ﬁmction achieve stated objectives

and satisﬁz speciﬁed constraints[4].

From a practical and simpliﬁed point of view, engineering design can be properly
illustrated using the basic module by M. Asimow [5]. He viewed the essential
aspect of the design process as consisting of the elements shown in the ﬁgure(Figure-1)
below[1]. A design problem, especially an engineering design problem, can be
decomposed into basic modules shown in Figure-1. We adopt this simple model of
design process because this very model makes it possible to divide a complex design
process into small elements which inherit all general features of design. Thus,
computer-based automated management of large design activity is possible because

computers are capable of dealing with inheritance.

 

 

General Information

 

 

 

 

 

 

     

Design

 

Speciﬁc Information -—-—> Outcome

 

 

 

Operation

  
 

 

 

Rollback .
G No j Evaluation

=
Y .

Yes

 

 

 

 

 

 

 

 

 

Go to next ste .

llt

Figure-1. Basic module in the design process (after Asomow)

1.3 Concurrent Engineer

Today, design has become a multi-threaded process, which carries more than one
child design process concurrently. This very characteristic of modern design requires
teamwork approach which is called concurrent engineering(CE) in the creation or
improvement of new products. Generally speaking, concurrent engineering, also called
simultaneous engineering, is a design approach which incorporates product design and
product manufacturing in an intimate way[6]. However, the concurrent engineering
concept is more than simply to integrate design and manufacturing at the start of the
design process . It can be illustrated using Dieter’s Model(Figure-Z) of concurrent

engineering[ 1 ].

 

 

 

 

 

 

 

Production
Sales and
< > System

Distribution \\ /
Desrgn
Manufacturing /

Figure-2. Model of Concurrent Engineering (after Dieter)

 

 

 

 

 

 

 

 

 

 

 

 

 

According to this model of concurrent engineering, product development should

integrate design with other tasks such as manufacturing planning, quality, and marketing.

Products are developed more quickly and often at a lower cost with higher quality by
simultaneously performing these tasks along with the use of modern design tools. This
approach addresses issues pertaining to a product’s entire life cycle. It also typically
includes the use of computer tools like computer-aided design, shared databases, and
computerized standards to help bring about efﬁcient and accurate communications and to
automate the design process as much as possible. In other words, today, concurrent
engineering is usually computerized. Computer, as a machine, requires logical or
mathematical modeling of a desired product. Thus concurrent engineering’s success is
heavily dependent upon the availability of a good standardized description of the

components of a product[7].

1.4 Manufacturing Process
1.4.1 Introduction

Generally speaking, even with the use of advanced technology, the approach to
product development still involves several steps, each of which must be completed before

the next step in design can begin. These steps are listed as follows.

' Design I

Prototyping

 

 
 

   

 

process Planning and Manufacturing Programming

     

 

. Manufacturing I

 

Figure-3. Product Development Steps

At the present time, using the framework implemented in this research, design can
be accomplished to such a level that a 3-D solid model can be visually displayed. At the
same time, it can convert the model to Stereo Lithographic (STL) format for rapid
prototyping. Furthermore, after the tool path has been determined, cutter location data or
even the NC codes (still premature) can be generated according to the tool path
information for machining. Solid modeling is the step that uniﬁes design and
manufacturing seamlessly. Solid model data can also be used as the inputs for a ﬁnite-
element analysis program. It is also used to conduct generative machining to produce
numerical machining code. In this way, design and manufacturing becomes one

integrated process.

1.4.2 Machining Process Automation

As one of the most commonly used processes today, machining process
automation has gained its popularity. There is a strong incentive for manufacturers to
increase the level of automation within their operations and by taking advantage of the
available software tools. As a way to enable the operation of machines by using a series
of computer-based instructions comprised of numbers, letters, and other symbols,
numerical control (NC) makes machines run consistently, accurately, predictably, and
essentially automatically. Based on the design information, NC programming process
mostly and typically consists of ﬁve major functions:

1. Creating the geometric model (rapid prototyping can also be done using this

model);

2. Establishing the machining process plan;

3. Generating the toolpath;
4. Post-processing;

5. Simulation and veriﬁcation.

1.5 CAD, CAM and Integrated CAD/CAM

The last two decades have witnessed extensive inﬁltration of computer
technologies into the design and manufacturing activities in engineering domains.
Starting with simple computer-aided drafting, this process has proceeded towards various

levels of sophistication in automated design and manufacturing systems.

The purpose of this section is to show readers some basic underlying concepts of
CAD, CAM and integrated CAD/CAM processes. Since the framework also has strong

impact on automated mechanics analysis processes, main features of mechanics analysis

are presented.

1.5.1 Computer-Aided Design (CAD)

Computer-aided design is aimed at the engineering design functionality, rather
than the less creative drafting function of the industrial enterprise. To a certain extent,
modern computer-aided design software usually provides users with drafting utilities with
a capability for engineering analysis. A modern computer-aided design system is
expected to incorporate a set of analytical tools as well as extensive graphing utilities to
fulﬁl the needs of both design and drafting functions. Implementation of such system

will inevitably lead towards the full integration of the entire design-to-manufactrm'ng

(DTM) process [8]. In an integrated system, a very direct advantage is that the geometry
created in the CAD process can be used as a basis to carry out other functions in
computer-aided manufacturing, which will be discussed hereafter. This helps engineers

to avoid the waste of time as well as errors resulting from having to redeﬁne the

geometry from scratch.

1.5.2 Computer-Aided Manufacturing (CAM)

The result of computer-aided design or any other designing processes is a virtual
product. CAM deals with the physical work done on the factory ﬂoor through which the
virtual product is frnally turned into a real product. Factory equipment may consist of
robots, multiple-axis machine tools, and programmable controllers, which can be ﬂexibly
conﬁgured to produce different parts and interconnected to set up a computer-integrated
manufacturing (CIM) system. Numerical control (NC) is one of the most mature areas of
CAM[9]. The numerical control was introduced much earlier than the introduction of
modern CAD and CAM systems. Computerized-numerical-control (CNC) and
distribution-numerical-control (DNC) are two derivatives of the NC technology. In a
CNC mode, a lathe or a milling machine is controlled by a simple computer using NC
code. In DNC mode, an NC-controller receives its program via a communication line
hooked up to a remote computer. Originally, the development of CAM systems were
mainly conceived to produce the voluminous NC code for numerically controlled
machining. Advanced CAM systems have features like assisting the task of process
design and implementation of designing modiﬁcations, rather than merely generate the

NC code. Now, through computer graphics, tool-path motions can be easily veriﬁed

Computer can thus generate NC code based on the geometric data ﬁ'om the CAD
database. In fact, many CAD/CAM systems have this capability routinely built into their

software packages.

1.5.3 CAD/CAM Integration

Unfortunately, CAM systems have been evolving independently of CAD
systems. The separated evolutions resulted in a formidable barrier to the further
development of the concurrent systems [10]. Most of the existing CAD systems require
high human interaction. Those systems are not designed to be parametric and rule-
driven. Responsibility for detailing, dimensioning, tolerancing, and rule-checking is
largely under the control of the computer-assisted draftspersons for whom, errors are
inevitable to make. To eliminate human errors, interface between CAD and CAM
systems was developed to deal with the conversion and transmission of detailed design
data. In order to implement such a well-interfaced seamless design-to-
manufactm'ing(SDTM) system [11], a preferred approach is to make the system
parametric and rule-based. In parametric and rule-based design, designers start with
parametric relationships in the prospective design as well as applicable rules and end up
with the design as parametric-mathematical representations plus its geometrical
model. The procedure of such a designing approach is ideal for computerization and
automation. In our research, we build a web-based framework which enables the merger

of CAD and CAM processes distributed over the internet.

1.6 Mechanics Analysis Process

Mechanics analysis is, to a certain extent, indispensable in most engineering
design and manufacturing processes. It shares many common aspects with modern
design and manufacturing processes. Most mechanics analyses can be represented either
analytically or numerically by mathematical models, which are highly parametric. In
other words, most mechanics analyses can be dealt with parametrically. A large-scale
mechanics research project may be conducted in different locations using different
approaches. For example, an EU (European Union) pressure vessel solar heating
research project, may be carried out using analytical methods, FEM and experimental
methods in different places for a number of solar conditions. That is to say, researchers
in several locations should deal with various cases using different methodologies while
sharing different aspects of the project. Thus, communications between different
participants is important. Based on these facts, process management methodologies
applicable for engineering design and manufacturing processes are suitable for most

mechanics analyses and researches.

1.7 The Internet

1.7.1 Data Communication

Imagine a scene like this: a human operator goes to a machine and reads the
display from its controller, and then goes to another machine to key in the readings into

its controller. This typically happens where machines cannot communicate directly.

10

 

Since most controllers are computerized, point-to-point communication between them is
possible and is not too expensive to implement. Such one-to-one data transmission can
be accomplished using serial or parallel communication. In short, serial communication
allows the 8 bits of a character to be transmitted through one single wire while in parallel
communication the 8 bits of each character travel simultaneously on 8 wires. Parallel

communication is faster than serial communication.

Although these two forms of data communications are inexpensive to
implement, they are limited by their communication speed as well as the point-to-point
communication topology. Think of a design group with its personnel as well as its CAD
and CAM software distributed on different shop-ﬂoors or even on signiﬁcantly distant

locations, computer networking would be a wiser and better choice to handle such data

communication.

1.7.2 Networking and Internet

In our research, we set up an Internet-based framework to carry out CAD/CAM
process management. Before we cast our sight upon the Internet, let us take a look at the

basics of the computer networking.

Local area networks (LANs), are privately-owned networks within a single
building or campus of fairly limited size. LAN links computers within a limited area so

that they can share ﬁles or printers. One computer, which is called server, can provide

11

disk space for other computers. The topology of LANs, or in other words, the way in
which machines are hooked up, is usually ring, star(with one of the computers at the

center), or bus( all in parallel).

WAN, which stands for wide area network, spans a large geographical area, often
a country or continent. Each computer on the network is called a node or end system and
is frequently called on to pass along messages to other computers. WAN allows users to
transfer ﬁles, mail electronic messages, and remotely log on to other computers. Each
end system can either be a machine inside a LAN which is hooked up to a switching

computer (or router) of the WAN or be directly attached to the router.

A internetwork is a collection of interconnected networks. It is often used to refer
to a collection of LANs connected by a WAN. The Internet means a speciﬁc worldwide
internetwork connecting universities, government ofﬁces, companies as well as

individuals.

In other words, Internet means “network of networks”. It dates back to the old
ARPAnet which stands for the US Department of Defense’s Advanced Research Project
Agency network[7]. Now Internet is no longer limited within the military domains.
Basic services of the Internet provides include: electronic mail, interactive conferences,

access to information resources, network news, and the ﬁle trans fer utilities.

12

Chapter 2
Process Management for Design/Manufacturing and

Mechanics Analysis

2.1 Introduction

Complex high-tech products are designed with increasing design are
manufacturing concerns by processes distributed over time, geography, participants, and
functionality. Design of any complex commercial artifacts or design of a process of a
complicated modern mechanics analysis may require a group of people possessing
different specialties spread over several continents with a time span of several decades.
Since such processes are multi-dimensional (time, geography and participants are
regarded as different dimensions), integrated and interdependent, effective coordination
within each dimension and between different dimensions is the essence to the success of
such processes. In a traditional design and manufacturing environment, the complexity
of such interdependency will result in a coordination that incurs great amount of
redundant expenditures as well as delayed schedules, hence reduced quality of the

product although individual productivity may be relatively high.

Modern process management often needs to have the following features:
1)Participants involved in the process should be able to share information in all
dimensions. 2)All participants should update descriptions of the shared

design/manufacturing process timely. 3) Ensuring that the joint actions between each

13

 

party of a shared design/manufacturing process are coordinated to achieve the desired

results as efﬁciently as anticipated.

The systems implementing the current process management technologies are
listed as follows according to the capabilities of which they impose constraints on how a
process can be performed [18] (please refer to Figure-4). Traditional manual systems
hardly impose any constraints with regard to how a process should be carried out. Ad
hoc systems are largely dependant upon the users’ decisions. It is basically an
email-based system used to route a work package once its destination is determined.
Both systems provide tracking utilities. Some structured conversation systems are
designed based upon the contract net [19] or speech act approach [20]. They have a
system-imposed protocol that allows them to arrange the distribution of the tasks.
Workﬂow systems set up a process ﬂow using text-based or drawing tools. Once the
process ﬂow is set up, the participants in the process simply perform their respective

tasks.

Structured Workflow

Manual Ad-hoc Conversations Interpreters
$

 

Degree of Limits Imposed by Process Management Tools

F igure-4. Types of Process Management Systems (after Klein)[7]

l4

2.2 Automated Design/Manufacturing Process and Mechanics Analysis

In a complex process, there may be a number of tasks which are inter-dependent.
These inter-dependencies can be represented by data speciﬁcations and transitions. Data
speciﬁcations are usually data ﬁle stored somewhere on-line. Transition shows direction
of the data ﬂow. The whole process may be so complicated that it can be split into
smaller sub-tasks. In some cases, for each task or even sub-task, there may be different
approaches available for the participants to complete the task or sub-task. There are also
constraints for each task which shape the process. Most manual and structured
conversation systems do not support the imposition of such constraints, nor can these
systems model how the tasks are sequenced. It is the human participants who make all

the decisions in complex process that lead to the ﬁrll execution for the whole process.

Workﬂow systems are able to impose constraints and we can deﬁne a process
ﬂow in a very detailed way using such systems. However, such systems model a process
in a ﬁxed or rigid manner, which means such a way of modeling would become
inefﬁcient should there be more than one approach or should any change occur.
Moreover, just like the structured conversation systems, these systems are also merely
electronic schedulers. All tasks are performed manually by individuals or a group or
groups of people which could be located at one place or scattered all over the world In
other words, no matter what kind of existing process management system you use, the

execution of the whole process ﬂow is continuous and fully automatic.

15

One of the goals of the research is to develop a new approach to automate the
execution of a distributed design/manufacturing process. Based on the basic element
discussed in the ﬁrst chapter, a simpler and more generalized elementary model was
derived for both design and manufacturing. In order to automate the whole process, we
need to have a task representation which is corresponding to a “design operation” or any
operation inside a mechanics analysis. The task representation is connected to an
executable program which is encoded to perform that task. As mentioned before, both
general information and speciﬁc information is consumed by a task. Information can be
interpreted as data, hence input data speciﬁcations are used to replace the general
information and speciﬁc information. In an automated system, differentiating the
speciﬁc information from the general information is a redundant step and it is advisable
to unify these two to allow for more ﬂexibility. Since there may be more than one
information source, it is rational to have multiple data input representation for a single
task. Direction of the input data is represented by a transition arrow, which shows where
the data comes from and how a task converts them into other data. The “outcome” in the
previous model is replaced with output data speciﬁcations. Just as the input, output may
need to reside in more than one data speciﬁcation. In some cases, different portions of the
output data are consumed by different tasks corresponding to different programs located
either on the same system or on other systems. Dividing the output into smaller data
blocks will save the time spent on data transmission. It may also lessen the amount of
time for the destination software to process the data, hence better performance. The
“evaluation” ﬁmction in the previous model is implicit here. It could be incorporated into

the too] if it is fairly “rigid”, which means it does not tend to be subject to change very

l6

 

often. On the contrary, if it is ﬂexible, the system will provide the user with pre- or post-
evaluation utilities to conduct the evaluation. It is also the pre/post-evaluation utilities

that enable the user to impose constraints that shape the process.

 

 

 

 

Input Data 1 Output Data 11

 

 

 

 

 

 

 

 

 

 

Output Data 1 Output Data m

\ _/
V—

Outputs
Figure -5, Automated Design/Manufacturing Element

 

 

 

The system leaves it to the user to determine, either at their own convenience or based on
the nature of the constraints, whether it is hard-coded or imposed using the system’s
pre/post-evaluation ﬁrnctionality. As to the feedback loop and the alternatives for
participants to perform a task, the system provides managerial tools to implicitly
implement the feedback and choose alternatives. The major managerial tool is a linear

scheduler used to organize the execution of the whole process.

Since we have identiﬁed the design process element with its manufacturing
counterpart, we may easily set up a seamless design-to-manufacturing process ﬂow
diagram based on the above-mentioned model. It is also very easy to make use of this

model to represent any mechanics analysis process not only because the mechanics

17

analysis is similar to design process but also because it is discipline-independent. The
system has build-in tools and graphical interface to help the user to set up and execute a
process. Most of the traditional process management systems are just managerial tools
or schedulers which require engineers to perform a task embedded inside a process ﬂow.
The system implements a design/manufacturing automation. Each node inside a process
ﬂow is associated with either a tool software or a data ﬁle containing information. The
human participants in traditional process management has been replaced by software
tools which are typically parametric. Remember, as is mentioned before, it would be
ideal for us to implement an integrated CAD/CAM system parametrically. Since we are
conceiving a process management system that is able to automate globally distributed
design and manufacturing processes, we need to design system which is platform-

independent. We will address this issue in the forthcoming section.

2.3 Why Java

In a modern a company, different departments are involved in a design process. It
is rational to assume that each department corresponds to a task which can either be a
decomposable task or an non-decomposable elementary task. In order to perform those
tasks, each department has its own software tools running on their own systems. Based
on the design/manufacturing model we have discussed before, most software tools need
to have input data. Unfortunately, these input data could be output data generated by
other departments or could be stored on other systems. The other departments may not
necessarily be located at the same place. Meanwhile, different departments may use

different operating systems. The goal of this research is to design a process managerial

18

system capable of executing embedded tools on various kinds of operating systems.
Therefore, the system itself should be able to run platform-independent. From an end-
user’s point of view, people tend to pick up their own machine or any machine with
internet utility to run their process management. It is unnecessary to design platform-
independent tool software. It is wise to set up a process management system that runs
err-line and is able to invoke software tools stored on any other intemet-connected

systems. Based on those facts, Java provides the important characteristics to develop our

system.

Initially called “Oak”, Java got its name in 1995 and was published the same year.
Originally, Java was designed to be a platform-independent language used to create
software embedded in consumer electronic devices. By 1993 the Java design team
realized that it could be adapted for internet programming and switched. It was a wise
switch that led to the success of Java. Now, just as what C was to operating systems, Java

has become a language for the Internet.

As a programming language, Java can generate two types of programs:
applications and applets. An application is an executable program running locally. It is
quite similar to those programs created by C or C++ . However, it has a very distinct
feature: it works in a Java virtual machine which makes the program platform-
independent. By analogy, the Java virtual machine is somewhat like an interpreter while
the Java program and the operating system are two persons the interpreter is talking to.

No matter what kind of language the operating system is using, this interpreter always

19

speaks “Java” with the Java program. Just as applications, Java applets are also platform-
independent. However, without applets Java would not be very different than other
programming languages. An applet is a program transmitted through Internet and run by
an Java-based web browser. It is a small piece of program dynamically downloaded via
the Internet. Unlike image ﬁles, sound ﬁles or video clips, Java applets are executed
dynamically so that they are highly user-interactive and changing dynamically in

response to the users’ input.

Making full use of these features of Java, our system is also designed to be
platform-independent and is expected to be put on-the-ﬂy over the Internet available to
be executed on any operating system. Therefore, platform-dependent CAD/CAM
software tools may be embedded regardless of the operating system. The participants are
free to choose their own programming language because our Java-encoded system will
invoke them on their own operating system. Java is also outstandingly capable of
handling networking communication. Data consumed or generated by the software tools
are delivered or directed by our Java-encoded process management system. Details of

the communication will be discussed in the next chapter.

Based on what features are intended to have for the framework and what Java is

capable of doing, it is chosen to implement our system.

20

 

 

 

2.4 State of the Art

Advancement in the information technology has inﬁltrated into many aspects of
our life. Collaborations between scientists and engineers are expected to be linked by
high performance Internet services such as Internet H and the Defense Research and
Engineering Network (DREN). Based on the latest information technology, DOD has
launched a number of programs to develop process management infrastructure: Rapid
Prototyping of Application Speciﬁc Signal Processor (PASSP) [12], Manufacturing
Automation and Design Engineering (MADE) [l3], and RaDEO (Rapid Design
Exploration and Optimization) [14]. To a certain degree, Internet has been used as a
medium to manage design and manufacturing activities [15]. It serves as a pool of
design information such as CAD drawing, analysis techniques or a list of off-the-shelf
parts [16]. A framework designed to manage distributed business and electronic

commerce on the information superhighway was developed by Andreoli et al [17].

2.5 The MIDAS System

In real practice, CAD/CAM processes arise when a given task is too large to be
performed effectively by a single individual and thus must be divided into sub-tasks to
achieve the top-level goal. Tasks in such a process may require some synchronization in
task execution. A rational execution mechanism must be implemented to avoid
contention for the use of some shared resources. Since a process is composed of a

number of high-level tasks and low-level sub-tasks, it should be decomposed while it is

executed.

21

However, most existing or proposed process management systems do not have a
mathematical formalism to capture a process in a discipline independent format. Without
such a formalism, task decomposition, execution synchronization, and constraint

handling are difﬁcult for most process presentations.

In this thesis, readers are presented with a new process management framework
with such formalism that can be utilized to manage complex design and manufacturing
processes. This framework is named as MIDAS, which stands for Manufactruing
Integration and Design Automation System. With such a generalized process formalism,
MIDAS provides a means to incorporate many specialized tools such CAD and FEM
packages, and to specify acceptable methodologies and available tools. Its use is not
limited to process management. Mechanics analysis, which shares many common
features with CAD/CAM processes, can be easily captured by MIDAS. It also enables
the users to adapt design changes efﬁciently and facilitates the exchange of information
among participants using the Internet. Most importantly, MIDAS allows users to select
tools and methodologies, and to optimize a process conﬁguration within a given set of

constraints.

22

Chapter 3

Design/Manufacturing Process Management Framework

3.1 Introduction

Based on the concepts we introduced in the previous chapters, our own process
management framework was implemented mainly using Java 1.02. MIDAS is a Java applet
that is rtmning over the Internet on any Java-compatible web browser. It is a tool that is used
to create, manage, and execute a process located anywhere on the Internet. In this chapter, the
conﬁguration of the ﬁ'amework, the components of the a process ﬂow, and process software

tool integration are addressed.

3.2 System Architecture

In this section, we will take a look at the major components of the Process
Management Framework as well as their organization and frmctionality. Detailed descriptions
of the major concepts involved in the architecture of our process management framework will
also be discussed, including external tool integration, the tool invocation process, Java File

System, and state properties.

23

3.3 System Cockpit
The MIDAS framework has an integrated interface called cockpit (see Figure-6)
where all interactions between the user and the system take place. The cockpit is

implemented as a Java applet which can be loaded via a Java-enabled web browser.

BesidesﬁmcﬁMngasﬂnusermmrthoemresystancmkmtalsopmvidesmecme
ﬁmcﬁomﬁtyofﬂreprocessmamgememﬁamewoﬂcAlﬂroughdiﬂ‘erentmsmayuse
diﬁemmmsmnesofthecmkpitamesameﬁmeﬁinctwﬂabomﬁmbaweenmmﬁpleusem
iscrmentlymrdertesting.

 

File Conﬁguration Mode Browse

 

 

 

 

 

( Flow
. .
M e Mdrtrng
Buttons
providing
different
ﬂow-editing <
ﬁrnetionality

 

 

 

 

 

 

 

 

 

 

 

F igure-6. System Cockpit

24

The system cockpit provides the following functionality:

Flow editing. Users may construct and edit process ﬂows using the ﬂow editing panel

 

of the cockpit. The ﬂow editing panel or the ﬂow editor provides the users with a graphical
interface with a number of functional buttons to set up a ﬂow. Flow layout can be optimized
via services provided by a remote layout server encoded in Perl. The Cockpit manages the
connection to and communication with the layout server through the Internet. This layout
editing utility is associated with the “ edraw” button. By clicking on that button get the

current messy layout of the ﬂow reorganized

Production Library Maintenance. Production library provided by the cockpit is used

 

to help user with production maintenance. This functionality is realized by the cockpit’s
production editor. Users may organize productions, modify input/output sets, create or edit
individual productions by using ﬂow editor and the production browser. The production
browser is especially useful when user would like to create a production which is similar to an
existing one. Using the production browser and the ﬂow editor users may easily create a new
production by simply instantiating the existing production. All existing productions are stored

in the production library.

Class Library Maintenance. Similar to production, libraries of task and speciﬁcation
classes are also provided in a general-to—speciﬁc manner. During the construction of a ﬂow,
users are allowed to instantiate a class into an actual task, speciﬁcation, or database by simply
dragging the appropriate class from a class browser, and dropping it onto the ﬂow editor’s

canvas. The class libraries are displayed in the form of a tree structure in the cockpit. In other

25

words, every object, no matter whether it is a task or speciﬁcation, is an instance of a class on

a certain level in the class tree hierarchy.

Process Simulation and Execution. Processes may be simulated or executed using the
cockpit. Several scheduler modules controlling how the process conﬁguration space will be
explored are provided Since the tools may be located externally on other servers, execution
of the ﬂow is carried out by invoking the appropriate external tools. Therefore simulation of
the execution of the extem tools which are actually running on other machines is necessary.
Simulation display, or in other words, ﬂow animation, are provided on the cockpit canvas for
users to monitor the execution progress graphically. The animation is realized using different
colors. Yollew for unavailable, green for ready, blue for available, white for execution in
process, and red for execution failure. Since the process is dynamic, user may recognize
which tool is running, which speciﬁcation is ready, or whether an execution of a tool is
successful or has failed There are currently two kinds of schedulers available for the users to
choose. They are the manual scheduler, and the comprehensive linear scheduler. When the
user is going to execute a process ﬂow, he/she will need to choose between manual mode and
automatic mode. These two modes are actually corresponding to the above-mentioned two
kinds of schedulers. Users are also provided with text-based proxy monitor for both manual
and automatic modes. When nmning automatic mode, scheduler monitor is also invoked to
show users tool execution information and scheduler information. These two monitors, in
conjunction with the animation simulation, provide users with a complete view of a running

scenario.

Process Files. A process ﬂow exists in the form of a ﬁle. The cockpit allows

 

processes to be archived on a remote server using the Java File System (JFS). The cockpit is

26

enabled by a JFS client interface to connect to a remote JFS server where process ﬁles are
saved and loaded While the JFS system has its clear advantages, it is also awkward not to
allow users to save process ﬁles, libraries, and etc. on their local systems. Therefore, the
current framework is conﬁgured to allow users to open or save a process ﬂow ﬁle on the
server from which the cockpit applet is loaded Not until version 1.1 of the Java Developer’s

Kit(JDK), local storage by a Java applet was simply not allowed.

3.4 External Tools

As mentioned earlier, each atomic or terminal task in a process ﬂow is corresponding
and bound to an external tool. In Run mode, when user expands an atomic task in the cockpit,
the corresponding external tool is invoked as though it was invoke under text-based
command-line. Therefore, a simple negotiation is required to execute a remote external tool.
In the previous chapter, our elementary process module was discussed Inputs and outputs are
two major constructs. Accordingly, an external tool uses a series of inputs and creates a series
of outputs contained in ﬁles. Just as the tools, the inputs and outputs are bound to
speciﬁcations in a ﬂow. Except for initial inputs and ﬁnal outputs, inputs to be consumed by
one tool are generated by other tools. In previous versions of the process management
framework, all tools wee located on a public ﬁle system, which was called the Server File
System. This ﬁle system allowed the tools to communicate with each other consuming and
creating input and output ﬁles on it. Now the latest version of framework allows the tools to
access and to generate their input and output ﬁles on remote sites. On each one of those

remotes sites, there is a site proxy server working in conjunction with a remote ﬁle server.

27

These two servers automatically handle the transmission of ﬁles from one system to another

during the runtime.

Users are free to choose the languages to implement their external tools. The only
requirement is that the platform where a tool is located should have the capability of running a
site server. External tools encoded in C, Fortran, Perl, UND( shell script, Java, I-Deas open
language, and Mathematica scripts have been tested A simple protocol is used to execute an

external tool:

1) The tool should be able to run under command-line (from a shell prompt or a DOS
prompt). The Java.lang.runtime package provides mechanisms for the site proxy server to
invoke external commands. However, the Java Virtual Machine is implemented on many
platforms in such a way that it does not allow the system to set up a working directory
before an external process is executed from within a Java application. In order to
overcome this barrier, it was necessary to write a Perl wrapper that is called ﬁ'om the site

proxy server, and then executes the external tool.
2) The tool must be capable of parsing the following command line format:

toolname <commandlineoptions> INPUTS i1 i2... iN OUTPUTS 01 02 03 0M

where i1, i2, i3,... W are the names of the N input ﬁles that the tool must be able
to open and execute, and o], 02, 03 0M are the names of the M output ﬁles that

the tool should produce.
If the tool is a selector, then the command becomes:

28

Selector <c0mmand line options> INPUTS i1 i2 iN OUTPUTS 01 02 03
.. 0M DB database] database2 DatabaseT ITEM I

Where database] database2 DatabaseT are names of the T databases to be
consumed by the selector; The ﬂag ITEM and the number i which follows it

are used to indicate which record inside the temporary database is picked.

3) The input ﬁle names sent off to the proxy server for it to execute may not be
necessarily sent in the same sequence for any two different invocations of the tool.
That is to say the tools should be designed in a such way that it has the capability of

recognizing the input ﬁle types.

The user-deﬁned external tools are supposed to be integrated into an abstract process
ﬂow ready to execute using the process management framework Two steps are involved in
incorporating tools with a process ﬂow: association and execution. Association includes
binding an external tool or a remote ﬁle with an abstract ﬂow object. Execution is deﬁned to
represent the steps that the framework goes through to actually run the external tools and to

process their inputs and outputs.

The action of binding is actually to deﬁne a series of properties of a speciﬁc ﬂow
object. For an atomic task, the following properties must be deﬁned in order to set up a task-
tool bonding: 1) SITE. Since the ﬁamework can execute tools located at a remote site, we
need to deﬁne its location. Default SITE is speciﬁed within the system so that it may not be
necessary to specify the SITE property of each ﬂow object, unless its location is differert than

the default site. 2)CMDLINE. The CMDLINE property speciﬁes the command which will be

29

executed at the remote site deﬁned by the SITE property. The CMDLINE property should
include any switches or arguments that will be sent to the external tool. 3)WORKDIR
speciﬁes the tool’s working path under which the framework will actually invoke the external
tool, create temporary ﬁles, etc. Usually this property is also deﬁned in the global property
defaults. 3)WRAPPERPATH. Since the 1.0.2 version of the Java Development Kit (JDK)
does not allow an external program be executed in an user-speciﬁed directory, an extra layer
called a wrapper between the tool and proxy server must be constructed to simply change
directories and then execute the external tool. This layer can be a DOS/Windows NT batch
ﬁle, a shell script, or a perl program. The external tool is wrapped in this simple script, and
executed Since tools may be running on different platforms, the wrapper program has to be

platform-dependent.

Once the user has deﬁned all the above propeties for a task, this task is said to be
bound to an external tool. In case no site, directory, or ﬁlename is speciﬁed for the outputs of
the task, the framework automatically creates unique ﬁle names, and saves the ﬁles in the
working directory of the corresponding tool on the system where the tool is running. If a tool
uses an input that is not speciﬁed by any other task, the user must bind it to a remote static ﬁle.
The framework is conﬁgured to reckon all external tools and speciﬁcations as to be remote. In
other words, even if the tool is located physically on the same system where the user is

running the framework cockpit, the framework will still treat it as remote tool.

After all ﬂow objects are bound to theirs appropriate external tools or ﬁles, it is time to
use the framework to perform process management or tool execution In stead of directly

linking and executing a tool from the cockpit, the process management framework actually

30

hasseverallayerslyinginbetwenthecockpit andtheextermltoolthatisboundtoaﬂow. A
descriptionofeachlayerbetweenthetoolandﬂrecockpitislistedbelow.

 

 

Remote Site File System

E External Tool j

Liz-w
Proxy Monitor |

 

 

 

 

 

 

 

 

 

 

 

 

I Site File
._ mix—F Server
Site Proxy Server ]

 

 

“T if 2

Communication Server

 

 

 

 

 

< >

T

O
i
2
n'
l
D

 

Cockpit

 

 

 

Figure-7. Communication Model

Whenonelamrchesacockpit,loadsaﬂowﬁle,andinvokesanatomictask,the
cwkpitisacmaﬂymlkingdimalymamolproxy.Thewolproxyacmasahaisonhyer
betueentheprocess objectsloadedordeﬁnedinthecockpit andthesiteproxyserver
throughTCP/lPsockets. Itsendsinformationpackagesﬁomﬂrecockpitintothefonnof
stringmessagesthatisrecognizablebythesiteproxyserver. Attiresametime,italsowaits
formﬂp‘ocessesmewagesﬁomﬂwsnemxysaversemmmughmecmnmmiwdmssaver
anddirectstheinfonnaﬁontothecockpitobjectwheredretoolproxyisongimﬂylamrched

31

For the sake of security, direct TCP/IP socket connections between a Java Applet and
any IP address other than the address from which the Applet was loaded is forbidden. For this
reason, we are nmning a communications server on the system where the cockpit applet is

stored to listen for messages from tool proxies launched by any cockpit on the same channel.

Site Proxy Servers deal with invocation requests from tool proxies via the
communications server. When an invocation request is received, the site proxy server goes
through the message’s syntax. It then invokes a tool monitor to manage the external tool
invocation, and returns the exit status of the external tool after the tool execution is completed
It is reasonable to imagine that there may be more than one tool running on the same site. It
may take a signiﬁcant amount of time for each of the tools to complete its execution.
Therefore, waiting for the ﬁrst tools to complete its execution to launch the execution of the
next one would make our process management system very inefﬁcient. Thus the proxy server
launches a tool monitor for each external tool to be invoked Running as a separate thread, a
tool monitor waits on the tool, stores its standard output and mor message, moves any input
or output ﬁles to their appropriate site locations, and informs its calling site proxy server when
the tool has completed This scenario allows the site proxy server to process the forthcoming

invocation requests continuously without too much delay.

32

3.5 Representation of a Process Flow
3.5.1 Basic Elements of A Process

This framework uses a formalism called process ﬂow graphs to represent design
processes. A very simple process grammar is used to deﬁne and document a design-to—
manufacturing process. As mentioned before, it is not uncommon to have alternative
approaches to perform a task. The use of the formal process grammar makes the

alternative methods within a process easily identiﬁable.

 

Logical Task Atomic Task Speciﬁcation

_/ /

 

 

 

»

 

Transition
Figure-8. Graphical Representation
Based on the automated design and manufacturing process element discussed in the
previous chapter, four basic graphical elements for a process flow graph are shown in
F igure-8. Engineers can create design—to-manufacturing processes in a top-down fashion. In
the ﬁgure above, the four fundamental constructs are listed. Oval nodes represent Logical
Tasks; two concentric ovals represent Atomic Tasks; and rectangular nodes represent Data

Speciﬁcations. The arrow is called a transition.

A logical task can be further decomposed into some other lower-leveled logical tasks
or atomic tasks. It can be called a non-terminal task because it is decomposable. An atomic

task is something that cannot be decomposed any more. It is directly hooked up to an on-line

design or manufacturing software. Therefore, atomic task is also denoted as terminal task.
The relation between logical tasks and atomic tasks is somewhat like the relation between
folders and ﬁles. One may place small folders inside a big folder. In the meantime, he or she
may also put ﬁles inside this same folder. However, unlike folders which can be empty,
logical tasks cannot be empty. It should be able decomposed further and further until there are

only atomic tasks.

Speciﬁcation is used to represent on-line ﬁles, especially data ﬁles. The arrow, which
is denoted as transition, is used to show the directions of data ﬂows as well as to weave the

stand-alone tasks and data speciﬁcations into a complete process ﬂow.

There are two other very special derivative constructs which are used together to represent a

very special kind of terminal task called selector. A selector has at least one on-line database.

Connected to other data specification(s)

 

<—-——‘ Database

 

 

 

 

 

Connected to other data speciﬁcation(s)

Figure-9. Selector and Database

34

The graphical representations of these two constructs are shown in Figure-9. Just as how it is
named, a selector works out its results based on the user-deﬁned requirements or on its build-
in rules. Selectors share some common features although they are implemented ﬁeely by the
users. Since a selector may need to pick up its choice from a database according to the
requirements imposed by the users, it has its regular inputs just like other tasks do. It also has
one or more databases either hooked up to it or hard-coded No matter how it is implemented,
a selector always makes only one choice at one time. A recommended way of implementing a
selector is to go through the database to pick up all possrble solutions, and store them on a
temporary sub-database. Sort this sub-database in an order such that the possible best solution
comes the ﬁrst. The selector then picks up the ﬁrst record of this sorted sub-database as its
output. Should this output turn out to be a bad choice, the selector would choose the next
record in the sub-database until it makes a right decision or until the database is exhausted.
This simple selecting algorithm is recommended because the selector only sorts the database

once.

3.5.2 Process Grammar

After introducing the basic elements of a process ﬂow, we take a look at the very
simple process grammar. In order for the readers to understand the grammar, readers are
presented with a very straightforward example as shown in Figure-10. In Figure—10, the

language produced by

35

L—aAlB
A—>a
B—>bc

Figure-10. An example of the process grammar

this trivial grammar consists of two words: { a, bc}. An analogous design process grammar,
which is a type of graph grammar, is represented in Figure-l 1. Notice that logical task L has
two possible productions: alternative A, and alternative B. Applying either production will
produce a derivation of the original graph by replacing logical task L with the ﬂow graph

representing that alternative.

 

Output

Input Input

© Intern data

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Output Output
Output
Logical task L and its input Alternative A Altermtive B
and output

Figure-11. Graphical of a logical task

36

Chapter 4

Benchmark I ------ Gearbox Design and Manufacturing

4.1 Overview

Two benchmark projects, which are gearbox design and ﬁrnctionally gradient
materials design have been developed. In this chapter, attention will be focused on the

ﬁrst one which is the design of a two-stage parallel shaft gearbox.

1

 

[Ill

 

 

 

L

spur gear helical gear double helical gear
Figure-12. 2-stage parallel gear systems

For a two-stage parallel shaft gear system, there are usually three types choices of
gears: spur gears, helical gears, and double helical gears(see Figure-12). With the
advantage of low manufacturing cost spur gear may produce relatively high noise during
operation and can only provide limited torque. Helical gear can withstand higher torque
but they are more expensive and introduce thrust force during operation. In order to
balance the axial force, thrust bearings are required. Double helical gear is actually a
combination of a pair of helical gears which make the thrust force on a helical gear

canceled off with the thrust force on the other, hence no thrust bearings are required.

37

‘In the benchmark(see Figure—13) process management, only the design and
manufacturing of the shafts, the selection of gear/pinion pair and the bearings are
considered. There are three major stages involved in this design and manufacturing

process: pre-selection, analysis, and manufacturing.

 

 

 

 

 

 

 

 

 

 

 

 

B A
:3:222::ZZ¢ZZZZZZZIZI¢IZZZZEE
E j \E‘E‘Bearing
:.::::::::::ﬁ:::::::::J::::::::.E
output : LI". ........... g," coupling

Figure-13. Two-stage parallel gearbox illustrative diagram

38

 

 

 

 

 

 

   

1:133:23? 063511313309 - Pre-selection (included in the
,eqmmm) L, logical task StaticAnaIysrLs that

.: be further decomposed into
smaller tasks)

   
 
  

 

 

 

 

 

SelectedGPShaft

 

 

 

 

 

 

 

 

 

 

 

 

MataialProp ' SelectedFinish

 

 

 

 

 

Dynamic sis

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

ShaftASTL ShaﬁBSTL

 

 

 

 

 

 

 

 

Figure-14. A overall designvmanufacturing process ﬂow diagram of gearbox

The above high-level, unexpanded flow diagram provides us with an general
overview of the gearbox design and manufacturing process. The ﬁrst speciﬁcation
GearShaﬁReq is bound to a remote data speciﬁcation, which is a ﬁle containing the
initial requirements deﬁned by the users. It is to be consumed by the atomic tasked
included in the StaticAnalysis logical task The ﬁrst few atomic tasks are designed to

perform the pro-selection which provides the forthcoming tasks with possible choices of

39

different combinations of gear, pinion, shaft as well as material. The other atomic tasks
included in the StaticAnalysis are designed to work in conjunction with the tasks in
DynamicAnalysis to produce the detailed dimensions for both gear, pinion and shafts.
Results are stored in the data speciﬁcation named GearBoxDesign. Based on these
results, solid models of the design components are created in the logical task named
CalManufacturingData while CNC codes are generated in the task CADCAMCoversion

for machining the selected bar stocks into the designed shafts.

4.2 Design
4.2.1 Pre-selection

The design starts with pre-selection. The ﬁrst ﬂow object is the initial input data
speciﬁcation which includes the basic user-deﬁned requirements. In this benchmark,
design requirements include maximum output power, maximum rotational speed,
transmission ratio, design life and some geometrical requirements such as shaft length
and minimum rotational speed, transmission ratio, design life and some geometrical
requirements such as shaft length and minimum and maximum gear diameter. There is a
bind command button on the cockpit interface. By choking on the button and then click
on the initial input data speciﬁcation, you will be able to enter the location of the input
data ﬁle. This procedure is designed for the situation in which there are more than one

tentative input data ﬁle. Once the input data ﬁle is bound to the ﬂow, the design process

can begin.

40

4.2.2 Gear/Pinion/Shaft Selection

A number of Java programs have been composed to handle the gear/pinion
selection. As mentioned above, maximum output power, maximum speed, transmission
ratio, design life plus some geometrical requirements serve as the inputs. Some pre-
evaluation will be conducted to give the range of the pitch. This is to screen out any gear
size whose strength is not satisfactory under the given operating conditions. The formula
used to estimate the pitch range is as follows[21]:

W1=F.mf.<l>f.Wmax 4.1

Where, W. = maximum suggested transmission load (lbs)

= face width of gear(inches)

mf = material factor(see Table- 1)

(by = pressure angle factor(see Table-2)

Wmax = maximum suggested load(see Table-3)

 

Material 303 stainless 2024T4 Brass Nylon Delrin Polyrethane
steel Aluminum

 

 

 

 

 

 

 

 

mf l 1.2 0.7 0.34 0.28 0.14

 

Table-l Material Factors

 

 

 

 

Pressure Angle (Dr
20 deg. 1
14.5 deg. 0.8

 

 

 

Table-2 Pressure vs (bf

41

 

Diametral Pitch W
120 65
96 82
80 98
72 105

64 115
48 140
32 195
24 245
20 280
16 318
12 350

 

Table-3 Pitch vs maximum operational tangential tooth load

 

 

 

 

 

 

Figure-15. Pressure Angle

Theformulatoestimatethemaximmnloadofthegeartoothwasused Theactual
strength of the gear tooth can vary drastically under different operating conditions. The
standard loads listed in Table-3 are for well lubricated 303 stainless gears with 20°
pressure angle, 1 inch face width, pitch line velocity below 1500 fpm, and smooth
loading. The standard loads of pressure angles other than 20 degrees and 14.5 degrees
are interpolated or extrapolated The lowest designing speed and maximum output

power (assume there is no power dissipated) are used to work out the possible maximum

42

torque transmitted. Based on the torque and the relation tangential load = 2 x torque
/ pitch diameter, the maximum tangential load exerted on the tooth surface can be
estimated. On the other hand, the maximum suggested transmitted load can be calculated

using the formula W, = F Omf . 49f on. Compare the maximum tangential load with the

maximum suggested transmitted load W, for each gear in the gear database to get a list of
all gears whose strength is high enough to withstand the maximum required load. Since
the ﬁner gear teeth or higher pitch gives us higher precision, low backlash, and smoother
operation, the computer will sort that list of the gears in terms of their pitch with the
largest pitch listed ﬁrst. Computer will then pick up the ﬁrst record in the list as best
possible choice. If this choice works out all the way to the end of the design process,

there is no need to test the second one and the rest.

Once the pitch range is determined, it becomes one of the constraints in search of
proper gear/pinion pairs. The simple algorithm used to search for a gear/pinion pair is as
follows. The computer sorts the list of gears generated just new again in terms of the
pitch diameter. Then based on the transmission ratio and starting with the smallest gear
with largest pitch as a pinion, the computer begins to look for the gear simply by
multiplying the pinion diameter with the transmission ratio and searching for a gear with
exactly the same diameter until the list is exhausted and pick up another pinion. This
process stops when the value of the product of a pinion diameter and the transmission
ratio is greater than the diameter of the largest gear in the list. After going through the
gear list thoroughly, all possible gear/pinion combinations are saved on a temporary ﬁle.

These choices satisfy all the geometrical requirements contained in the initial input. The

43

selector invoked will also automatically sort the temporary data pool in terms of a certain
ﬁeld or certain set of ﬁelds according to some built-in rules that guarantee the design will
tend to be the most economical. In short, the built-in rules are deﬁned to try the smallest
gear ﬁrst to make sure that it tends to be economical. As mentioned before, this built-in
sorting procedure is inferior to and may be overruled by any arbitrary order issued by the
framework. This is reasonable because guaranteeing that it be economical may incur

sacriﬁces in some other respects.

Based on the previous outputs, corresponding shafts are picked up from a shaft
database. These shafts are chosen according to some geometrical constraints such as bore
size. Naturally, gear and pinion shafts may be different in size. The computer will also
concatenate gear/pinion pairs with their selected shafts and sort and save them on a
new temporary data pool. Then the selector will pick up a record on that temporary data
pool and produce a one-record ﬁle as its output. The temporary data pool may be re-

established if the framework issues such an order (see Figure-l6).

Gear/Pinion Record 1

Gear/Pinion Record 2 .. '-

Shaft Record 3

   

Matching Process

New record 1: Gear/Pinion Record 1 & Shaft Record 3

New record 2: Gear/Pinion Record 2 & Shaft Record 1

 

Figure-l6. Concatenation of gear/pinion database and the shaft database

4.2.3 Material Selection

A material selector also needs to be activated to choose the possibly satisfactory
types of materials by looking up through a material database. Only one material will be
chosen at a time. The material selector shares all general features with other selectors.
Properties of a speciﬁc kind of material is saved on an output ﬁle and will be used by

other tools.

45

4.2.4 Static Analysis
4.2.4.1 Static Forces

Using the formulae in solid mechanics, calculations are conducted in order to
produce the key static forces which are to be used for further evaluations as well as
selections. Based on the sizes of the gear shaft or the pinion shaft, a pre-evaluation
function will tell whether the ﬁ'amework should calculate forces in both shafts or either
gear shaft or pinion shaft. In order to simplify the process, most of the pre-evaluations

are hard-coded.

Let us consider the forces exerted on a helical gear and its shaft. Single helical
gear introduces axial force (see Figure-17). Spur gears and double helical gears can be

considered as its special cases in which the thrust force is equal to zero.

, >1nput(outpm) torque

Reaction forces

  
    

Reaction forces Radial force Tangential force

F igure-17. Forces and moment exerted on a helical gear and its shaft

46

The diagram below shows that the gear-shaft system can be presented by a

combined loading situation which consists of a beam subjected to bending and a rod

subjected to torsion (see Figure-l8)

A vectorial sum of the radial force and the

 

 

 

’ tangential force
A Moment caﬁ by the axial1
force
+
’I‘; ----------- - 'Il\‘
" Torque caused by the " Input torque

tangential force

F igure-18. Combined loading decomposition of a shaft

For a helical gear and pinion pair, the thrust forces on each of them are reaction
forces so that they are equal and opposite in direction. The gear has the greater diameter,
which means that the moment located at the center of the gear shaft is always greater
than that of the pinion shaft. Similarly, the torque on the gear shaft is also larger than that
on the pinion shaft. Since the spur gear and double helical gears do not have thrust
forces, there is no concentrated moment located in the middle of the shaft. Therefore, in
case of spur gear or double helical gears, the computer will ﬁrst take a look at the size of
the pinion and gear shafts. If the two shafts have the same diameter or the pinion shaft is
thicker, then the computer will only carry out force and stress analysis for the gear shaft.

If the gear shaft is thinner, then you need to check the strength of both shafts. On the

47

other hand, in case of single helical gear and pinion pair, their dimensions will be
checked. In this case, there are both moment and torque located in the middle of each
shaft. Since the gear has greater radius while the thrust and tangential force on both gear
and pinion teeth are reaction forces, the moment and torque on the gear shaft are always
the larger. Again, if the gear shaft has the same diameter as that of the pinion shaft or it
has smaller diameter, only the gear shaft’s strength will be checked. Only when the
pinion shaft’s diameter is thinner than that of the gear shaft should the strength of both

shafts be checked.

Based on the pre-evaluation result, computer will work out forces, moments and
torques for the appropriate shaft or both shafts which are to be used in the forthcoming
tasks. The forces are saved on a ﬁle located on a deﬁned remote system. A ﬂag is
attached to the ﬁle to help other tools recognize the physical meanings of the data store

on that ﬁle.

This scenario is a good example of the production alternative. Thee are three
alternatives, which are to check gear shaft, to check pinion shaft and to check both. In
automatic mode, the pre-evaluation function determines which alternative should be
executed by the framework ﬁrst. In other words, the pre-evaluation function generates a
ranking of all the possible alternatives based on its input data. The ﬁ'amework will try the
alternative ranked numbe one ﬁrst. If it fails, the framework will try the alternative one
till success or till there is no more alternative. In case no alternative is successfully

executed, the framework will issue a roll-back command to select either another material

48

or a different set of the gear/pinion pair. In manual mode, the pre—evaluation function is
still called. However, the user may choose not to follow the ranking and execute any one

of the alternatives.

4.2.4.2 Stress Analysis

Since the loads actually cause bending and torsion, a complex state of stresses
exists in the shaft (see Figure-19). The maximum normal stress caused by bending takes
place on the surface of the shaft at its center because of the relationship 0'b=MY/I, where
0,, is the bending normal stress, M is the bending moment, Y stands for the distance to the
center of the intersection, and I is the cross-section’s moment of inertia. The vectorial
combination of tangential and radial forces in the middle of the shaft and the reaction
forces produced by the bearings will also cause shear stresses on the cross-section. In
case of pure shear, shear stress of this kind can be considered as evenly distributed over
the cross-section. When the shear comes up in conjunction with bending, the shear stress
distribution varies as described in the formula:

e

where S is the shear stress on the cross-section, V is the skettjforyd dylt) I [is the
moment of inertia of the cross section about OX (please refer to Figure-19). From this
formula, we can see that S vanishes when y equals e. This means that S reaches its
maximum value along OX and decreases vertically. The shear stress S is called the
transverse shear stress. Since bending stress are maximum at point A while the transverse

shear stress is zero there, it is unnecessary to combine them. Conventionally, unless the

49

shaft is very short, the value of the transverse shear stress is much smaller than stress

caused by bending, hence it is ignored [22].

 

 

 

 

 

V Ben . g Transverse
stress

2 distribution 51.13“! it .ESS

A dlStl'lleIlOIl

 

 

 

 

 

 

 

 

 

 

 

 

V
QJ"
D

F igure-19. Cross section of a shaft and stress distribution on it

 

Since there is torque existing in the middle of a shaft, shear stress caused by the
torque needs to be considered. Unlike the transverse shear stress, torsional force reaches
its maximum at the surface of the shaft. Moreover, since the input power may not be
trivial, it is necessary to take the torsional shear stress into account. Both stresses are at
their maximum at the surface of the shaft. Therefore, element at the surface in the middle

of the shaft represents the most critical spot (see Figure-20).

 

 

   

 

 

R1 R2
Figure-20. Stresses in the combined loading

50

In case single helical gears are chosen, axial force is introduced, hence the axial
normal stresses. It is assumed that the axial normal stress’ distribution over the shaft
cross section is uniform. Also assume that the axial force is pointing to the left. Based
on Figure-21 , the axial force raises the normal compressive stress in element A, which is
located left of M-M. Vice versa, normal stress in element B is also increased except that
the stress is tensile. Therefore, when the effective stress is calculated to verify whether

the shaft has enough strength, the increase in stress should be taken into account.

When all those stress components are available, it is time to calculate the
effective or equivalent stress[22]. The effective stress called the von Mises stress(o'.) is
calculated based on the Mises criterion or the maximum energy of distortion theory of
failure. In a general case, in which principal stresses and directions are unknown, the
following equation provide us with a way to calculate the von Mises stress:

20. 2 = (Ox-cy)2+(0’y-O'z)2+(0'z-0‘x)2+6(txy2+ty22+tzxz) 4.2

where x, y, and 2 stand for directions of three coordinates
In our benchmark, the above equation is simpliﬁed into:

2 _ 2 2
Ge - ( Gmaximum bending + Gaxial normal) + 3 Ytorsion 4.3

51

 

Element A

 

 

 

 

Bending stress plus

 

 

4——I——‘
! axial normal stress
“in! Element B
, M i
Note: all other forces and moments
remain the same as in F igure-ZO

F igure-21. Stresses at Dangerous Points

 

After the calculation of the effective stress, a comparison is carried out between
the effective stress and the yield strength of the material chosen. If the effective stress is
higher than the yield strength, the framework will roll back either to select another type
of material with higher strength or to choose a new set of gear/pinion/shaft whose shaft
size is greater. If the effective stress is lower than the yield strength, then the stress

analysis is completed.

4.2.5 Bearing Selection
Bearing selection can be simultaneously carried out with the stress analysis. The
bearing selection tools have the information on geometrical constraints of all connecting

parts as well as information regarding the static forces calculated. Then it goes through a

52

bearing database to seek for all possible bearings whose bore diameters are less than the
shaft diameter and list all this bearings on a temporary database just as any othe selectors
do. The bearing with the smallest bore diameter comes ﬁrst in the database. The bearing
bore diameter should be less than shaft diameter - 2 xﬁllet radius (see Figure-22).
In addition, the ﬁllet radius of the bearing ring has to be large than that on the shaft,
otherwise the bearing cannot be mounted. The radial and axial forces are retreived from
the inputs. The temporary bearing database is opened to get the ﬁllet radius of the ﬁrst
bearing record. The a Java function is called to calculate the equivalent radial load
EQRL, which equals XR+YT. Where R is the radial force, T stands for the thrust load, and
X and Y are radial and thrust factor (see Table-4). The basic dynamic load rating C
which is one of the currently selected bearing’s properties stored in the memory is
incorporated with EQRL and the rotational speed N to estimate the bearing life L using
the formula L=16700(C/EQRL)k/N (for details, please refer to [23]). Where constant k
equals 3 for ball bearings and 3.333 for roller bearings. Comparing the estimated
bearing life with the expected life to see if the bearing will fail within the period of
service. In case that single helical gears are chosen, thrust bearings will be selected
accordingly. Therefore, when single helical gear is used, difference between the actual
thrust load and the selected bearing’s thrust capacity is calculated to check if it can
withstand such a load. If either life requirement or thrust strength is not satisﬁed, the

framework will roll back to choose another bearing until the requirements are met.

53

 

 

 

 

 

   
 

To be mounted
Bearing
ring

Figure-22. The ﬁllet radius of the bearing ring

 

 

 

 

 

 

 

Bearing Type X Y

Single-row ball 1.0 0 ’
Double-row ball 1.0 0.75
Cylindrical roller 1.0 0
Spherical roller 1.0 2.5

 

 

 

Table-4 Radial and Thrust Factors

4.2.6 Fatigue Analysis

Since the shafts are rotating components subjected to cyclic loading, fatigue analysis is
necessary. A surface-ﬁnish-condition selector is invoked at the beginning of the fatigue
analysis. Since the major factors inﬂuencing surface ﬁnish are the cutting tool outline, the
fragments of the built-up edge left on the work piece during cutting and vibration, this
selector works rather independently. For fatigue analysis, information produced by all
previous steps except for stress analysis are used as inputs. The charts for stress
concentration factors, notch sensitivity, size factor, surface factor and fatigue notch
factor have been converted into Java code using interpolation. Variable stress and mean

stress are calculated and the concept of effective stress is also introduced in the analysis.

54

The judgment of whether the material will fail is made based on Goodman line

(Figure-23).

For most wrought steels the fatigue endurance limit is between 0.45 and 0.60 of
the tensile strength S... Therefore, it is common to 0.5Su as steels’ fatigue endurance limit
for design purposes. However, an engineering component’s surface ﬁnish condition,
size, operating environment would affect its fatigue endurance limit Se very strongly.
Using the equation

Se=0.5 ks kZ k, k, km Su 44
whee k3, k2. k,, ,k,, and k,,I are factors for surface, size, temperature, reliability, and
othe miscellaneous effects like plating or case hardening, the actual fatigue strength is
reduced. For normal temperature in operation, temperature factor k. is 1.0. Since we do
not have plating, case hardening or high residual stress, we take 1.0 as the value of the

factor of the miscellaneous effects.

4.2.6.1 Surface Factor

Fatigue strength varies with surface condition because surface irregularities are
stress raisers which will initiate fatigue cracks. The surface factor is a positive numbe
that is less than 1.0. Finer smface ﬁnish corresponds to higher surface factor. Surface

factor is also a function of tensile strength. It decreases as tensile strength goes up.

Therefore, for each ﬁnish condition thee is a curve depicting the KS - Su relationship

[22]. Read the data points off the curves. Pick more points whee the curvature is large.

55

A polynomial with the order equivalent to the number of the data points to ﬁt the curve is

used. The material’s tensile strength is then substituted into the polynomial to calculate

the surface factor.

4.2.6.2 Size Factor

When the size increases, the fatigue endurance limit decreases. A larger

component tends to have a weaker metallurgical defect which will cause a fatigue crack

to take place. The formulas listed below determine the value of the size factor [24]:

k, = (d / 0.3)“-068
kz= (d / 7.6)"-068
k = d -0.19

k,_.=1.85d*’-19

Where (1 is the shaft diameter.

4.2.6.3 Reliability Factor

0.l<d<2.0in
5<d<50mm
2<d<10in

50<d<255mm

45(a)
45(b)
45(c)

4.6( d)

The reliability factor k, is a function of the expected reliability R. The following

table shows you the k,- R relationship.

 

R(reliability,°/o)

90

95

99

99.9

99.99

 

k,(reliability factor)

 

 

0.90

 

0.87

 

0.81

 

0.75

 

0.70

 

 

56

Table-5. k, - R relationship

Based on this table, if the designer expects to have a reliability of 99%, then the

reliability factor is 0.81.

4.2.6.4 Goodman line and Stress Concentration

Since the shaft is rotating and this rotation causes alternating stress, Goodman
line(Figure-23), which is used to judge whether or not a specimen subjected to alternating
loading can reach inﬁnite life, is introduced. As to the theoretical details of the Goodman

line, please refer to [22].

Alternating Stress

A

Se=o;, B

  

----9,(a,.., Km.)

\
\
\
‘
§
§
\
N
~~
\

 

0 Mean Stress Sy Su
F igure-23. Goodman line
In the above chart, the abscissa corresponds to mean stress while the ordinate is
the alternating stress. The value of point A corresponds to the ultimate strength Su while
point B is associated to a value of the adjusted endurance strength 0;,. Point C is
corresponding to the yield stress. In order to see whether the material can withstand such

an alternating load, mean and alternating stresses need to be calculated. In this case the

57

torsional shear stress is considered to be the mean stress because it is always there. The
maximum bending stress on the shaft surface in the middle is used as the alternating
stress. Since the shaft has different sections with different diameters, stress concentration
may take place at the change of the cross-sections. A number denoted as fatigue stress
concentration factor Kf or the fatigue notch factor is calculated and is multiplied to the
alternating stress 0,, to evaluate the escalated stress caused by the change of geometry.
To calculate Kf, two values, which are the theoretical stress concentration factor K, and

the fatigue notch sensitivity q, should be calculated . The theoretical stress concentration

factor K, can be estimated based on the specimen's geometry and the types

 

    

 

 

 

 

   

 

 

 

 

 

 

 
   

 

Pornt of (X. Y) |
interest .
Curves
I
E \\\\ \‘\ ‘\\
‘X ‘s, .. ------ Data arrays
..- 1" "gas 2. 9’ ‘33:??? in ‘ I =€*""33i7?:e33
a , / ---- .,
4 i "'22: .. 7-
f, ,7. if ._ it” ' a? ‘3 5
I I 0’ .\
f """""""""""""""""""" , r““""'"1 r,
i '\
: ".
I \
g ‘t
: ".
""""""""""""""""""""" Polynomial y3

ylm +1--

Linear Interpolation

iv

Kt orq J

F igure-24. Interpolation process

rm)

 

 

 

58

loads exerted on it. The geometry is speciﬁed by dimensions such as radii of the
different sections and the ﬁllet radius. K, charts are available for simple loading situations
such as tension, bending and torsion. Little data exists on the effect of coincident
stress raises. Based on some photo-elastic evidence, the product of the two separate
factors is used. The fatigue notch sensitivity q varies with ﬁllet or groove radius. For

details, please refer to [25].

When K, and q are ready, Kfcan be obtained using the equation Kf= 1 + q(K, - 1).
K, and q are calculated by interpolation. Since their original data is presented in a form of
curves, a series of data is obtained from each curve and is stored curve by curve. When
interpolation is initialized, the program will ﬁrst ﬁnd the curves between which the point
of inteest is located and their corresponding data series stored in arrays. Based on the
data, two polynomials are generated to ﬁt the two curves regionally. Since thee may be
many data points stored on the computer, only a few(6 to 10) points around the vicinity
of the point of inteest are used. Now thee are two polynomials for the two curves. If a
vertical line is drawn through the point of inteest, it is easy to identify the coordinates of
the two intesecting points on the curves. Then by simply using linear interpolation, the
location of the point of inteest can be identiﬁed (see Figure-24). Afte the point of
inteest has been located on the Goodman chart, it can tell whethe or not the designed
shaft will survive the inﬁnite numbe of rotations. If the point is located below the line
BJC (in Figure-23), it means that the designed shaft has enough fatigue endurance

strength and the manufacturing processes can be carried out. If it is located somewhere

59

above the line BJ C (in Figure-23), it will fail within ﬁnite times of rotations. In that case,
rollback will take place using one of the following scenarios in an orde of the priority as
listed below: 1) to select a large ﬁllet radius which is geometrically feasible; 2) to use
large shaft; 3) to use anothe material with highe ultimate strength; 4) to choose a ﬁne

surface ﬁnish.

4.3 Manufacturing
4.3.1 Solid Modeling

When the design processes have been completed, the ﬁ'amework invokes an
I-DEAS solid modeling program to start the manufacturing processes. A transitional tool
is used between the design and manufacturing processes to collect the information
required for manufacturing and pass them to the manufacturing tools. In this benchmark
project, this tool is not implemented as a stand-alone task. Instead, it is incorporated into
the fatigue analysis. The manufacturing tools are encoded mostly in I-DEAS open
language which has some special requirements on its ﬁle format. Therefore, the
transitional tool incorporated in the fatigue analysis was designed not only to collect

information but also to convert all information into the format that I-DEAS can

recognize.

Since it is vey hard for the Java-based framework to invoke I-DEAS programs
inteactively and graphically, in batch mode invocation is used. I-DEAS open language
has a restriction that does not allow its program to take external inputs (as a paramete)

unde command line. This restriction makes it hard for the framework to generate output

60

speciﬁcations with random names. Furthermore, the I-DEAS should always run with a
pre-deﬁned project ﬁle and a model ﬁle. Thus in case more than one user has logged on
and is running the same process at the same time or even at diffeent time, the
consequence would be eithe a dead lock or that only the latest outputs exist. To
circumvent these difﬁculties, an extra interface is written. This simple interface allows
the I-DEAS Open language program to run in a predeﬁned environment and save output
ﬁles with ﬁxed names. It recognizes the randomly ordeed inputs, constructs temporary
directories with unique names, copies everything such as project ﬁle, model ﬁle and
program ﬁles into those directories, invokes I-DEAS to run the open language programs,
converts the outputs with unique names to the working directory and labels them with

ﬂags so that othe tools can recognize them.

The solid modeling tool imports all geometrical information, builds 3-dimensional
solid models of all gearbox components such as gears, shafts, bearings and gearbox
housing, and stores them in a library. The tool also assembles those components and
generates a postscript ﬁle for the assembled gearbox with a housing. At the same time,
this I-DEAS tool also generates an IGES (Initial Graphical Exchange Specialization) ﬁle
of the assembled soled model for future use. Unfortunately, most Java-enabled web
browsers such as Netscape cannot display postscript images. Theefore, the interface
which is lying in between the solid modeling tool and framework converts the postscript
ﬁle into JPEG of GIF format image ﬁle for the users to actually view the gearbox

designed. On the whole, the solid modeling process can be divided into step as described

in Figure-25.

61

 

 

Design/Manufacturing Framework

 

l

l

 

 

 

 

 

Enables random

 

Interface

 

     

Tool used to
gather

ﬁle names I
information and

 

   

convert it into

 

postscript ﬁles

 

 

 

 

   
   
 

Converting IDEAS format

into GIF or
JPEG ﬁles

 

 

 

 

l l

 

 

 

 

 

I Solid modeling I-DEAS program

 

Open I-DEAS, set start conditions

 

 

Create 3-D models of all gearbox
components

 

 

Create a library to store gearbox parts solid
models

 

 

gearbox

 

 

Convert all solid model into IGES format

 

 

 

Generate postscript-formatted ﬁle of the
gearbox solid model

 

 

 

Generate a solid model of an assembled I A
Shut down I-DEAS I

 

Figure-25. Solid modeling processes

62

 

4.3.2 Manufacturing

When the solid modeling is done, the framework proceeds to invoke I-DEAS
again in orde to run the generative machining and manufacturing program which is also
written in I-DEAS open language. Up till now, using the MIDAS framework, design can
be accomplished to such a level that a 3-D solid model can be displayed. At the same
time, it is also converted to Steeo Lithographic (STL) format for rapid prototyping.
Furthermore, if the tool path has also been ready, cutter location data and the NC codes
for numerical machining can be generated according to the tool path information. A
simple description of this process is listed as follows: 1) Invoke the manufacturing
program encoded in I-DEAS open language and import the manufacturing data; 2)
Retrieve the shaft data from the library generated in the solid modeling process; 3)
Generate STL ﬁle and convert it so that the image can be posted on the Internet; 4)
Create machine and stock instances; 6) Create a job setup; 7) Create tool paths according
to manufacturing data; 8) Generate CL ﬁles and display the ﬁles on the world wide web;

9) Shut down I-DEAS.

4.4 Conclusion

The gearbox design/manufacturing process benchmark successfully demonstrated
the framework’s ability to perform a series of stress/fatigue analyses and search for a set
of parts satisfying various requirements. It also veriﬁed that the framework is capable of

representing and integrating design tasks and manufacturing opeations seamlessly.

63

Chapter 5

Benchmark II --- Design of Functionally Gradient Materials

5.1 Introduction

The second benchmark project is to use the framework to design functionally
gradient materials. Functionally gradient materials (FGMs) are designed to have gradient
properties resulting from continuously varying the volume ﬁaction of a second phase in a
controlled manner. By combining these approaches, materials with a variety of desired
properties are designed. Recently, thee has been great inteest in FGM composites
which are produced by a variety of schemes in which the concentration of the

reinforcement phase is artiﬁcially varied.

It is challenging to determine the desired distribution of the second phase because
it depends on the type of the application and the geometry of the ﬁnal structure. The
thermoelastic properties as well as the types of the applied loads have to be taken into
account simultaneously to deﬁne the type of gradient, and the required properties of the
reinforcement and matrix materials. In this benchmark project, we have studied the
design of FGMs for axisysmmetic structures subjected to temperature gradients, or
pressure diffeentials. One of the advantages of using the framework to design FGMs is
the reusability of the same process ﬂow in case studies. FGMs designers may need to
investigate a variety of designs with diffeent volume fractions of the reinforcement
phase and applied loads. In that case, the framework enables the designers to feed the

system with diffeent types of initial conditions such as volume fraction and

automatically executes the process ﬂow. When the results of all cases are available, they

are compared to determine which one is the most desired distribution of the second

phase.

In this chapter, effective medium theory using Mori-Tanaka method is brieﬂy
outlined. Then the thermal gradient in a hollow cylinder with speciﬁed boundary
temperatures is calculated. Following this, effective thermoelastic properties are
determined for several second phase distributions. The thermal stresses computed show a
strong dependency upon the second phase distribution. Stresses caused by internal
pressure are separately considered. Using superposition, the effect of pressure and

thermal gradient is combined.

5.2 Effective Properties
5.2.1 Elastic Properties
By applying the appropriate homogenous boundary conditions in conjunction
with the properties of the constituent materials, the effective properties can be computed.
Listed as follows are the displacement boundary condition.
u = e”x 5.1
where x is the position vector and the e” is any spatially constant symmetric tensor.

The effective stiffness is deﬁned by

t=C+Eb 5.2

65

where f is the average stress and the applied strain, 6" , is equal to the average strain,

E , subject to the displacement boundary condition (5.1).

Although the average stress is unknown, the assumption of Mori and Tanaka [26]
may be applied to estimate the effective stiffness tensor based on the following
assumption for the relation between the average strain in inclusions, 61, and the appliéd
strain, 6°,

61 = A 60 5.3
where the strain concentrator, A, is deﬁned as

A=T[(l-v)I+vT]" 5.4
where v stands for the volume ﬁ'action of particles or ﬁbers, I is the fourth rank identity
tensor, and T is Wu's Tensor [27], deﬁned as

T=[I+ESo(Cr-Co)]'l 5.5
Here E is the Eshelby's tensor [28], So is the compliance tensor of the matrix material
and Co and C1 are respectively the stiffness tensors of the matrix and particle materials.
Under the Mori-Tanaka assumption, the effective tensor is

C*=C"“=Co+v(c,-C0)A 5.6

The effective compliance tensor, 8"“, may be expressed as the reciprocal of C“.

66

5.2.2 Thermal Expansion Coefﬁcient

In orde to obtain the thermal gradient, the effective thermal expansion coefﬁcient

(CTE) tensor, of, should be determined. The CT E obtained using the Merl-Tanaka

approach is
a+=ao+(a, -ao)(s,-so)"(s""-so) 5.7
whee era and or, are respectively the CTEs of the matrix and the particle materials while

S, is the compliance tensor of the particle material.

5.2.3 Thermal Conductivity
The effective thermal conductivity properties wee obtained in a similar way based
on the Mon-Tanaka scheme [29]. Aveage temperature gradient g, and the average heat
ﬂux q are two primary variables in thermal conduction. Relation between these two
variables can be expressed using Fourie's heat conduction equation
q = - K+ g 5.8
whee K+ is the effective conductivity tensor. H“ is deﬁned as the resistivity tensor,

which is the reciprocal of K“.

A tensor, g, which is equivalent to Wu's tensor can be deﬁned as

g: = T go 5.9
whee

T=[I+EHo(Kr-Ko)]‘l 5.10

and Hg is the resistivity tensor of the matrix material.

67

Conside there is a general material with multiple second-phases. The average
temperature gradient in the inclusions and the average temperature gradient in the matrix
materials can be related by

31 = T g0 5.11
The effective thermal conductivity tensor is expressed as

K+=Ko+v(Kr-K0)A 5.12
whee E is a second orde tensor which is similar to the Eshelby. A is deﬁned as the
temperature gradient concentration as follows

A=T[(l-v)I+vT] 5.13

5.2.4 Homogenization of Inhomogeneous Properties
The expression for the effective properties are found to be functions of the constituent
material properties and the volume fraction for a speciﬁc geometry of the second phases.
Since the volume fraction distribution function can be expressed as

v = v(x), 5.14
the expressions of effective properties for a heterogeneous material such as FGM can also
be obtained by using the position vector x. For instance, the effective stiffness tensor can
be written as

C+ = C+(x) 5.15
It is rational to use cylindrical coordinate system for axisymmetric FGMs so that the
inhomogeneity is restricted to the radial direction only. If the volume fraction is a

function of r, then the inhomogeneous properties can also be expressed using r. Owing

68

to the extremely small ratio between particle size and structural dimension, these
homogenization methods are applicable. Thus, the spatial distribution function of the

particles becomes the key parameter in the FGMs design.

5.3 Formulation
According to thermoelasticity, the total elastic strain e, equals the sum of the
mechanical strain e, and the eigenstrain 6’. It is expressed as

e=e+e'=e+a+éT 5.16
whee 61‘ is the tempeature variation ﬁeld. The stress is therefore

T=C+C=C+(E-E.)EG-O’* 5.17
Listed as follows is the equation of equilibrium with zeo body force.

div 1: = 0 5.18
The traction boundary condition is deﬁned as

t n = t0 on 03 5,19
The polar coordinate expression of the displacement vector U for the axisymmetric plane
strain problem can be written as

U = u(r) e.- 5.20
whee e, is the unit vector in the direction of r. Due to the symmetric structure, the only

non-zeo strains are
en=du/dr and eeo=u/r 5.21

Applying the locally isotropic and globally inhomogeneous stiffness tensor to the strain

tensor gives a as follows.

69

 

 

 

 

[Cu Cre Ge 0 0 0 ‘ trumpeter \
C,e Crr (3,9 0 o o 11,, gm
0 0 o (C..- can 0 o 0 '
o o 0 o (c...- ca/z o 0
o o 0 o o (C..- Cre)/2 0

K J K J

In case of the F GM cylinder in consideration,
C” = Cn(r) and C,9(r) 5.23

as with other properties such as the CTE and thermal conductivity considered.

By incorporating equation (5.22) into the equilibrium equation, we obtain the
following equation in terms of u
[d2u/dr2 + (Cm/C" + l/r) du/dr + (C,9,, /rcrr - 1/r2)u] (3..
= d[(Crr + 2 C,9)a6T]/dr, 5.24
where C”, and C,e, , are an/dr and dC,9/dr respectively. If homogeneous axisymmetric
media are used, C,,,, and Cd), , are equal to zero. In other words, C", Co and or are
constants. In that case, the above equation then transforms into the equation obtained by

Timoshenko and Goodier [30] for homogeneous and isotropic materials.

In order to solve this equation, boundary conditions need to be identiﬁed. For an
axisymmetric cylinder, boundary conditions at the inner and outer radii are speciﬁed as

follows:

[Crr der + C,9 u/r - (C,, + 2 C,9)or(5T ] = pi 5.25

{:1}

70

and

[Cr du/dr + Ca u/r - (Crr + 2 Cre)0t51‘] = p0 , 5.26

r = r0
where r, and r0 are the inner and outer radii respectively. P, and Po stand for the internal
and external pressures. In case of pure thermal loading, both P, and P0 are assumed to be

zero .

Although in the previous part of this chapter differential equation (5.24) in terms
of u is obtained, the left-hand side of the equation still contains the temperature
variational ﬁeld as a ﬁrnction of r only as (ST (r). For steady state, 6T can be derived
from the following heat conduction equation for cylinder
ﬁamkﬂrgl) z 0 5.27
where k = k(r) is deﬁned in the same way in which the other properties were previously
determined. For steady state, the two boundary conditions imposed are

6T (r,) = T, 5.28 (a)
and

6T (r0) = To 5.28 (b)
where T, and To are the temperature of the interior and exterior of the cylinder. For

steady state, difference between the T, and To becomes the greatest, hence the most

severe thermal loading on the cylindrical structure.

71

5.4. Materials

Due to its practical importance, aluminum alloy 6061-T6 is chosen as the matrix

material. Compatible second phase materials are graphite, B4C, glass, mica, TiBz, ZrBz,

A1203 and SiC. Since A1203 and SiC are the best for metal matrix composites, they are

chosen for the present research. Properties of these materials are shown in the table

 

 

 

 

 

 

 

 

 

 

below.

Matrix Al Alloy Second-phase Second-phasse

SiC A1203

Modulus 70Gpa 616Gpa 379GPa
Poisson's Ratio 0.34 0.17 0.23
CTE x 106 23.6/°C 2.5/°c 8.3/°C
Conductivity 1 8OW/mK 25W/mK 3 7. 7W/mK

Strength iO.27GPa -8.3/+O.39GPa -4480/+205GPa

 

Table - 6 Room temperature properties of matrix and reinforcement

5.5 "Multiple-version" Process Flow

Based on the inhomogeneous properties obtained in micro-mechanics analysis, the

macroscopic thermoelastic analysis can be conducted on FGM cylinders. Three second-

phase distribution functions were investigated : linear (type 1), concave-up (type 2), and

concave-down (type 3) . In order to make comparison, several MMC cylinders whose

second phase is uniformly distributed are presented as reference. For

speciﬁed

temperature boundary conditions, T, and T0 are chosen to be 0 ° C and 100 ° C.

72

 

 

 

 

 

 

Typel v=(r-r,)/(ro-r,)
Type 2 v=(r - r,)2 / (ro - r,)2
type 3 v=(- r2+2ror + r,2 - 2r,,r,)2 / (ro — r,)2

 

Table - 7. Second-phase distribution functions used

Although in this benchmark study, only three second-phase distribution functions
are chosen, it is not uncommon that by far more than three cases are considered in real
practice. Owing to the fact that the design is too complicated for the designer to directly
come up with an ideal distribution ﬁrnction, multiple case study is necessary. The
framework, which is designed to capture parametric processes, is very suitable for the
multiple case study in the FGM design. Since the desirable design should be determined
by comparing the results of each considered tentative design, the ﬁamework provides a
utility called "multiple-version". The "multiple-version" enables the framework to
conduct different designs, and make comparisons among the results based on certain pre-
deﬁned rules in order to determine which one is the ideal design. This functionality
reﬂects and captures a very common feature in mechanics analysis as well as engineering
designs, especially when the analysis and design have their tools scattered all over the

Internet. The overall process ﬂow chart designed using the framework is presented in

Figure-26 .

In this benchmark, the whole process is divided into three steps represented by
three logic tasks. These tasks are material selection, micro-mechanics analysis, and
thermoelastic analysis. The material selection logic task can simply be decomposed into

a material selector which selects both matrix and second-phase and their corresponding

73

 

properties. In micro-meclmnics analysis, Mon-Tanaka method is captured inside an
atomic task to produce inhomogeneous properties such as stiffness , CTE and effective
thermal conductivity in terms of the position vector. When these inhomogeneous
properties are ready, temperature distribution can be determined. With the temperature
distribution in conjunction with the inhomogeneous properties, stresses and
displacements are obtained, hence the effective stresses (von Mises stresses). When the
effective stress distribution for each second-phase volume ﬁaction function is ready,
comparisons are automatically made to determine the best design Since the "multi-

version" feature is implemented, the repetitions are implicitly made to avoid hard-coding.

 

 

 

lnputData

Material Selection

1

Selected Materials

&
Tr

Inhomo Props

i
ThermoElatics R
GIF3 I I GIFl l

EﬂStress

FGM Design

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

GIFZ

 

 

 

 

 

 

 

 

 

 

 

Figure - 26 FMGs design ﬂow chart created by the framework

74

In computer-aided design (CAD) or analysis, modularization, which facilitates the
reusing of the same process ﬂow, is strongly desirable. This "multi-version" feature
signiﬁcantly reduces the complexity of a process ﬂow while enabling the user to test as

many case as possible since computer would never get tired.

5.6 Thermal Loading and Internal Pressure
5.6.1 Thermal Loading

The temperature distribution is relatively independent of the second phase proﬁle
(see Figure-27) . According to the effective thermal stress distribution reﬂected in
Figure-28, type-1 has the lowest maxim von Mises stress which takes place at the
ceramic-rich outer radius. However, considering the large margin of safety with ceramic-
rich materials under compressive loading, none of these FGM cases show a clear
improvement over the others. The resulting stresses of FGM type-1 and type-2 at the
inner radius, the metal-rich side, are much lower than that of type-3. That is to say these

two types of FGMs are safer.

 

100

 

 

 

on
O

 

 

05
O

 

 

 

 

Temperature (°C)
uh
O

N
O

 

 

 

 

 

 

 

 

O
O

0.4 0.6 0.8 1
Normalized radius, r' = (r - r,)/(ro - n)

Figure - 27 Temperature ﬁelds in three type of FGMs

75

.o
u.

.0
4:.

 
 

p
u

p
N

’
‘0’
”
O
I

”
”
I

Effective (von Mises) Stress
(in Gpa)
.O
I
I
I
I
I
II
I
I
I

C

0.2 0.4 0.6 0.8 1
Normalized radius, r' = (r - r,)/(r0 - r,)
Figure - 28 von Mises stress in three types of FGM

O

5.6.2 Internal Pressure

The stress distribution of homogeneous thick-wall cylinders under internal and external
pressures, P, and Po, can be determined by the following two equations.

0, = P,[(r,,/r)2-l]+Po[(r°/r,)2-(ro/r)2]/[ {a,/r924] 5.29(a)
and

oe= P,[(r,,/r)2+1]+Po[(ro/r,)2—(ro/r)2]/[ {a,/r924 ] 5.29(b)
where r0 and r, are the external and internal radii, respectively. The above equations
show that stress distribution is independent of materials and the maximum stress occurs
at the interior of the cylinder. For stresses caused by internal pressure in FGM cylinders,
the formulation derived previously can be applied without the thermal strain in Equation
(5.16). Based on this formulation, the results are represented in Figure-29 with an extra
stress distribution whose second phase distribution varies linearly from pure ceramic
phase at the inner radius to the pure metallic phase at the outer radius. In types 1, 2 and 3,

the maximum stress takes place at the outer radius, while for the linearly distributed

76

second phase case, the maximum stress occurs inside. Therefore, FGM cylinders are
useful since the service-induced defects are located outside and can be easily spotted to

maintain the structural integrity.

5.7 Conclusions

Using the framework, the effectiveness of the FGMs with different second-phase
distributions in reducing the stresses at critical locations has been fully explored for the
case of thermal load and internal pressure of a cylinder. The use of the framework
facilitates an approach toward the design of FGMs in which various distribution ﬁrnctions
of the second phase are tried in order to reduce stress or to obtained desired stress
distributions to maximize the margin-of-safety in the structure. This approach provides
guidelines to the materials design engineers to reduce the wall thickness of FGM
structures for a given maximum allowable stress level by appropriately designing the

second phase distribution, hence low structural weight and cost for a given requirement.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Effective (von Mises) Stress

 

 

 

Normalized Radius, r* = (r - r,)/(ro - r,)
Figure - 29 von Mises stress in FGMs subjected to internal

77

Chapter 6

Conclusions

6.1 Contributions

The intent of this research is to design an infrastructure capable of efﬁciently and
effectively coordinating various distributed design and manufacturing activities in eithe
a parallel or sequential manner. An internet-based design and manufacturing process
managerial framework was implemented as the prototype for the inﬁ'astructure. The main

features implemented in this framework are summarized below:

Platform-independent Graphical User Interface(GUI) - The framework has a
intuitive, easy-to-use graphical use interface for building, editing and executing process
ﬂows. Inteaction with ﬂow objects and opeations are realized through a graphical use
inteface. Since the interface is encoded in Java, it has uniform appearance as well as

functions for all platforms and for any Java-enabled web browses.

Property Inheritance and Macro Substitution - Each ﬂow object is associated
with a ﬂow object class. This ﬂow object class allows designes to deﬁne propeties that
are common to all or a speciﬁc type of ﬂow objects that are inherited from it. For the
same reason, there are common system properties that are pre-defmed as property macros
for all ﬂow objects. Any speciﬁc ﬂow object may either inherit or re—deﬁne any one or

all the system properties. This feature makes it more efﬁcient to create or to maintain a

78

process ﬂow. All ﬂow object classes are designed as a general-to-speciﬁc hierarchy, with

children classes inheriting properties from their parents.

Outstanding Tool Software Compatibility - The implemented framework has
shown its ability to effectively manage complex tasks involved in the gearbox design and
manufacturing processes. Based on the available databases for bar stocks, bearings and
gears, the framework brings a variety of tools into play to search for and evaluate
diffeent possible combinations until it ﬁnds the best solution. When a design is done,
the framework invokes manufacturing tools to provide data for rapid prototyping and
machining. Meanwhile, it also generates images for on-line simulation. During the whole
process, the NﬂDAS framework integrated tools encoded in Java, Fortran, Unix shell
scripts, Pel, Mathematica programming language, I-DEAS open language, Windows NT
command scripts and HTML. It has been proven that the framework is tool software
independent. In othe words, an end-use do not have to wony about whether a speciﬁc

tool can be captured and executed by the MIDAS framework.

Common Gateway Interface(CGI) Servers - In the current implementation of the
framework, some components are interfaced with the framework's cockpit through a CGI
gateway. Any remotely distributed component could be incorporated into the system
through a CGI gateway, as the system's Java applet cockpit can very easily communicate
with remote HTTP servers. Advantages of the CGI gateway for communicating with
remote components are listed as follows: 1) Well Defined Interface. The web seve and

CGI gateway are conceptually well deﬁned and are practically accepted; 2) Security

79

Considerations. For many organizations, system ﬁrewalls are installed. Typical
ﬁrewalls allow only limited communication between internal and external networks. The
htq) protocol is allowed for most systems. Access to the external tools located within the

secure networks can be realized by using a web seve and the CGI site proxy seve.

6.2 Future Work

The present work has laid a sound foundation for many additional new features in the

future. Several possibilities are presented heeafte.

New Features of User Interface. - Version 1.2 of the JDK(Java Development Kit)
provides much advanced use interface utilities. Java Foundation Classes (JF C), which is
among the most notable, provides advanced Graphical Use Interface capabilities that have
high portability. These classes provide standard new features such as scrollable canvases,

drag-and-drop, and an advanced 2D-API for two-dimensional graphics support.

Remote Method Invocation (RMI). - The communication between the frameworks
cockpit and the external tools are currently realized via custom TCP/IP socket messaging.
With all its advantages, one outstanding disadvantage is the proprietary nature of the
approach. Moreove, the high overhead of maintaining, extending, and debugging custom
message passing techniques could also be a heavy burden and would not be fault-proof. RMI
provides an altenative way to exchange information between Java objects. The advantages
include a likely standard method of communication (easy to integrate diffeent communication
components), much lowe developmental ovehead, hence a great way to implement

collaboration functionality.

80

Use of JDBC. - JDBC is Commonly referred to as the Java Database Connectivity.

 

This is a new addition to the JDK. It enables direct access to SOL-based database severs in
Java code. Using this new API may enable the ﬁamework to include the storage of serialized
ﬂow objects. For instance, saving a serialized simulation run, reloading it at a late time, and
continuing execution from whee it was left off. It may also allow the access to remote

databases for Selectors.

Common Object Request Broker Architecture (CORBA) Distributed Services. - In the
current implementation of the MIDAS, all communication is implement using TCP/IP
custom socket messaging that has its own disadvantages as mentioned above. One emeging
industry standard, provided by the Object Management Group (OMG), is the Common
Object Request Broke Architecture (CORBA). While communication Java entities can be
easily implemented with RIVII, a heteogeneous environment requires something more
comprehensive. CORBA meets those requirements very well. Once the ﬁamework is
interfaced by CORBA, all distributed services of the system will be able to communicate
through any of a number of available ORBs (Object Request Brokers). The MIDAS
programmers might be well released ﬁom the overhead of maintaining the communication

utilities by allowing an ORB to execute the external tools via the standard CORBA wrappers.

Better Runtime Debugging Monitor - Although proxy monitor, schedule monitor,
ﬂow execution graphical simulation and standard output to the Java console are already
available, the lack in the means of tracing an error when it takes place is still a big issue.
Especially when communication has halted or tool has its own runtime error, thee is hardly
any efﬁcient way to help the end use ﬁgure out what goes wrong. In the future, a series of

error code should be stipulated and a runtime error message monitor showing the users

81

detailed error information should also be programmed These new features will greatly help

the users to resume any halted communication or to ﬁx any corrupted tool.

82

APPENDICES

83

A. Sample HTML File Used to Invoke the Remote Servers

and the MIDAS Framework’s Java Applet

PrMain.htm1

<HEAD>
<title>Process Management System Demonstration</title>
</head>

<body bgcolor="#000000" text=="#ﬂ'ffft">

<cente>

<P>

</cente>

<!--#exec cgi="/cgi-user/guhua/startJFS.sh"-->

<pre>

</pre>

<tt>

<applet code=PrMain.class width=0 height=0>

<param name=username value=guest>

<param name=password value=>

<param name=debugthresh value=30>

<param name=redrawmode value=chung>

<param name=demo value=false>

<param name=platform value=unix>

<cente>

<font size=4>

ERROR! Your browser is not conﬁgured to run JAVA code.
<p>

<font size=2>

If you are running Netscape v2.02+, pehaps you just have JAVA support disabled. If
you are NOT running a JAVA capable version of Netscape, you can get one <a
href="http://home.netscape.com">here</a>.

</center>

</tt>

</applet>

</body>

 

84

B. Sample Unix Shell Scripts Used to Invoke Remote Servers
Thtough CGI

 

StartJFSsh

#l/usr/bin/sh

MADPATH="/use/r01/chung/MAD/system"

H=‘/bin/cat /etc/hostname.*‘

echo "Content-type: text/html"

echo

echo "<br><font size = 2>"

echo "<cente>"

echo "<h2>Executing Remote Start Hacks on <em>$H</em></h2>"
echo "Script: <strong>"$0"</strong><p></cente><hr>"

echo "Attempting to start the JF S seve on <strong>$H</strong>...<br>"
echo .‘/user/web/cgi-use/guhua/myzap 'java MultiSeve' > /dev/null‘
echo ‘/user/web/cgi-use/guhua/myzap 'java RemoteFileServe' > /dev/null‘

 

echo ‘/user/web/cgi-use/guhua/myzap 'java JFSserve' > /dev/null‘

cd $MADPATH/j fs-0.05

umask 0

#chmod 666 root/etc/*

echo ‘/soft/sparc/bin/java JFSserver ./root > /dev/null &‘

echo "Attempting to start MultiServe on <strong>$H</strong>...<br>"

cd $MADPATH

echo ‘/soft/sparc/bin/java MultiServe > /dev/null &‘

#sleep 5

echo "Attempting to start the Tool Proxy seve on <strong>$H</strong>...<p>"
echo ‘/user/web/cgi-use/guhua/myzap 'java ProxySeve' > /dev/null‘

cd $MADPATH

echo ‘/soft/sparc/bin/java ProxyServe CPS www > /dev/null &‘

echo ‘/user/web/cgi-user/guhua/myzap 'java RemoteFileServe' > /dev/null‘
echo "Attempting to start the RemoteFileServer on <strong>$H</strong>...<p>"
cd $MADPATH

echo ‘/soft/sparc/bin/java RemoteFileServer -unlimitted > /dev/null &‘

echo

echo "These are the processes currently running on "$H" that are related to what we're
doing...<br><pre>"

/usr/bin/ps -ef | grep JFSserve

/usr/bin/ps -ef | grep MultiServe

/usr/bin/ps -ef | grep ProxyServe

/usr/bin/ps -ef | grep RemoteFileSeve

echo "</pre>"

85

echc) "<!_."
# ------ Run remote seve
echo ‘/opt/bin/lynx -dump http://www.cps.msu.edu/cgi-user/guhua/startSeves.cgi |

/usr/bin/unix2dos - -‘

 

86

C. Major Applet Class

/* ________________________________
Major Class extends Applet

1k _________________________________ */
import java.awt.*;

import java.applet.*;

import java.util.*;

import java.io.*;

import java.net.*;

public class PrMain extends Applet implements Runnable {

public final static String perlURL =
new String("httpz//localhost/cgi-bin/drawgate.prl");

public final static String imageName =
new String("cool-process.jpg");

public final static int CHUNG = 0;
public final static int FARIBA = 1;
public final static int DOS = 0;
public final static int UNIX = 1;

public static int redrawMode = CHUNG;
public static boolean demo = false;
public static int platform = DOS;

static int runCount = O;

// public static objects that will accessed by sub-
// modules of the system

static StateClassDirectory taskDirectory
= new StateClassDirectory();

static StateClassDirectory specDirectory
= new StateClassDirectory();

static ProductionDatabase productionDB

87

= new ProductionDatabase();
static Constraints constraints = new Constraints();
static PropertyDatabase preferences

= new PropertyDatabase();
static String defaultSite = new String("EGR");
public static AppletContext appletContext;

Flow rootFlow = new Flow();

Cockpit cockpit;

DirectoryBrowser taskBrowser,specificationBrowser;
DatabaseBrowser productionBrowser;

static Toolkit tk;
public static URL codeBase = null;

Thread thr = null;

boolean running = true;
boolean setup = false;

long samplelnterval = 2000;

public void init(){

codeBase = getCodeBase();
appletContext = getAppletContext();
tk = getToolkit();

thr = new Thread(this);
if(++runCount < 2){

thr.start();
setup=true;

} else {

new MessageWindow("Currently, only one copy of the
Process Management System may be run at a time in
a single Java Virtual Machine. This restriction
may be removed in the future. If this message is
displayed in error, PMS will not be able to start
until your browser is restarted...",200);

bail();

}

// thr.start();

88

}

private void setup(){

// instantiate the browsers
ImageLabel im = new ImageLabel(codeBase + imageName);
im.waitForImage(true);
ProgressDialog pd = new
ProgressDialog(6,300,"Initializing System
Cockpit...",im);
getToolkit().sync();
// pd.show();

cockpit = new Cockpit(this);

pd.increment("Initializing Task Browser...");
taskBrowser = new DirectoryBrowser("Task Browser",
taskDirectory);
taskBrowser.getTreeCanvas().addMouseDownHandler(new
TaskDirHandler());

pd.increment("Initializing Specification Browser...");

specificationBrowser = new
DirectoryBrowser("Specification
Browser", specDirectory);

specificationBrowser.getTreeCanvas().addMouseDownHandl
er(new SpecDirHandler());

pd.increment("Initializing Production Browser...");
productionBrowser = new DatabaseBrowser("Production
Browser", productionDB);

String n = getParameter("username");
String p = getParameter("password");
String f = getParameter("filename");
String d = getParameter("debugthresh");

String rdm = getParameter("redrawmode");
String dem getParameter("demo");
String plat = getParameter("platform");

pd.increment("Parsing tag parameters...");
if(n != null && p != null){

cockpit.usr = n;

89

cockpit.pwd = p;
cockpit.login();
} else if(n != null II p != null){
Debug.msg("Both a USERNAME and PASSWORD must be
specified.",
Debug.HIGHEST);

}

if(d != null)
Debug.setPriorityThreshhold(Integer.parseInt(d));

else
Debug.setPriorityThreshhold(Debug.MEDIUM);

if(f != null) {
try {
Debug.msg("filename: "+f);
cockpit.readFile(new String("/home/guest/"+f),0); //
Consistency of the filename & version is necessary.
cockpit.load.disable(); // Prevent from loading &
saving the others
cockpit.save.disable(); //
} catch(RequestException e) {}

}
if(rdm != null){

if(rdm.equalsIgnoreCase("Chung"))
redrawMode = CHUNG;

else

redrawMode = FARIBA;

}

if(dem != null){
if(dem.equalsIgnoreCase("true"))
demo = true;
else

demo = false;

}

if(plat != null){
if(plat.equalsIgnoreCase("unix"))
platform = UNIX;
else
platform = DOS;

}

90

pd.increment("Initializing Threads...");
pd.increment();

try {
Thread.sleep(2000);
} catch (InterruptedException e) { }

pd.dispose();
pd = null;

cockpit.show();

}

public void run() {

while(running){

try {
Thread.sleep(sampleInterval);
if(setup){

setup();

setup=false;

}

} catch (InterruptedException e) {
return;

};

}

public void showSpecBrowser(){
if(specificationBrowser != null){
Debug.msg("Bring up Spec Browser...");
specificationBrowser.show();
} else {
specificationBrowser = new
DirectoryBrowser("Specification Browser",

}
}

specDirectory);

public void showTaskBrowser(){
if(taskBrowser != null){

Debug.msg("Bring up Task Browser...");

91

taskBrowser.show();
} else {
taskBrowser = new DirectoryBrowser("Task Browser",

taskDirectory);
}
}

public void showProductionBrowser(){
if(productionBrowser != null){
Debug.msg("Bring up Production Browser...");
productionBrowser.show();

} else {
productionBrowser = new DatabaseBrowser("Production

Browser", productionDB);

}
}

public void bail(){
runCount--;

if(productionBrowser != null)
productionBrowser.dispose();

if(taskBrowser != null)
taskBrowser.dispose();

if(specificationBrowser != null)
specificationBrowser.dispose();

// cockpit.dispose();

// Kill the current running PrMain Thread...

if(thr != null){
//Debug.msg("Stopping Thread " + thr.toString());
running = false;

}

}

public static URL getStartURL(){
return codeBase;

}

public Flow getRootFlow(){
return rootFlow;

92

}

public static ProductionDatabase getProductionDatabase(){
return productionDB;

}

public static StateClassDirectory
getSpecificationDirectory(){
return specDirectory;

}

public static StateClassDirectory getTaskDirectory(){
return taskDirectory;

}

public static AppletContext getAppContext(){
return appletContext;

}

93

D. Sample Code of the Interface Between the Framework and Tools

// A interface class used to invoke any
// other program in command-line

// Format:
// java call program input parameters m output parameters

import java.util.*;
import java.io.*;
import java.awt.*;

// —————————————————————————————————————————————————————————————————

public class call {
// ‘-
static String trans_;

static String str;
int no_of_tools=200; // subject to change for later development

static tools tr=new tools();

 

/* ———————————————— main --------------- */
public static void main(String argv[]) {

tools tryl = new tools();

tools t = new tools();

ToIdeas T - new ToIdeas();

rec_len l = new rec_len();

Mat M = new Mat();

brsel B = new brsel();

G_P_Shaft gps = new G_P_Shaft();

stress str_= new stress();

fatigue fat = new fatigue();

String[] f = new String[20];

String[] f_= new String[20];

String[] ff= new String[l7];

String fl="", f2=lINI f3=""’ f4=""’ f5=ﬂ ﬂ, f6="", f7="", f8=ﬂ", f9=""' flo=ﬂﬂ;
String trs = "";

float tra;

float traO;

int ii=0;

int i=0;

int nub_Inp=0; /* "INPUTS" location */
int nub_Out=0; /* "OUTPUTS" location */
int no_of_inp=0;

94

int no_of_out=0;
int loop_time=0;
int bound=0;

float[] pr=new float[lOO];
int trai=0;

String tra_="";

int traii,b;

trans_=argv[0];

for (ii=0; ii<bound; ++ii){ // for starts

if (ate("inputs")){
nubﬁInp=ii;
no_of_inp=ii-2;
}

if (ate("outputs")){
nub_Out=ii;
no_of_out=bound—ii-l;
bound=-l;
}

} // for ends here

loop_time=nub_Out-l;
for (ii=2; ii<loop_time+l; ++ii){ // for begins

if(argv[0].equals("CopyF")){
tryl.CopyF(argv[ii],argv[nub_Out+ii-l]);
}

} // for ends here

// ******************* Interface ********************

if (ate("Diameter")) {
// public float Diameter(int tn, int p)
pr[1]=fv(arQV[2],0,0);
pr[2]=fV(arQV[3].0,0);
tra=tryl.Diameter((int)(pr[1]),(int)(pr[2]));
out(argv[5],0,0,tryl.FltToStr(tra));
}
else if (ate("Tan_Force")){
// float Tan_Force(float r,float pow,float Rp)
pr[1]=fv(argv[2],0,0);
pr[1]=fv(argv[3],0,0);
pr[1]=fv(argv[4],0,0);
tra=tryl.Tan_Force(pr[l],pr[2],pr[3]);
out(argv[6],0,0,try1.FltToStr(tra));

95

else if (ate("Angle_ Ft _Fr")){
// double Angle_ Ft _Fr(float helix _angle, float pressure_ angle)
pr[1]— =tryl. StrToFlt(try1. goto_ rec _get_ field( (argv[2],l, 1, " ,"));
pr[2]=fv( argv[3],1, 2)
tra=(float)tryl.Angle_Ft_Fr(pr[l],pr[2]);
out(argv[S],2,l,tryl.FltToStr(tra));
}
else if (ate("ForcePlusForce")){
// float ForcePlusForce(float fl, float f2)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
tra=tryl.ForcePlusForce(pr[l],pr[2])
out(argv[S],0,0,tryl.FltToStr(tra));
}
else if (ate("NormalStress")){
// float NormalStress(float force, float nn)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
tra=tryl.NormalStress(pr[1],pr[2]);
out(argv[6],0,0,tryl.FltToStr(tra));
}
else if (ate("Moment")) {
// float Moment(float f,float 1, float theta)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
pr[3]=fv(argv[4],0,0);
tra=tryl.Moment(pr[1],pr[2],pr[3]);
out(argv[S],0,0,tryl.FltToStr(tra));
}
else if (ate("Mmax")) {
// float Mmax(float w, float m, float l)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
pr[3]=fv(argv[4],0,0);
tra=try1.Mmax(pr[l],pr[2],pr[3]);
out(argv[6],0,0,tryl.FltToStr(tra));
}
else if (ate("TorqueShearStress")) {
// float TorqueShearStress(float torque, float diameter)
pr[1]=fv(argv[2],0,0),
pr[2]=fv(argv[3],0,0);
tra=try1.TorqueShearStress(pr[l],pr[2]);
out(argv[S],0,0,tryl.FltToStr(tra));
}
else if (ate("Von_ Mis _stress")) {
// float Von _Mis _stress(float torque, float diameter)
pr[1]=fv(argv[2], 0, 0);
pr[2]=fv(argv[3], 0,0);
tra=try1.Von_Mis_stress(pr[1],pr[2]);
out(argv[5],0,0,tryl.FltToStr(tra));
}
else if (ate("Max_Shear_stress")) {
// float Max_Shear_stress(float torque, float diameter)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
tra=try1.Max_Shear_stress(pr[l],pr[2]);

96

out(argv[5],0,0,tryl.FltToStr(tra));

}

else if (ate("I_pie")){

// float I_pie(float Diameter)
pr[1]=fv(argv[2],0,0);
tra=try1.I_pie(pr[l]);
out(argv[4],0,0,try1.FltToStr(tra));

}

else if (ate("Max_Bend_Stress")) {
// float Max_Bend_Stress(float M,float D, float I)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
pr[3]=fv(argv[4],0,0);
tra=try1.Max_Bend_Stress(pr[l],pr[2],pr[3]);
out(argv[6],0,0,tryl.FltToStr(tra));

} 7

else if (ate("Mean")) {
// float Mean(float max, float min)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
tra=try1.Mean(pr[l],pr[2]);
out(argv[5],0,0,tryl.FltToStr(tra));

}

else if (ate("interpolation")) {

// float interpolation(float xl,float x2, float yl,float

// y2,float inter_x)

pr[l]
=fv(argv[2],0,0);
pr[2]
=fv(argV[3],0,0);
pr[3]
=fv(argv[4],0,0);
pr[4]
=fv(argv{5},0,0);
pr[5]
=fv(argv[6],0,0);

tra=tryl.interpolation(pr[1],pr[2],pr[3],pr[4],pr[5]);
out(argv[8],0,0,try1.FltToStr(tra));
}
else if (ate("out_in_GoodmanLine")) {
// String out_in_GoodmanLine(float Sn,float Su,float Sa,float

// Sm)

// -------------------
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argVE3],0,0);
pr[3]=fv(argv{4],0,0);
pr[4]=fv(argv{5].0.0);
// --------------------

97

str=try1.out_in_GoodmanLine(pr[l],pr[2],pr[3],pr[4])5
out(argv[8],0,0,str);
}

else if (ate("Kf")) {
// float Kf(float Kt, float q)
// Kt = stress concentration factor;q = average fatigue notch

// senstivity

// public float q(float r,float mm)

// the input r is the notch radius (mm)
// Note: input unit not= mm, input mm=—l
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
tra=tryl.Kf(pr[l],pr[2]);

out(argv[5],0,0,try1.FltToStr(tra));
}

else if (ate("Kt_bending")) {
/*
float Kt_bending(float D,float d,float r)
*/

pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
pr[3]=fv(argv[4],0,0);
tra=tryl.Kt_bending(pr[1],pr[2],pr[3]);
out(argv[6],0,0,try1.FltToStr(tra));

}

else if (ate("Kt_Torque")) {
/*
float Kt_Torque(float D,float d,float r)
*/

pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
pr[3]=fv(argv[4],0,0);
tra=tryl.Kt_Torque(pr[l],pr[2],pr[3]);
out(argv[6],0,0,try1.FltToStr(tra));

}

else if (ate("Kt;Axial")) {

// float Kt;Axial(float D,float d,float r)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
pr[3]=fv(argv[4],0,0);
tra=try1.Kt;Axial(pr[l],pr[2],pr[3]);
out(argv[6],0,0,try1.FltToStr(tra));

}
else if (ate("q")) {

// float q(float r,int mm)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);

98

tra=tryl.q(pr[1],(int)pr[2]);
out(argv[S],0,0,tryl.FltToStr(tra));
}
else if (ate("Equal_Ra_Load")) {
// float Equal_Rad_Load(float radial_load, float thrust_load,

// int bearing_type)

pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
pr[3]=fv(argv{4],0.0);

tra=tryl.Equal_Ra_Load(pr[1],pr[2],(int)(pr[3]));
out(argv[6],0,0,tryl.FltToStr(tra));
}

else if (ate("Cs")) {
/*
float Cs(String finish, float tensile_strength)
*/
//pr[1]=fV(argv{2].0.0);
pr[2]=fv(argv[3],0,0);
tra=try1.Cs(argv[2],pr[2]);
out(argv[5],0,0,try1.FltToStr(tra));
}
else if (ate("Cz")) {
// float Cz(float speciman_diameter, int inch_or_mm)
pr[1]=fv(argv[2],0,0);
pr[2]=fv(argv[3],0,0);
tra=tryl.Cz(pr[l],(int)pr[2]);
out(argv[S],0,0,tryl.FltToStr(tra));
}
else if (ate("GPSselector")){
/* initial file:
1 max_rot_speed,2 max_power,3 ratio_part_hi,4
ratio_part_low,5 Dmax,6 Dmin,

7 no of helical, 8 life of bearing ......

9 fraction of in/output shaft diameter in terms of the
bearing bore size, 10 in/output shaft length,
11 no. of teeth displayed
*/

/* java call xxxxxx INPUTS ini_file OUTPUTS choice_file DB
gdatabase sdatabase ITEM n */

fl=t.goto_rec_get_field(argv[2],2,l,",");

if(!(f1.equals("ini"))){
t.Append(argv[2],"ini");

}

t.dele_file("name.tmp");
t.Append("name.tmp",argv[2]);

99

f1=t.goto_rec_get_field(argv[7-l],l,l,",");

if (!(f1.equals("ghl-l"))){
f2=argv[7-l];
argv[7-l]=argv[8-1];
argv[8-l]=f2;
}

pr[1]=fv(argv[3-l],1,l);
pr[2]=fv(argv[3-l],1,2);
pr[3]=fv(argv[3-l],l,3);
pr[4]=fv(arQV[3-l],l.4);
pr[5]=fv(argv[3-l],l,5);
pr[6]=fv(argv[3-l],1,6);
pr[7]=tryl.StrToFlt(argv[lO—l]);
pr[8]=fv(argv[3-l],l,7);
trai=(int)(pr[7]+0.5);
traii=(int)(pr[8]+0.5);
gps.gearsel_l(pr[l],

pr[21,

pr[3],

pr[4]:

pr[5].

pr[6],

argv[7—1],

argv[8—1],

"gps_selected.tmp",

argv[5-l],

I! II
I I

9, // no_of_fields_gear
3, // no_of_fields_shaft
traii, // no_of_helical
trai); // item

t.Append(argv[4],"GPS");

/*

choice_file(GPS):

stock no., D_bore, pitch, teech no., pitch diameter, pressure
angle, helical angle, hub style, face width

1 2 3 4 5 6

7 8 9

stock no., D_bore, pitch, teech no., pitch diameter, pressure
angle, helical angle, hub style, face width

10 ll 12 13 14 15

16 17 18

stock no., nominal diameter, length, stock no., nominal
diameter, length, cal_length

19 20 21 22 23
24 25 */

100

// Note: Pinion comes first.
// P, G, P_shaft, G_shaft

} // gps ends here

else if (ate("where")){
// java call xxx INPUTS choice_file(GPS), ini_file
OUTPUTS go_file_name

// l 2 3
// 4 5 6
/* go_file

1. pinion shaft 10 or —1

2. gear shaft 10 or -1

3. both 10 or —1
*/

// java call xxx IN choice_file(GPS) ini_file CONS
// const.dat IOSET ioset ALTs a1 a2 a3

// 0 l 2 3 4 5
// 6 7 8 9 10 12

trs=t. goto_rec_get_field(argv[2],2,1,",");

if (trs.trim().equals("GPS")){

pr[1]=fv(argv[3-l],l,23);
pr[2]=fv(argv[3-l],1,20);
pr[3]=fV(argv{4-1].l.7);

}
if (trs.trim().equals("ini")){

pr[1]=fv(argv[4—1],l,23);
pr[2]=fv(argv[4-l],l,20);
pr[3]=fv(argv[3-l],l,7);

}
// java call xxx IN choice_file(GPS) ini_file CONS

// const.dat IOSET ioset ALTs a1 a2 a3
// 0 1 2 3 4
// 6 7 8 9 10 11

101

/* pre_where_to_go(float gear_shaft_D,
// parameters placed here as a reminder

float pinion_shaft_D,
int no_of_helical,
String go_file_name
String ioset,

String alt[],

String const_file)

*/

ff[1]=argv[9];
ff[2]=argv[10];
ff[3]=argv[ll];
ff[O]=" n;
for (i=4; i<=l6; ++i){
ff[i]=" ";
}

tra_= str_.pre_where_to_go(pr[l],
pr[2],
trai,
"/dev/null",
argv[7],
ff,
argVISJ);

} // where ends here

else if(ate("g_s_force")){

/* g_s_force( float max_rot_speed,
float max_power,
float gear_D,
float helix_angle,
float press_angle,
float shaft_length,
int helical_gear_no,
String outfile
){

// java call xxxxx IN choice_file(GPS) ini_file OUT
// output_file
// 1 2 3 4

fl=t.goto_rec_get_field(argv[2],2,l,",");

if (!(f1.equals("GPS"))){
trs=argv[2];
argv[2]=argv[3];
argv[3]=trs;

}

102

pr[1]=fv(argv[3],l,l);
pr[2]=fv(argv[3],l,2);
pr[3]=fv(argv[2],1,l4);
pr[4]=fv(argV[2].l,7);
pr[5]=fV(ar9V[2],l,6);
pr[6]=fV(ar9v{2],1.25);
pr[7]=fv(argV[3].l.7);

trai=(int)(pr[7]+0.6);

str_.g_s_force(pr[l],pr[2],pr[3],pr[4],
pr[5],pr[6],trai,argv[5]);
D
} // g_s_force

else if(ate("p_s_force")){

/* p_s_force( float max_rot_speed,
float max_power,
float pinion_D,
float helix_angle,
float press_angle,
float shaft_length,
int helical_gear_no,
String outfile
){

*/

// java call xxxxx IN choice_file(GPS) ini_file OUT
// output_file
// l 2 3 4

fl=t.goto_rec_get_field(argv[2],2,1,",");

if (!(fl.equals("GPS"))){
trs=argv[2];
argv[2]=argv[3];
argv[3]=trs;

}

pr[1]=fv(argv[3],1,l);
pr[2]=fv(argv[3],l,2);
pr[3]=fv(argv[2],1,5);
pr[4]=fv(argv[2],l,7);
pr[5]=fv(argv[2],1,6);
pr[6]=fv(argV[2].l,25);
pr[7]=fv(argv[3],1,7);
trai=(int)(pr[7]+0.6);

str_.p_s_force(pr[l],pr[2],pr[3],pr[4],pr[5],
pr[6],trai,argv[5]);
} // p_s_force

else if(ate("steel")){

103

/* steel database:

AISI No., Condition of Steel Tensile Strength(Ksi), Yield
Strength, Machinability, mat type */

else

/* java call xxxx IN OUt output_file DB steel_database ITEM
n */
// 1 2 3 4 5 6

// now, no of records is 4

//public void steels(String steel_database,

// int item, int no_of_records,

/* String output_file, String
Deli){ .....

*/

pr[1]=tryl.StrToFlt(argv[7+1]);
trai=(int)(pr[l]+0.5f);
M.steels(argv[5+l],trai,4,argv[3+1],",");

// steels ends

if (ate("bothforce")){

/* public void gpbothforce(
float max_rot_speed,
float max_power,
float gear_D,
float pinion_D,
float helix_angle,
float press_angle,
float shaft_length,
int helical_gear_no,
String outfile,
String deli){ ...... */

// java call xxxxx IN choice_file(GPS) ini_file OUT

output_file

// l 2 3 4 5
f1=t.goto_rec_get_field(argv[2],2,l,",");

if (!(f1.equals("GPS"))){

trs=argv[2];
argv[2]=argv[3];
argv[3]=trs;

}

104

pr[1]=fV(arQV[3],l,l);
pr[2]=fv(argv[3],l,2);
pr[3]=fv(ar9v{2],l.5);
pr[4]=fV(argv{2],l,7);
pr[5]=fv(argv[2],1,6);
pr[6]=fv(argv[2],l,25);
pr[7]=fV(argv{3],1.7);
trai=(int)(pr[7]+0.6);
pr[8]=fv(aIQV[2].l.l4);

str_.gpbothforce(pr[1],pr[2],pr[8],pr[3],pr[4],
pr[5],pr[6],trai.argV[5],",");

}// bothforce ends here
else if (ate("stress")){

/* void stress_analysis(float shaft_D_p,
float shaft_D_g,
String inputfile,
String output_file,
String deli,
float yield_stress

) */

// java call xxxx IN choice_file(GPS) inputfile(force)
// material_file OUT outputfile

// 1 2 3
// 4 5 6
b=4;

for(i=2; i<=b; ++i){

f[1]=t.goto_rec_get_field(argv[i],2,l,",");
if(f[l].equals("GPS")){
ii=i;
b=—888;
}
}
trs=argv[2];
argv[2]=argv[ii];
argv[ii]=trs;

f[2]=t.goto_rec_get_field(argv[3],2,l,",");
f_[2]=argv[3];
f[3]=t.goto_rec_get_field(argv[4],2,l,",");

f_[3]=argV[4];
for (i=2; i<=3; ++i) {

105

if (!f[i].equals("m")){
ar9V131=f_[i];
}
if (f[i].equals("m")){
argV[4]=f_[i];
}
}
pr[1]=fv(argv[2],l,20);
pr[2]=fv(argv[2],1,23);
pr[3]=fv(argv[4],1,4);
str_.stress_analysis(pr[1],pr[2],argv[3],argv[6],",",pr[3]);

}//stress ends here

else if (ate("bearing")){

//t.Append("bn_.tmp",argv[6]);
t.dele_file("bn_.tmp");
t.Append("bn_tmp",argv[6]);

/* void BearingSel( //float D_bore,
float D_shaft,
String beardatabase,
String bearbests,
String Deli,
int no_of_fields, // now =11
String choice_file,
int item,
int tot_no_of_rec, // can let it be any
//value (say 1000)
float axial_force,
float rad_force,
float rot_speed,
int lifeofbear

) */

// java call xxx IN choice_file(GPS) ini_file forcefile OUT
bearbests choice_file(bearing) DB

/* 1 2 3 4 5
6 7 8
beardatabase ITEM n
9 10 ll */

// force file:

/* Tan_force, Angle_Ft_Fr, Rad Force, ShearForce,
AxialForce, Torque, Central Moment,

1 2 3 4 5
6 7

Moment Y, Moment Z, Total bending moment

8 9 10

106

// There are three lines in the stress file. The second line
// might be "0".
// The first line will always consist of non-zero fields.
// The third line contains only one field which can be "g" or
// "p" or "9p".
// Obviously, the 3rd line serves as an indicator indicating
// that
/* g ----- first line is pertaining to gear shaft data
p ----- first line is pertaining to pinion shaft data
gp -—-— first line --> gear shaft data
second line --> pinion shaft data
*/
// Stress file:
/* ShearStress, TortionalShearStress, MaxBendNormalStress,
NormalStressDueToAxialForce,
1 2 3
4
NormalStress, ShearStress, Von_Mis_Stress
5 6 7
*/

/*Bearing Type Codes

*/

1-single-row ball

2—double-row ball
3—cylindral roller
4—spherical roller

// java call xxx IN choice_file(GPS) ini_file forcefile OUT
******** choice file(bearing) DB

/*

I 2 3 4 5 6
7 . 8

beardatabase ITEM n

9 10 11 */

for(i=2; i<=4; ++i){
f[l]=t.goto_rec_get_field(argv[i],2,1,",");
if(f[l].equals("GPS")){
ii=i;
i=888;
}

1

trs=argv[2];
argv[2]=argv[ii];
argv[ii]=trs;

107

f[2]=t.goto_rec_get_field(argv[3]1211:"I")F
f_[2]=argV[31;
f[3]=t.goto_rec_get_field(argv[4],2:l:"r");
f_[3]=argv{4];

for (i=2; i<=3; ++i) {

/* if (f[i].equals("GPS")){
argv[2]=f[i];
} */

if (f[i].equals("ini")){
argv[3]=f_[i];
}

if (!(f[i].equals("ini"))){
argV[4]=f_[i];

/* void BearingSel( //float D_bore,
float D_shaft,
String beardatabase,
String bearbests,
String Deli,
int no_of_fields, // now =11
String choice_file,
int item,
int tot_no_of_rec, // can let it be any
// value (say 1000)
float axial_force,
float rad_force,
float rot_speed,
int lifeofbear) */

// java call xxx IN choice_file(GPS) ini_file forcefile OUT
bearbests choice_file(bearing) DB

/* l 2 3 4 5
6 7 8
beardatabase ITEM n
9 10 11 */

// bearing file format
/* stock no, outer D, bore D, width, static radial load(lbs),

dynamic radial load,
1 2 3 4 5

108

6
static thrust load, length unit code, force unit code,
fillet radius, bearing type
7 8 9
10 ll
*/
// java call xxx IN choice_file(GPS) ini_file forcefile OUT
// bearbests choice_file(bearing) DB

/* l 2 3 4 5
6-1 7-1 8-1
beardatabase ITEM n
9—1 10-1 11-1 */

pr[1]=fv(argv[2],l,23);
pr[2]=try1.StrToFlt(argv[ll-l]);
trai=(int)(pr[2]+0.5f);
pr[3]=fv(argv[4],1,5);
pr[4]=fv(argv[4],1,3);
pr[5]=fv(argv[3],1,1);
pr[6]=fv(argv[3],l,8);

t.dele_file("bn_.tmp");

t.Append("bn_.tmp",argv[6]);
B.BearingSel(pr[1],argv[9-1],"bears.tmp",",",11,argv[7—
l],trai,1000,pr[3],pr[4],pr[5],(int)(pr[6]+0.5f));

}// end of bearing

else if(ate("finish")){

// void finish_sel(String material_type,int item, String
mat_file)

// ---------------

// this is actually finish condition output file
// java call xxx IN material_file OUT outfile_finish DB ITEM n
// 1 2 3 4 4 5 6
tra_=try1.goto_rec_get_field(argv[2],1,6,",");
pr[1]=try1.StrToFlt(argv[6+l]);
trai=(int)(pr[1]+0.5f);
tryl.dele_file(argv[4]);
// fat.finish_sel(tra_,trai,argv[4]);

fat.finish_sel("steel",trai,argv[4]);

} // finish ends here

else if (ate("fatigue")){

/* String fatigue_1 (String bearing_sel,
int bear_bore_D_field_no,
int bear_fillet_field_no,

109

String shaft_sel,

int shaft_D_field_no,

String deli, // ","

float max_bend_normal_stress,
float axial_normal_stress,
float torque_shear_stress,
String finish_condition,
float ultimate_stress,

String L_unit // "in"

) */

// java call xxx IN bearingchoicefile GPSchoicefile forcefile

//
//

//
//

for

}

for

for

for

l 2 3 4
finishselectedfile materialselectedfile

OUT outfile
5 6

7 8

(i=2; i<=6; ++i){
[i]=argv[i];

(i=2; i<=6; ++i) {
trs=t.goto_rec_get_field(f_[i],2,1,",");

if (trs.equals("b")){
argV[2]=f_[i1;
//f_[i]="VVV";
}

(i=2; i<=6; ++i) {
trs=t.goto_rec_get_field(f_[i],2,l,",");

if (trs.equals("m")){
argV[6]=f_[i];
//f_[i]="VVV";

}

(i=2; i<=6; ++i) {
trs=t.goto_rec_get_field(f_[i],1,l,",");

if (trs.equals("m")){
argv[5]=f_[i];
}
if (trs.equalS("p")){
argv[5]=f_[i];
}
if (trs.equals("h")){

110

argV[5]=f_[i];

if (trs.equals("g")){
argv[5]=f_[i];

if (trs.equals("f")){
argv[5]=f [i];

for (i=2; i<=6; ++i) {
trs=t.goto_rec_get_field(f_[i],2,l,",");

if (trs.equals("GPS")){
argv[3]=f_[i];

for (i=2; i<=6; ++i) {
trs=t.goto_rec_get_field(f_[i],3,l,",");

if (trs.equals("p")){
argv[4]=f_[i];
1

if (trs.equals("gp")){
argV[4]=f_[i];
}

if (trs.equals("g")){
argv[4]=f_[i];
}

pr[1]=fv(argv[4],l,3);
pr[2]=fv(argv[4],l,5);
pr[3]=fv(argv[4],1,2);
tra_=tryl.goto_rec_get_field(argv[5],l,l,",");
pr[4]=fv(argv[6],1,3);

str=fat.fatigue_l(argv[2],3,ll—
1.aIQV[3],20.".",pr[l],pr[2].pr[3].tra_.pr[4]."in");

tryl.dele_file(argv[8]);

if (str.equals("in")){

// java call xxx IN bearingchoicefile GPSchoicefile forcefile
// l 2 3 4
// finishselectedfile materialselectedfile

111

OUT

//
//

outfile

/* static void last(String f,

String
String
String
String
String
String
String
String

initial,
force,
stress,

mat,

finish,

9P5:

bearing,
deli){ .......

*/

trs=t.goto_rec_get_field("name.tmp",1,1,",");
fl=t.goto_rec_get_field("strname.tmp",l,1,",");
f2=t.goto_rec_get_field("bn_.tmp",1,1,",");

last(argv[8],trs,

f2, "I it);
System.exit(0);
}

if

argv[4],fl,argv[6],argv[5],argv[3],

(str.equals("out")){

try1.Append(argv[8],"failed");

System.exit(l);
}

} // fatigue ends here

else if(ate("ToIdeas")llate("toideas")){

/* To_Ideas(String
String
String
String
String
String
String
String
String
String
String
String
String
String
String
String
String
String

fA;shaft,
fB_shaft,
f_bearingAa,
f_bearingAb,
f_bearingBa,
f_bearinng,
f_pinion,
f_gear,
gear,
initial,
force,
stress,

mat,

finish,

9P5:
bearing,
fatigue,
deli) */

112

// java call ToIdeas IN gear initial force stress mat
// finish gps bearing fatigue OUT f1 f2 f3 f4 f5 f6 f7 f8

// O 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14 15 16 17
// 18 19

for (i=2; i<=10; ++i){
f_[i]=argv[i];
}
for (i=4-2; i<=10; ++i) {
trs=t.goto_rec_get_fie1d(f_[i],2,1,",");
if (trs.equals("b")){
argv[2]=f_[i];

//f_[i]="vvv";

}

for (i=4—2; i<=10; ++i) {
trs=t.goto_rec_get_field(f_[i],2,1,",")i
if (trs.equals("m")){
argV[6]=f_[i];

//f_[i1="VVV";

}

for (i=4-2; i<=10; ++i) {
trs=t.goto_rec_get_field(f_[i],1,1,",");

if (trs.equals("m")){
argv[5]=f_[i];

if (trs.equals("p")){
argv[5]=f_[i];

if (trs.equals("h")){
argV[5]=f_[i];

if (trs.equals("g")){
argV[5]=f_[il;

if (trs.equals("f")){
argV151=f_[il;

113

for (i=4-2; i<=10; ++i) {
trs=t.goto_rec_get_field(f_[i],2,1,",");

if (trs.equals("GPS")){
argv[3]=f_[i];

for (i=4-2; i<=10; ++i) {
trs=t.goto_rec_get_field(f_[i],3,l,",");

if (trs.equals("p")){
argV[4]=f_[i1;
1

if (trs.equals("gp")){
argV[4]=f_[i];
1

if (trs.equals("g")){
argv[4]=f_[i];
1

for (i=4-2; i<=10; ++i) {
trs=t.goto_rec_get_field(f_[i],1,1,",");

if (trs.trim(1.equals("45")){
argv[8]=f_[i];
1

for (i=2; i<=10; ++i) {
trs=t.goto_rec_get_field(f_[i],1,l,",");
if (trs.trim().equals("gh1-l")){
f_[2]=f_[i];
1
1

Pr111=fv(argv[4] 1113);
pr[2]=fV(argv{41,l,5);
pr[3]=fv(argv[4],1,2);
tra_=tryl.goto_rec_get_field(argv[5],1,1,",");
pr[4]=fv(argv[6],1,3);

114

//
//
//
//

//
//

/*

java call xxx IN bearingchoicefile GPSchoicefile forcefile
1 2 3 4
finishselectedfile materialselectedfile
OUT outfile

As a reminder

5

tatic void last(String f,

String initial,
String force,

String stress,
String mat,

String finish,
String gps,

String bearing,
String deli){ .......

*/
trs=t.goto_rec_get_field("name.tmp",1,1,",");
f1=t.goto_rec_get_field("strname.tmp",l,1,",");
f2=t.goto_rec_get_field("bn_.tmp",1,1,",");

//

last(argv[8],trs,argv[4],f1,argv[6],argv[5],
argv[3lrf21 "I u);

// java call ToIdeas IN gear initial force stress mat
// finish gps bearing fatigue OUT fl f2 f3 f4 f5 f6 f7 f8

// O 1 2 3 4 5 6 7
// 8 9 10 11 12 13 14 15 16 17
// 18 19

for (i=12; i<=19; ++i){
t.dele_file(argv[i]);
1

T.To_Ideas(argv[12],
argv[l3],
argv[14],
argv[lS],
argv[l6],
argv[17],
argv[18],
argv[19].trim(),
f_[2], //String gear,

trs, //String initial,
argv[4],// String force,
f1, //String stress,

argv[6],//String mat,

115

argv[5],//String finish,
argv[3],//String gps,

f2, //String bearing,
argv[8],//String fatigue,

",");

else{}
// do nothing here

}//main method ends here

// ------- out ———————
static void out(String file, int rec, int field,String cont){

//tools try1=new tools();
//try1.repl_fie1d(file,rec,field,",",cont);

tr.Append(file, cont);
return;

// ------- val ———————

static String val(String file, int r, int f){
// file --- file name
// r —--— record no.
// f ---- field no.
String hu;
hu=tr.goto_rec_get_field(file,r,f,",");
return hu;
1

// ------ fv -------
static float fv(String file, int r, int f){

float hu;
hu=fl(val(file,r,f));

return hu;

116

// -------- est_max_pitch -----------

static float est_max_pitch(float speed,float p,float radius){

//using: lb and inch.

float[]
pitch={120f,96f,80f,72f,64f,48f,32f,24f,20f,16f,12f};

float[]
f={65f,82f,98f,105f,115f,140f,l95f,245f,280f,318f,350f};

//forces

float forc;
float loc;
int loc_;
forc = tr.Tan_Force(speed,p,radius);
loc = tr.locate(f,11,forc);
loc_ = (int)( loc+l);

return pitch[loc_];

static boolean ate(String method){

String lll="0";
lll=trans_.toLowerCase();

if (lll.equals(method.toLowerCase())) {return true;}
return false;

// -------- in --------
/* static int in(int i){
return (int)(tr.StrToFlt(input_v[i]));

1*/

117

// ------- fl ---------
static float f1(String in__){
// convert int to float

return tr.StrToFlt(in__);

1

static void last(String f,

String initial,
String force,
String stress,
String mat,
String finish,
String gps,
String bearing,
String deli){

tools t=new tools();
String sl,sZ,s3,s4,sS,s6,s7,s8;
String[] s=new String[30];

String d=deli;

int i=0;

//String[] e1=new String[30];
//String[] e2=new String[30];

String[] el={" stock no. ", " D_bore(in) ", " pitch ",
" teech no. ", " pitch diameter(in) ",

" pressure angle ", " helical angle ", "
hub style ", " face width(in) "1;

String[] e2={" stock no. ", " nominal diameter(in) ",
" available max length(in) "1;

String[] e3={" Tan_force (lb)", " Angle_Ft_Fr", Rad
Force(lb)", " Shear Forc(lb)", " Axial
Force(lb)" ,

" Torque(lb in)", " Central Moment(1b

in) n,

" Moment Y(lb in)", " Moment Z(lb in)", "
Total bending moment(lb in)"};

String[] e4={" ShearStress(ksi)","
TortionalShearStress(ksi)","
MaxBendNormalStress(ksi)",

" NormalStressDueToAxialForce(ksi)", "
NormalStress(ksi)", " ShearStress(ksi)",
" Von_Mis_Stress(ksi)"};

String[] e5={ " stock no", " outer D(in)", " bore

D(in)", " width(in)", " static radial load(lbs)", "

dynamic radial load(lbs)",

" static thrust load(lbs)", " length unit

code", " force unit code", " fillet

radius(in)"," bearing type code"};

118

t.dele_file(f);
sl=t.goto_rec_get_field(gps,1,7,deli);

t.Append(f,sl);t.Append(f,sl);

.Append(f," SUCCESSFULE");

t.Append(f,"Fatigue Analysis Has Been Finished and This
Design is a Well-Done");

t.Append(f,"Gearbox Key Data Are Listed As Follows");

t.Append(f," ");

('1‘

t.Append(f," Basic Data ");

/* initial file:

1 max_rot_speed,2 max_power,3 ratio_part_hi,4
ratio_part_low,5 Dmax,6 Dmin,

7 no of helical, 8 life of bearing ......

*/

sl=t.goto_rec_get_field(initial,l,1,deli);
t.Append(f," Max. rotational speed="+sl+"rpm");
52=t.goto_rec_get_field(initial,1,2,deli);
t.Append(f," Max. power="+52+"w");
53=t.goto_rec_get_field(initial,1,3,deli);
s4=t.goto_rec_get_field(initial,1,4,deli);
55=t.goto_rec_get_field(initial,1,8,deli);
t.Append(f," Transmission ratio="+53+" : "+s4);
t.Append(f," Design life="+55+"hr");
//t.Append(f," Design life="+55);
t.Append(f," ");
t.Append(f," Material Data");

/* steel database:

AISI No., Condition of Steel Tensile Strength(Ksi),
Yield Strength, Machinability, mat type */

// 1 2 3
4 5 6

s6=t.goto_rec_get_field(f,1,6,d);
s7=t.goto_rec_get_field(f,1,1,d);
58=t.goto_rec_get_field(f,1,2,d);
t.Append(f," AISI No.="+s7);
t.Append(f," Material="+s6);
t.Append(f," Condition="+s8);
sl=t.goto_rec_get_field(f,1,3,d);
t.Append(f," Tensile Strength(Ksi)="+ sl);
sl=t.goto_rec_get_field(f,1,4,d);
t.Append(f," Yield Strength(Ksi)="+ sl);
sl=t.goto_rec_get_field(f,1,5,d);
t.Append(f," ");

t.Append(f," Machinability="+sl);

119

/* choice_file(GPS):
stock no., D_bore, pitch, teech no., pitch diameter, pressure
angle, helical angle, hub style, face width

1 2 3 4 5 6
7 8 9

stock no., D_bore, pitch, teech no., pitch diameter, pressure
angle, helical angle, hub style, face width

10 ll 12 13 14 15
16 17 18

stock no., nominal diameter, length, stock no., nominal
diameter, length, cal_length

19 20 21 22 23
24 25 */

// Note: Pinion comes first.

t.Append(f," ");

for(i=0; i<25; ++i){
s[i]=t.goto_rec_get_field(gps,1,(i+l),d);

t.Append(f," Pinion Data");
for(i=0; i<9; ++i){
t.Append(f,e1[i]+"= "+s[i]);
1
t.Append(f," ");
t.Append(f," Gear Data");
for(i=9; i<18; ++i){
t.Append(f,e1[i-9]+"= "+s[i]);
1
t.Append(f," ");
t.Append(f," Pinion Shaft Data");
for(i=18; i<21; ++i){
t.Append(f,62[i-18]+"= "+S[iJ);
1
t.Append(f," ");
t.Append(f," Gear Shaft Data");
for(i=21; i<24; ++i){
t.Append(f,e2[i-21]+"= "+s[i]);
1
t.Append(f," "1;

sl=t.goto_rec_get_field(finish,1,1,d);
t.Append(f, " Finish Condition = "+sl);

120

t.Append(f," "1;

// force file:

/* Tan_force, Angle_Ft_Fr, Rad Force, ShearForce,
AxialForce, Torque, Central Moment,

1 2 3 4 5
6 7

Moment Y, Moment Z, Total bending moment
8 9 10
*/

// There are three lines in the stress file. The second line
// might be "0".

// The first line will always consist of non—zero fields.
// The third line contains only one field which can be "g" or
// "p" or 0'gp".

// Obviously, the 3rd line serves as an indicator indicating
// that

/* g ----- first line is pertaining to gear shaft data
p ----- first line is pertaining to pinion shaft data
gp -—-— first line —-> gear shaft data

second line -—> pinion shaft data

*/
sl=t.goto_rec_get_field(force,3,l,d);
if (sl.equals("g")){

t.Append(f," Pinion Forces and Moments");
for (i=1; i<1l; ++i){
s[i]=t.goto_rec_get_field(force,1,i,d);
t.Append(f,e3[i-l]+"="+s[i]);
1

if (sl.equals("g")){

t.Append(f," Gear Forces and Moments");
for (i=1; i<11; ++i){
s[i]=t.goto_rec_get_field(force,l,i,d);
t.Append(f,e3[i-1]+"="+s[i]);
1

if (sl.equals("gp")){

121

t.Append(f," Gear-Pinion Forces and Moments (gear data
come first)");
for (i=1; i<11; ++i){

s[i]=t.goto_rec_get_field(force,1,i,d);
t.Append(f,e3[i-1]+"="+s[i]);

1
for (i=1; i<1l; ++i){
s[i]=t.goto_rec_get_field(force,2,i,d);
t.Append(f,e3[i-1]+"="+s[i]1;
1

t.Append(f," "1;

// Stress file:
// --------------------------------------------------------
/*
ShearStress, TortionalShearStress, MaxBendNormalStress,
NormalStressDueToAxialForce,

l 2 3
4

NormalStress, ShearStress, Von_Mis_Stress
5 6 7

*/

t.Append(f," Stresses");

for(i=1; i<=7; i=i+l){

s[i]=t.goto_rec_get_field(stress,1,i,d);
t.Append(f,e4[i—1]+"="+s[i]);

122

// bearing file format:

/* stock no, outer D, bore D, width, static radial load(lbs),
dynamic radial load,

1 2 3 4 5
6
static thrust load, length unit code, force unit code,
fillet radius, bearing type
7 8 9
10 ll
*/

t.Append(f," ");
t.Append(f," Bearing Data");

for (i=1; i<=11; ++i){

s[i]=t.goto_rec_get_field(bearing,l,i,d);
t.Append(f,e5[i—1]+"="+s[i]);

t.Append(f,t.goto_rec_get_field("idf.tmp",1,1,",")
+","+t.member[2-1]);

return;

1

1 // class ends here

123

E .Sample Execution Procedure and the Iﬂgut/Output

Gearbox Desigg

gb.tmp: the name of the single-lined GPSselected file used for
testing.

IN=INPUTS

OUT=OUTPUT

DB=DATABASE

item=ITEM

Initial Input File: input.dat

Database Files:
gear_1.db
shaft_l.db
steel.db

l) G/P/S selector
java call GPSselector IN input.dat OUT gb.tmp DB gear_1.db shaft_l.db

item 0
java call GPSselector IN input.dat OUT gb.tmp DB gear_1.db shaft_l.db

item 1

java call GPS IN input.dat OUT gb.tmp DB gear_1.db shaft_l.db item 0

2)a pre-evaluation function
java call where IN gb.tmp input.dat OUT go.dat

3)Forces Calculations

any of the following three productions
java call g_s_force IN gb.tmp input.dat OUT force.dat
java call p_s_force IN gb.tmp input.dat OUT force.dat
java call bothforce IN gb.tmp input.dat OUT force.dat

4) Material Selector
java call steel IN df OUT mat.dat DB steel.db ITEM 0

5) Stress Analysis
java call stress IN gb.tmp force.dat mat.dat OUT stress.dat

6) "Bear" Selector
java call bearing IN gb.tmp input.dat force.dat OUT best_bearing.dat

DB bearing.db ITEM 0

124

71 Surface Finish Condition Selector
java call inish IN steel.db OUT finish.dat DB ITEM 0

8) Fatigue Analysis

java call fatigue IN bestnbearing.dat gb.tmp force.dat finish.dat
mat.dat OUT fat.dat

9) To I—Deas

java call ToIdeas in gear_l.db input.dat force.dat stress.dat mat.dat
finish.dat gb.tmp best_bearing.dat fat.dat OUT f1 f2 f3 f4 f5 f6 f7 f8

10) pre—eval.

java cell where IN gb.tmp input.dat CONS const.dat IO "io gh" ALTs
PinionForce GearForce BothForce

FGM Desigg

Material Selector

‘1

java FGM_Mat“Se1_Kwon INPUTS OUTPUTS mat BD Materials_FGM.do item 0

Micro~Mechanics Calculations
ghnnew.bat INPUTS mat OUTPUTS funct

Calculation of Temperature Distribution
Dist_new.bat INPUTS mat fraction? OUTPUTS tempD 1.gif 2.gif

Calculate stresses and displacements
stress_fgm;new.bat INputs tempD funct fraction OUTputs st.gif st

*Note: the order of the three inputs is arbitrary

Calculate effective stress and compare with yield stress
java StressAnalysis INPUTS st mat OUTPUTS effstrs

*Note: if the effective stress is higher than the
yield stress, the program will report a
failure(exit(l)) and you should go back and

try another volume fraction function.

125

Effective stresses comparison
java finalcompare INPUTS effstrsl effstrsZ effstrs3 effstrs4...
OUTPUTS Best

*Note:

there can be as many input files as possible.

Since there, at this point, are only four types

of volume fraction functions, there are only

four input files which contains effectives stresses
corresponding to different types of volume fraction
function.

IMPORTANT, READ Carefully:

we should NOT go further to conduct this task

until all four or whatever number of effective

stress files are all ready. If there are more

volume fraction functions to try, just go back

to calculation of temperature distribution and

try a new input and go all the way through to get the
effective stress file for that particular fraction
function. Repeat this till there is not more

volume fraction function to try.

126

References

127

References

George E. Dieter, Engineering Design, A Materials and Process Approach,
McGraw-Hill, 1991

. Clive L. Dym, Engineering Design, Cambridge University Press, 1994

. T. Winograd and F. Flores, Understanding Computers and Cognition, Ablex
publishing, Norwood. NJ, 1986

. C. L. Dym and R. E. Levitt, Knowledge-Based Systems in Engineering, McGraw-
Hill, New York, 1991

. M. Asimow, Introduction to Design, Prentice-Hall, Inc., Englewood Cliffs, NJ,
1962

. J. L. Nevins and D. E. Whitney (eds), Concurrent Design of Products and Processes,
McGraw-Hill Publ. Co., New York, 1989

. David Belson, Handbook of design, manufacturing and automation, Chapter 2,
Concurrent Engineering, John Wiley & Sons, Inc., 1994

. Y. Hazony, Towards the Factory of the Future, Perspectives in Computing(IBM),
3(4), 4-11 (Dec. 1983).

. Carl Machover, The CAD/CAM Handbook, McGraw-Hill, 14 — 17, 1996

128

10. Y. Hazony, Chapter 8, Handbook of Design, Manufacturing and Automation, John
Wiley & Sons, Inc., 1994

11. L. Zeidner and Y. Hazony, Seamless Design-to-Manufacturing, Journal of
Manufacturing Systems, 11(4), 269-284, 1992

12. Chung, M. J., Carmichael, L., and Dukes, M., 1996, Managing a RASSP Design
Process, Computers in Industry, 30, pp. 49-61

13. Cutkosky, M. R., Tenebaum, J. M., and Glicksman, J., 1996, Madefast: Collaborative
Engineering over the Internet, Communications of the ACM, 39, 9, pp. 78-87

14. Lyons, K. RaDEO Project Overview, [Online] Available
http://www.cs.utah.edu/projects/alpha/arpa/mind/index.html, 1997

15. Berners-Lee, T., Cailliau, R., Luotonen, A., 1994, The World- Wide Web,
Communications of the ACM, 37, 8

16. Erkes, J. W., Kenny, K. B., Lewis, J. W., Sarachan, B. D., Sobololewsky, M. W.,
and Sum, R. N., Implementing Shared Manufacturing Services on the World- Wide
Web, Communication of the ACM, 39, 2, pp. 34-45, 1996

17. Andreoli, J-M., Pacull, F., and Pareschi, R., 1998, XPECT: A Framework for
Electronic Commerce, IEEE Internet Computer, 1, 4, pp. 40-48

18. Mark Klein, Integrated Support for Process, Conﬂict, and Rationale Management in
Coorperative Design, Handbook of Design, Manufacturing and Automation, page 65-

75, 1994

19. RC. Smith, The Contract Net Protocol: High-level Communication and Control in a
Distributed Problem Solver, IEEE Trans. Comput. C29(12), 1104-1113, Dec. 1980

129

20. T. Winograd, “A Language / Action Perspective on the Design of Cooperative

21.

22.

23.

24.

25.

26.

27.

28.

29.

Work”, Proc. CSCW 86, page 203-230, 1986
B94 Precision Mechanical Components, W.M.Berg, Inc, 1996

Arthur H. Burr, and John B. Cheatham, Mechanical Analysis and Design, Prentice
Hall, 1995

Marks’ Standard Handbook for Mechanical Engineers, eighth edition, McGRAW—
HILL Book Company, page 8-138 through 8-140, 1979

Design of Transmission Shaﬂing, ANSI/ASME B 106.1M-1985, pp. 4-6, 1985

F. W. Paul, Jr. and TR. Faucett, The Superposition of Stress-Concentration Factors,
J. Engrg. Industry, Trans. ASME, Vol. 84, pp. 129-134, 1962

Mori, T. and Tanaka, K. Average Stress in Matrix and Average Elastic Energy of
Materials with Mistiﬁtting Inclusions, Acta Metallurgica et Materialia, 21, pp. 571-
574, 1973

Wu, T. T., The Effect of Incluction Shape on the Elastic Moduli of a Two-Phase
Material, International Journal of Solid and Structure, 2, pp. 1-8, 1985

Eshelby, J. D., The Determination of the Field of an Ellipsoidal Inclusion and
Related Problems, Proceeding of the Royal Society, Lodon A, 241, pp. 376 — 396,
1957

Hatta, H. and Taya, M., Equivalent Inclusion Method for Steady State Heat
Conduction, International Journal of Engineering Science, 24, pp. 1159 — 1172, 1989

130

so. Timoshenko, s. P. and Goodie, J. (3., Theory of Elasticity, 3'“I Edition, McGraw-Hill,
N.Y., P. 442, 1970

131