Is concerned with the reduction of product range assemblies parts materials and design?

ABSTRACT

Design for manufacture and assembly (DFMA) is the practice of designing products with manufacturing in mind so they can be designed in the least time with the least development cost; make the quickest and smoothest transition into production; be assembled and tested with the minimum cost in the minimum amount of time; have the desired level of quality and reliability; and satisfy customers needs and compete well in the marketplace.

DFMA considers manufacturing issues early to shorten product development time and ensure smooth transitions to manufacturing, thus, accelerating time-to-market. DFMA reduces costs since products can be quickly assembled from fewer standard parts. Parts are designed for ease of fabrication and commonality with other designs. This, in turn, means a broader product line can be created by assembling common “building blocks” modules into new products.

The basics of DFA

DFA has some basic principles and these are:

Minimise the part count in the assembly by combining part functions.

Parts should have self-aligning and self-locating features so that they cannot be installed incorrectly.

Parts should have self-fastening features.

Parts should not be ‘left-’ or ‘right-handed’, even if this means adding unused features to the parts.

Parts should either be symmetrical (for easy orientation during assembly) OR very asymmetric for clear identification (for easy detection and orientation).

Parts should automatically check that all the previous parts are present and located correctly.

Parts should be designed to reduce the need for re-orientation during assembly.

Parts should be designed for handling and insertion (both manual and automatic).

Parts should be designed for easy gripping and transfer in fixtures using registration locations.

An assembly should have a ‘base’ part into which all other parts are located.

Parts should be designed to be assembled from the top down onto the ‘base’ part to use gravity rather than fight against it.

Fasteners should be avoided where possible.

Plastics processing is ideally suited to DFA. Using twin shot moulding or multi-layer extrusion can radically reduce the number of parts needed.

2.09.4.1 Fuel Assembly Design

Fuel assembly designs for all reactor types (i.e., PWR, BWR, and PHWR) are constantly evolving as assemblies/bundles are improved to increase fuel performance (i.e., higher powers, higher burnup, increased power ramp tolerance) to ultimately improve operational economics and safety margins. Changes are driven by many factors and some changes directly or indirectly impact tolerance to PCI failure. For example, an early and continuing trend in design evolution is sub-division of the fuel into smaller diameter elements/rods to increase the total number of elements/rods, which increases assembly/bundle power without a corresponding increase in UO2 temperature, thus mitigating thermally driven fuel failure mechanisms,171 or allowing fuel uprating.172 However, excessive fuel sub-division creates fuel fabrication challenges, increased cladding material (i.e., neutron absorption and possible source of hydrogen gas release via oxidation reaction of Zr with steam in the event of a severe accident), flow challenges under normal operating conditions and accident conditions, and potential for element sag/creep. An optimized compromise of the aforementioned design features is eventually reached.

Other changes in general fuel assembly/bundle design include variations on fill gas pressure, presence and design of plenums to collect fission gases, particularly for LWR’s grid changes to mitigate grid-to-rod fretting and improve flow conditions; for PHWRs, changes to appendage design to improve Critical Heat Flux (CHF), general optimization of rod end regions in the reactor to mitigate end-flux-peaking and PCI with the endclosure weld region. Changes to fuel assemblies directly targeting PCI mitigation are more typically found in cladding modifications (i.e., advanced alloys, barrier liners, or application of lubricants), and variations to the pellet design (i.e., geometry, fabrication, and additives). These changes are described in the following sub-sections.

5.5.4 Toward a future classification and support structure for manufacturing requirements

Available guidelines for DFA and DFM (e.g., those developed by Boothroyd et al. [6]) provide best practices for design. These guidelines are generic and are best suited for greenfield applications where the manufacturing system will be designed according to the product. In the case of legacy manufacturing systems, considering the manufacturing system is a challenge for two reasons. First, the consideration of the legacy manufacturing system should not limit the innovativeness of the new product. Therefore, establishing a balance between the manufacturing system and the new design is the first challenge. The second challenge pertains to how the manufacturing system requirements should be communicated and integrated in the product design. The latter might be overcome by introducing a systematic way of working with requirements, especially from the manufacturing side. It is important to be able to systematically elicit requirements from the manufacturing perspective. Additionally, manufacturing should be able to make a distinction between “demanded” and “recommended” requirements. This would help designers to define a boundary for the product design. Manufacturing can also help designers to understand the source and effects of manufacturing requirements. The model in Fig. 5.9 can be a useful tool for manufacturing to produce a map of their requirements. Documentation and formal agreement on requirements between product design and manufacturing can potentially improve the way of working in the early stages of NPD.

DFM guidelines

DFM also has some basic guidelines for good designs and these are:

4.2.4 Design for manufacture

The possibility of using biocomposite materials in many areas of engineering application has emphasised the need for design for manufacture. Biocomposite materials are manufactured using different processes: hand lay-up, compression moulding and extrusion, to mention but a few. These processes and their effects on the properties of various biocomposite materials are extensively discussed in the next section. The expected properties and intended areas of application of a biocomposite are important determinant factors to be considered during design for its manufacture. Close to these factors is the geometry of the biocomposite products, among others.

Importantly, Mohanty et al. (2002) proposed a tri-corner approach in designing for the manufacture of biocomposites with excellent or desirable strength: (i) effective, (ii) low cost and efficient biofibre treatment, effective blending and functional matrix modification, and (iii) choice of efficient biocomposite processing conditions, as illustrated schematically in Fig. 4.6. A deeper discussion on each of these approaches can be found in the subsequent sub-sections and other chapters.

Moreover, it is expected that biocomposite design for manufacture supports a reduction in the costs of manufacturing, components, assembly, supporting production and considers the impact of design for manufacturing decisions on other unavoidable factors. Recently, design for manufacture has been combined with a design for assembly, as a simultaneous effort. They are jointly referred to as a design for manufacture and assembly (DfMA). DfMA has numerous benefits over the traditional design approach, where many manufacturing processes and post-manufacturing operations are required. A single part of biocomposite materials can be manufactured, just like forged or cast materials (Fig. 4.7(b)), instead of Fig. 4.7(a). A typical example is shown in Fig. 4.8, where an interior carpet of a car’s door is made by hemp fibre-reinforced polyethylene biocomposites.

Furthermore, there are numerous advantages of having effective DfMA (single biocomposite part), as shown in both Figs. 4.7(b) and 4.8 over the traditional design approach. These benefits include, but are not limited to, the following:

Reduced costs (of materials, design, manufacturing and assembly).

Ease of design, manufacturing and installation/assembly.

Not susceptible to failure, hence longer durability is guaranteed.

Lower time/effective time management from design to installation/repairs or recycle stages.

Use of less equipment, labour and facilities.

Effective waste management.

Ease of maintenance and repairs.

Better aesthetics and reduced weight.

Process instructions

Process instructions are at the heart of successful plastics processing but many companies neither set machines in a logical manner, record these settings accurately nor enforce the use of these settings (see Section 5.12).

Pre-production control plan

A pre-production control plan is essential before production is started. This is similar to the site-wide control plan discussed in Section 4.18 but is much more product-specific.

The pre-production control plan is covered in more detail in Section 10.3.

Tip - A pre-production control plan will inevitably contain more product and process controls than the final production control plan.

IV. Nondeterministic Finite Automata (nfas)

In this section we define the nondeterministic finite automata (NFAs). A DFA being deterministic has only one computational thread. However, an NFA, because any given configuration may have many possible next configurations, cannot be described by a single computational thread. An NFA computation should be visualized as many superimposed simultaneous threads. But an NFA is not a parallel computer—it does not have any ability to run simultaneous computations. Instead, one can imagine the NFA behaving as follows: if the problem the NFA is solving has a solution, then the simultaneous threads will collapse into a single unique thread of computation that expresses the solution. If the NFA cannot solve the problem, the threads collapse into failure.

It is obvious that an NFA is not a machine that one can build directly. So why is it worth considering? Here are three reasons. The first is simply that this model has more expressive power than the DFA in the sense that it is easier to design NFAs than DFAs for some languages, and such NFAs usually have fewer states than the corresponding DFA. A second reason is that the abstract concept of nondeterminism has proved very important in theoretical computer science. Third, although NFA are more expressive when it comes to programming them, it turns out that any language that can be accepted by an NFA can also be accepted by a DFA. We prove this result via simulation in Section V.

Nearly all of the basic definitions about DFAs carry over to NFAs. Let us mention the enhancements to a DFA that yield the NFA model and then look at some examples. The new features in order of descending importance are the use of nondeterminism, the use of Λ-transitions, and the use of transitions on arbitrary strings.

Nondeterminism means that the machine could potentially have two or more different computations on the same input. For example, in Fig. 6 we show a portion of an NFA. In this NFA from state q0 on reading an a, the machine could go to either state q1 or state q2. This behavior is nondeterministic and was not allowed in the DFA. In our examples we will see that this feature is very useful for designing NFAs.

A Λ-transition allows the machine to change state without reading from the input tape or advancing the input head. It is useful to think of such a transition as a jump or goto. Why would such a jump be useful? As an example suppose we want to recognize the language {a}* ∪ {b}* over the alphabet {a, b}.The NFA shown in Fig. 7 accepts this language. Since NFAs, like DFAs, only get to read their input once, the two Λ-transitions start two threads of computation. One thread looks for an input that is all a's, the other looks for an input that is all b's. If either thread accepts its input, then the NFA stops and accepts. Thus we can accept (formally defined in this section) {a}* ∪ {b}* very easily; the design is also conceptually appealing. Notice that without using Λ-transitions the machine needs three accepting states.

A DFA for accepting the language {a}* ∪ {b}* is shown in Fig. 7B. This machine has more states, transitions, and accepting states and it is more complex. It turns out that at least four states are needed for any DFA that accepts the language {a}* ∪ {b}*.

Now let us look at the third enhancement to DFAs. By use of arbitrary transitions on strings we mean that a transition can be labeled with any string in Σ*. Essentially, this means an NFA is allowed to read more than one input symbol at a time (or none). How might this feature prove useful? Coupled with nondeterminism this enhancement allows us to design simpler machines. As an example recall the DFA presented in Fig. 5 that accepted the language {x | x ∈ {a, b, c}* and x contains the pattern abac}. An NFA for accepting this same language is shown in Fig. 8. Until we formally define computations and acceptance for NFAs, think of this machine as gobbling up symbols unless it encounters the pattern abac in which case it jumps to an accepting state and then continues to gobble up symbols. We have reduced the five-state DFA from Fig. 5 to a two-state NFA using this new feature.

Rather than go through all of the definitions presented for DFAs again for NFAs, we highlight the changes in defining NFAs.

Definition 8

A nondeterministic finite automaton (NFA) is a five-tuple M = (Q Σ, Δ, q0, F) that is defined similarly to a DFA except for the specification of the transitions. The transition relation Δ is a finite subset of Q × ∑T* × Q.

Notice Q × ∑T* × Q is an infinite set of triples but we require Δ to be finite.

The new specification of transitions handles all of the enhancements that were discussed above. Since we now have a relation instead of a function, the machine can be nondeterministic. That is, for a given state and symbol pair it is possible for the machine to have a choice of next move. In Fig. 6, for example, the two transitions (q0, a, q1) and (q0, a, q2) are shown. Of course, in a DFA this pair of transitions would not be allowed.

Since Δ ⊆ Q × ∑T* × Q this model incorporates Λ-transitions and arbitrary string transitions. For examples, in the NFA shown in Fig. 7A the two Λ -transitions (q0, Λ, q1 and (q0, Λ, q2) are shown and in Fig. 8 the transition from state q0 to q1 is (q0, abac, q1).

Finally, since Δ is a relation that is not total, there can be state symbols pairs for which Δ is not defined. In Fig. 7A the machine does not have a transition out of state q0 on either a or b. So, in the full representation of Δ there simply are no transitions (q0,a,q) nor (q0,b,q) for any q ∈ Q. If a thread ever entered such a state, the thread would terminate.

Nearly all of the other definitions for DFAs carry over with very little modification. For example, ⊢ still relates configurations but now we might have C1 ⊢ C2 and C1 ⊢ C3, where C2 ≠ C3; a situation that was not possible in a DFA. One definition we need to rethink is that for acceptance. Since NFAs are nondeterministic, there may be several possible computation threads on the same input. We say an input is accepted if at least one thread leads to acceptance.

Definition 9

Let M = (Q, Σ, δ, q0, F) be an NFA. M accepts input x ∈ Σ* if (q0, τI(x))⊢M*(f,τF(x)) for some accepting state f ∈ F. Such a computation is called an accepting computation. Computations that are not accepting are called rejecting computations. The language accepted by M, denoted L(M), is {x | M accepts x}. The union of all languages accepted by NFAs is denoted LNFA. That is

LNFA= L|there is an NFAMwithL=LM .

On a given input an NFA may have both accepting and rejecting computations. If it has at least one accepting computation, then the input is accepted. That is, the input is accepted if at least one thread leads to an accepting state. The language accepted by an NFA consists of all strings that the NFA accepts. Let us consider an example of two possible computations of the NFA M shown in Fig. 8 on input abaca.

The first is

(q0,[1,abaca] )⊢M(q0,[2,abaca])⊢M(q0,[3,abaca]) ⊢M(q0,[4,abaca])⊢M(q0,[5,abaca])⊢M(q0,[6,abaca ])

and the second is

(q0,[1,ab aca])⊢M(q1,[5,abaca])⊢M(q1,[6,abaca]).

.

Clearly, the two computations are very different. In the first one we use up all of the input in five steps but do not end in an accepting state. Thus, this is an example of a rejecting computation. In the second case we use up all of the input in two steps and do end in an accepting state. Thus, the latter computation is accepting. Since there was an accepting computation, the input abaca is accepted by M and abaca ∈ L(M). To prove that an input is accepted by an NFA, one only needs to demonstrate that a single accepting computation exists. However, to argue that an NFA does not accept a given string, one must show that all possible computations are rejecting. This is usually more difficult.

1.2.2.5 Inulinases

Inulin-acting enzymes belong to glycoside hydrolases (GH) families 32 and 91. Family GH32 mainly consists of exoinulinase (E.C. 3.2.1.80), endoinulinase (E.C. 3.2.1.7), 1,2-β-fructan 1F-fructosyltransferase (E.C. 2.4.1.100), 1-exohydrolase (E.C. 3.2.1.153), and sucrose 1F-fructosyltransferase (E.C. 2.4.1.99). Inulinases belonging to family GH32 have tremendous applications in the food and pharmaceutical industries. Exoinulinases carry out sequential degradation of inulin from its nonreducing end, releasing fructose with a molecule of glucose, while endoinulinases act arbitrarily on the internal β-2,1-glycosidic linkages of inulin to produce fructooligosaccharides of varied chain lengths (Fig. 1.3). The action of 1-exohydrolase is similar to exoinulinase, and it acts on inulin-type fructans to produce fructose. By acting on inulin, 1,2-β-fructan 1F-fructosyltransferase produces fructooligosaccharides, whereas 1F-fructosyltransferase specifically produces short-chain fructooligosaccharides from sucrose. Family GH91 includes inulin transferases (E.C. 4.2.2.17 and E.C. 4.2.2.18) that eliminate the fructan chain (inulin) from the terminal d-fructosyl-d-fructosyl disaccharide, releasing α-d-fructofuranose-β-d-fructofuranose 1,2′:2,1′ dianhydride (DFA-I) and α-d-fructofuranose-β-d-fructofuranose 1,2′:2,3′ dianhydride (DFA-III), respectively. These enzymes are also known as fructotransferases.

Inulinases have been reported from the inulin-storing tissues of plants, animals, and a wide variety of microorganisms; but they are present in very minute quantities in plants and animals. Therefore, microorganisms are the source of choice for inulinase production, as they offer many advantages, including easy cultivation and genetic manipulation, high production yield, rapid multiplication, and considerable variability in biophysical and biochemical characteristics [21,28]. Among the microorganisms, Aspergillus sp., Penicillium sp., Kluyveromyces sp., Bacillus sp., Pseudomonas sp., and Streptomyces sp. are potent inulinase producers [25]. Inulinases from fungal sources are preferred over other microbial sources, as they can tolerate low pH and high temperature conditions, and require low substrate concentrations for their optimal growth. Among Aspergilli; A. niger, A. niveus, A. ficuum, A. tamari, A. terreus, and A. tubingensis are efficient inulinase producers. Whereas Penicillium subrubescens, P. expansum, P. purpurogenum, P. rugulosum, P. trzebinski are potent inulinases producing Penicilli [28]. Recently, Penicillium oxalicum [146,147] and Aspergillus tritici [148] have been reported as potent inulinase producers. Bacterial strains such as Bacillus sp., Clostridium sp., Streptomyces sp., Xanthomonas sp., and so forth are used for inulinase production because of their ability to survive under high temperatures, acidity, alkalinity, and salinity conditions. Recently, Bacillus sp. SG7 [149], Acinetobacter baumannii [150], Bacillus centrosporus ZF-9 [59], and B. safensis [151,152] have been reported as new inulinase producers. Moreover, some extremophilic bacteria such as Clostridium thermoautotrophicum, Sphingobacterium sp., Streptomyces sp., and Xanthomonas oryzae have also been reported as efficient inulinase producers [21]. Among the yeast strains, Meyerozyma guilliermondii [153], Cryptococcus aureus [154], and Zygosaccharomyces cerevisiae [155] are efficient inulinase producers. A few yeast strains, such as Zygosaccharomyces, Gordonia, Hanseniaspora, Torulosopra, Saccharomyces, Metschnikowia, and Lachancea have also been screened for inulinase production [156]. Nowadays, thermotolerant microbial species are becoming an important source of inulinases, as they reduce the chances of contamination and support a higher yield of inulinase under extreme conditions [157]. Inulinase production has been reported in both solid state, and in submerged fermentation, using a wide range of substrates and microorganisms [21,28].

Microbial inulinases can actively hydrolyze inulin into glucose, fructose, and fructooligosaccharides (FOSs). The production of high fructose syrup [22,23,26,27] and fructooligosaccharides [19,25] are the two major applications of inulinases in the food industry. Inulinases have also been used in the production of ethanol [158], single cell oil [159], single cell proteins [160], citric acid [161], lactic acid [162], sorbitol [163], mannitol [164], pullulan [165], 2,3-butanediol [166], and so forth.