The Generation and Use of Partial Solutions in Process Synthesis

The Generation and Use of Partial Solutions in ProcessSynthesis

Eric S FragaDepartment of Chemical & Biochemical Engineering

University College LondonLondon WC1E 7JE

United Kingdom

June 16, 2000

Abstract

The use of automated tools can be of great benefit to an engineer involved in a large, complex tasksuch as the design of a chemical plant. Such tools, however, must provide the engineer with more thanjust a solution to the problem. It is vital that the engineer be given an insight into the reasons for thechoice of a given solution. This is particularly important in optimization of complex problems. In thesecases, the advantages of the solution (other than a better value of the objective function) are often notimmediately obvious and the user is asked to take the results on faith.

A process synthesis procedure which provides some indication of why a particular design alternativewas chosen can be invaluable, especially during the early stages of design when many decisions are stillto be made. This paper describes a novel implicit enumeration method, using dynamic programming,which enables and encourages an engineer to easily explore the solution space for new problems. Whencompletely feasible solutions are not available, the synthesis tool provides information in the form ofpartial solutions which can lead to a better understanding of or a different perspective on the problem.Using partial solutions, the method can itself generate better solutions, dynamically increasing the searchspace for solutions that include complex recycle structures.Keywords: process synthesis, optimization, graph traversal, dynamic programming, sequential modular,computer aided design.

1 Introduction

The synthesis of chemical process flowsheets is a difficult problem due to the number of alternative designspossible in many cases and to the numerical problems caused by nonlinear models. Algorithmic techniquesfor synthesis have been developed, including evolutionary approaches starting with existing designs,1,2

methods based on the use of decomposition3-5 or hierarchical representations,6,7 optimization proceduresbased on extracting process flowsheets from superstructure representations,8-13 and even methods basedon stochastic optimization procedures.14 These methods have been shown to be quite successful, even forthe generation of complex processes including recycle structures and heat integration.

Approaches based on superstructures are more amenable at achieving optimal solutions. The optimizationprocedures are able to consider simultaneously all aspects of the process flowsheets, including reaction andseparation sections and heat integration. However, generating optimal process flowsheets requires that thesuperstructure include all feasible structures for the particular problem. The superstructure must often bedefined by the user explicitly, a task which may be onerous. Generating the superstructure automaticallyhas been attempted, including the work of Friedler et al.15 to generate the maximal structure, out of whichprocess flowsheets can be extracted and optimized, and also approaches based on implicit enumeration togenerate and search the superstructure simultaneously.16,17

1

2

A serious limitation of algorithmic techniques based on superstructures is that they often simply present theuser with a solution, with no justification or rationale describing why the solution is the best. If the user hascomplete and implicit trust in the techniques embodied in the software system, this may not be a problem.However, in general, the user has little awareness of the actual process undertaken by the procedure andtherefore little reason to trust the results presented. Also, many systems are based on local optimizationtechniques and hence will not be successful in identifying the global optimum, yet the user will not haveany indication of how far from the global optimum the solution is. When considerations of operability, forexample, are introduced, the lack of knowledge about the solution and how it fits in with the actual searchspace becomes even more significant.

In a recent paper,8 we described a new implicit enumeration approach for process synthesis, using discreteprogramming techniques, which introduced a technique for handling and identifying recycle streams. Theresults showed that with appropriate unit models, complex problems could be tackled without the explicitgeneration of complex superstructures. The method, however, required the unit models themselves to beaware of recycle streams. Although effective, this may appear counter-intuitive to the user of the system.In some circumstances, it may also not generate a sufficiently diverse solution space. This paper intro-duces a new method which dynamically generates a more complex search space, capable of automaticallyidentifying suitable recycle streams when necessary.

The new method is based on being able to identify why infeasible subproblems, encountered during thesearch procedure, are in fact infeasible. The concept of partial solutions is introduced and simple, userdefinable, heuristics are used to rank these solutions. The underlying optimization procedure is based ondynamic programming with an implicit enumeration search procedure. A benefit of the new approachis that, for problems that can not be solved, information about the reasons for failure is available. Eachsubproblem encountered in the search procedure is recorded. If the subproblem can not be solved, it istagged with a list of problems which were responsible for the lack of success in finding a feasible solution.This list of reasons for failure is accumulated recursively. The information collected enables us to developautomatic techniques for generating flowsheets with recycle streams. More importantly, the user can bepresented with partial solutions to the problem along with an explanation of why a complete solution couldnot be found. This may be useful to spur the development of novel technologies and the generation ofcompletely new processes. It also encourages the engineer to use the synthesis tool iteratively, refining theproblem based on a partial solution and attempting it again.

2 Information on Failure

One of the major drawbacks to the use of automation tools, especially in optimization, is a lack of infor-mation provided when a tool fails or, for that matter, even when it succeeds. Quite often, the reason forfailure can be as important as any valid solution might have been. Identifying such reasons can lead to newdirections in research or to new approaches for solving a given problem, directions and approaches whichmight not have been taken otherwise.

In order to automatically handle the generation of process flowsheets with recycles, in the context of adynamic programming approach, it is necessary to identify streams which are suitable for recycling. Oneapproach used, when attempting synthesis manually, is to identify streams which can not be processed(profitably) and to consider recycling them if possible. The difficulty, from the point of view of automation,is the identification of these streams. This need for identification and the desire for information when thesynthesis tool fails to generate a feasible solution are complementary. Solving the latter will automaticallyprovide the former. That is, generating the information necessary for explaining why a synthesis procedurefails should enable the tool to identify streams which can not be processed and which might be suitable forrecycling.

This section describes how an algorithmic technique for process synthesis has been extended, initially, toprovide useful information when the search does not yield a feasible solution. The underlying approach isbased on the use of implicit enumeration for the simultaneous generation and search of a graph representing

Partial solutions in process synthesis E S Fraga, UCL

3

the solution space. Dynamic programming techniques are used to ensure that repeated problems are solvedonly once, balancing the computational requirements of an exhaustive search with an increase in memoryuse. The system, Jacaranda, has been implemented in Java and is part of the FiSH (Fully-integratedSynthesis Hierarchy) system.18 Jacaranda is a new software implementation which includes all the featuresavailable in the CHiPS process synthesis package.16

Process synthesis using dynamic programming is based on using a cost table which stores the best (partialor complete) solution to every subproblem encountered during the search procedure. This requires the useof discretization to define a finite (albeit possibly large) search space and a well defined index operationfor accessing entires in the cost table. Jacaranda uses a dynamic indexing procedure19 which defines astring representation for every subproblem. The string is used as an index into the cost table through theuse of dynamic hashing techniques.20,21 String indices are generated using a combination of componentbase flows, providing a mapping from the continuous space to a finite discrete space. As this mapping isunder user control, it can be tailored for the problem under consideration, or, in fact, can encourage theuse of the synthesis tool in an iterative and explorative manner.8,19,22 The combination of hashing with adynamic indexing method creates an efficient yet flexible method for the reuse of computation.

2.1 Solution Hierarchy

Providing information on the success or failure of subproblems can be incorporated into the search proce-dure by extending the information stored in the cost table. When a subproblem has been solved success-fully, the cost table is used to store the cost of the optimal solution (or the value, if maximizing profit) andthe particulars of the solution, such as the first downstream unit which processes the stream represented bythe subproblem and the outputs of that unit. This results in a recursive description of the solution rootedat a given subproblem. The information stored in the cost table can be extended to include reasons why asubproblem was not solved, and this information can, as the solution itself is, be described recursively interms of any further subproblems.

We have decided to describe reasons for failure in terms of a hierarchy, listed below. A subproblem isdefined as a stream which must be processed and may have associated with it a set of qualifiers used forincorporating recycle streams or for limiting the number of instances of units8 and virtual heat links (VHLs)used for the synthesis of heat integrated processes.23 In this context, the hierarchy is as follows:

1. Product [PRODUCT]: This subproblem defines a leaf node in the search graph, a node which repre-sents a final product stream.

2. No utilities [NOUTIL]: Although at least one unit may be able to process the stream, the heating orcooling requirements of such units can not be met with the utilities available or through process heatexchange embodied by the virtual heat links (VHLs) present.

3. No technology [NOTECH]: None of the unit technologies available for the given subproblem canprocess the stream associated with that subproblem.

4. No Solution [NOSOLN]: No solution is available for this problem. This only occurs when a cycle inthe search graph is found: a subproblem can not be attempted as the process of finding a solution forit is already in progress.

Each level in the hierarchy is assigned a value (by the user). These values are used to define a status valuefor each solution to a subproblem, a value that depends on the status of the current unit node with 0 if theunit design is feasible and if the associated heating and cooling requirements can be met added to the statusvalues of each of the subproblems the node generates:

��


4

where �� denotes the “status of” function, � is the given problem, � a unit design, and ��

the ��subproblems generated by the unit design. This equation is analogous to the cost estimation: the cost ofthe solution to a problem is the cost of a unit design plus the cost of processing each of the products of theunit.

The lower the status value of a solution, the better the solution is. In the default situation, the differententries in the hierarchy are given different values with PRODUCT=0 through to NOSOLN=3.

The reason for a hierarchy is to allow us to compare alternative solutions for a given subproblem. Forexample, if one alternative fails due to a stream which can not be processed at all but another alternativefails because there were no utilities which could handle a unit’s requirements, the latter is chosen as a betterpartial solution as it appears higher in the hierarchy. Providing new utilities is more likely easier to achievethan developing completely new processing technologies.

2.2 N-best solutions

The underlying dynamic programming approach enables us to generate the N-best solutions, for any valueof N. For each subproblem, a ranked list of solutions is determined and these are used to generate a rankedlist for any problem which references this subproblem. The list is ranked according to cost. However, inorder to increase the diversity of the solutions presented to the user at the end, solutions in the list mustnot be similar to each other. In the context of early design, similar solutions are those which have thesame sequence of units, disregarding actual unit operating conditions and heat exchange networks wheninserting solutions into the ranked list. The actual procedure used to decide if two solutions are dissimilaris based on the use of string representations.19

In introducing status levels, as described above, it is no longer appropriate to compare solutions purelyon the basis of cost. Partial solutions may appear cheaper (they may contain less units than completesolutions) or more expensive (they do not include all possible products which may have negative costs,i.e. values). Therefore, the actual status value is used to rank solutions when placed in the N-best list.Moreover, solutions are deemed to be similar if they have the same status value. In the early stages ofdesign, we wish to present the engineer with as wide a scope of solution structures, partial or complete,as possible. When comparing solutions, their status value is checked first. If both solutions have the samestatus value, then the solution with the lower cost is considered to be better. By basing the definition ofsimilarity on the status value, we are likely to present a range of solutions that may include one completesolution plus solutions which are partial because of different reasons (or different number of failures).

The recursive algorithm shown in Figure 1 indicates how the hierarchy is used. More detailed descriptions Fig 1of other aspects of the underlying search procedure, such as the generation of recycle structures, consider-ation of heat integration simultaneously with process structure, the effect of discretizations on the searchspace, and the efficient reuse of computation, have appeared earlier in the literature.8,16,19,23,24 Except asnoted below, the addition of a hierarchy for partial solutions does not affect the properties of the underlyingsearch procedure.

2.3 Branch & Bound Approach

The introduction of partial solutions has one effect on the branch and bound algorithm used by the searchprocedure. The recursive search can no longer prune sections of the search graph purely on a cost basis.Partial solutions will have only partial costs. The branching algorithm therefore must incorporate the statuslevel into the bounding procedure to identify sub-graphs to prune.

The base algorithm would prune sub-graphs by looking at the current node cost plus the costs of subprob-lems already solved. The latter are identified through the use of the dynamic programming cost table,implemented as a dynamic hash table and indexed through the use of string encodings for problem rep-resentation. Assuming that all costs are positive and that the hierarchy status values are also all positive,bounding can still be performed in the same way. The information about the current node (cost and status


5

value) is combined with the information available for the subproblems which have been solved to generatea current lower bound on the cost and the status value. The combination of the two can be used to compareagainst the current N-best solution list for the problem, possibly pruning the search at the current node.If pruning is not performed, one of the unsolved problems is tackled and the cost/status information isupdated. The whole procedure is repeated until either the search is pruned at this node or the subproblemshave all been solved.

2.4 Example I: 5 Component Separation Sequence

This example consists of a five component hydrocarbon feed which must be separated into its constituentcomponents at high purity.25 Distillation is available as the only processing technology. This problemis easily solved, generating the solution shown in Figure 2. However, using the hierarchical synthesis Fig 2procedure, we are able to generate not only all possible structures but also a ranked list of partial solutions.These latter solutions can be used to gather further information about the problem which may suggestalternative solutions. In particular, the best partial solution, shown in Figure 3, indicates that the most Fig 3difficult aspect of the process flowsheet is the separation of component D from E. Specifically, this partialsolution is defined as the best solution in which one separation is not performed (and therefore not costed).In other words, this solution is the one that exhibits the lowest cost for the remaining process.

Studying the complete solution, shown in Figure 2, is not sufficient for identifying this fact. Although theD/E separation is indeed the most expensive in the process, it involves other components which might ormight not affect the overall cost. The generation of partial solutions allows the procedure to isolate theseeffects, providing the engineer with a little more information about the search space. This knowledge couldenable an engineer to develop better solutions by considering alternative separation technologies, appliedfirstly to the D/E separation.

2.5 Example II: Separation problem with wide range boiling components

Being able to efficiently explore the solution space for synthesis is particularly important for large problem-s. In these cases, it is much more difficult to a priori suggest reasonable structures. The sample problempresented here is again a separation problem but now with a 10 component feed. The number of alter-native processes grows factorially with the number of components,25 even when the number of differentprocessing technologies is limited.

In this example, the components in the feed present a wide range of boiling points and hence may require avariety of utilities to meet the requirements of distillation units in the structure. One of the possible statuslevels in the hierarchy is activated when no utilities are available for a specific design. The default hierarchylevels are used and the best solution found is shown in Figure 4. It identifies the separation D/E as the best Fig 4to perform first.

The best partial solution, shown in Figure 5, is somewhat different. The first separation, shaded in the Fig 5figure, is now G/H and there are few common substructures in the two solutions. The G/H separationrequires a utility to heat a stream to 562 degrees K. No such utility is available. Comparing the costs showsthat if an appropriate utility could be found, the cost of the new utility sufficient to satisfy the requirementswould have to be less than "!# �$% '&�( for the partial solution to be better than the best found in this initialrun. This provides the engineer with some awareness of which constraints are restricting the selection ofdesign alternatives. The extra information may be used to advantage by, for example, introducing a newutility into the problem definition or by exploring different technologies which may not have the sameconstraints.

These two small case studies show that even for problems in which feasible solutions exist, and can befound by the synthesis procedure, the generation of partial solutions can provide useful insight into theproblem. This insight may be sufficient to enable an engineer to identify alternative solutions not embodiedin the current problem definition. This is particularly advantageous in the early stages of design where adeeper understanding of the process will lead to better final designs.


6

3 Iterative Dynamic Programming

As soon as information is collected by a search procedure in an automatic and systematic manner, theobvious next step is to make use of this information in the search itself. This section describes how thestatus information, generated by the search procedure and tagged to the solution (partial or otherwise)of each subproblem can be used to generate complete solutions automatically. In particular, the searchalgorithm has been extended to provide the capability of identifying suitable recycle structures withoutuser intervention.

3.1 Example III: Motivating Example

Consider a feed stream consisting of the three components, ABD, with the desire to produce C, with D asa valuable side-product. Also suppose that we have available the following technologies: distillation and areactor which achieves partial conversion (70%) of A and B to produce C. If we attempt this problem usingthe new hierarchical search procedure, as described above, we can generate a set of alternative processes,all of which are partial solutions. The best alternative is shown in Figure 6 and consists of a distillation Fig 6unit which separates D from the feed, a reactor which produces a stream ABC, and finally a distillationunit which seperates the desired product C from the unconsumed reactants A and B. This latter stream,indicated as “3A 3B” in the figure, is left dangling, indicating that further processing increases the statusvalue and yields no feasible solutions. The result is not surprising. Even less surprising is the step theengineer would follow next if the design procedure were handled manually: the dangling unconsumedreactant stream would be recycled back to the reactor, increasing the production of the desired product C. Itwould be desirable to have the synthesis procedure attempt this automatically, generating a flowsheet withthe appropriate recycle structure and with units designed and costed accordingly.

3.2 Dependencies

Having implemented a mechanism for defining the status of each subproblem within a hierarchy, we nowneed to identify the reason for its classification. In other words, we would like to ascertain why a problemwas not solved successfully, if such were the case. This is achieved by tagging the solutions of eachunsuccessful subproblem with a list of dependencies. These are used to quantify more clearly the aspectsof a problem which lead to difficulties. The use of status alone is not enough information to automaticallygenerate, for example, structures with recycle streams.

Every solution for each problem encountered during the search procedure is assigned a list of dependencies.A dependency is a subproblem which, if it could be solved successfully, would also allow the currentproblem to be solved. Dependency lists are defined in a recursive manner, similar to how the status valueis calculated. If a solution to a problem is composed of a unit node plus the solutions to one or moresubproblems (as defined by the products of that unit node), then the list of dependencies for the currentsolution is simply the union of those for the subproblem solutions. If, however, the current solution hasstatus NOTECH, then the dependency list is the problem itself.

In the example above, the problem defined by the dangling stream “3A 3B” in Figure 6 may have severalalternative solutions. One is that the distillation unit is used to process the stream, leading to two sub-problems, defined by the streams “3A” and “3B.” Each of these subproblems can not be solved (using theavailable technologies) and hence each is given a status value of NOTECH. For each of these subproblems,we also define the dependency list to be the problem itself. Backtracking to the “3A 3B” problem, onealternative (partial) solution is defined: distillation in combination with two partially solved subproblems.The status of this solution is )*$ NOTECH and its dependency list consists of two subproblems, defined bythe streams “3A” and “3B”. A second alternative solution for the “3A 3B” problem is to consider the casewhere the stream is not processed by any unit model. In this case, the solution is given status NOTECH

and the dependency list consists of the “3A 3B” problem. Assuming that the status value associated withNOTECH in the hierarchy is positive, then this latter solution is “better” and is inserted in the list of N-best


7

solutions ahead of the other alternative. It is this solution that is indicated in Figure 6. If we were to look atfurther solutions to the original problem, we would find that an alternative solution structure which is basedon the partial solution in which the stream “3A 3B” is separated is present as well, as shown in Figure 7. Fig 7

The list of dependencies is percolated upwards in the search procedure. At the end, for any partial (i.e.non-feasible) solution, in the list of N-best solutions, we have a list of dependencies. For the examplepartial solution in Figure 6, the dependency list is the subproblem identified by the stream “3A 3B.” Evenwithout any automatic procedure for handling these dependencies, the generation of dependencies providessome insight into the problem. The use of a cost table for dynamic programming has the added benefit thatthe user can browse the list of subproblems attempted during the search procedure. The subproblems havepartial or complete solutions available along with the status and dependency information described above.We have developed a simple graphical tool which can be used for easily browsing this table.22

3.3 Recycle Streams

The dependency information described above can help an engineer during the initial stages of design, i-dentifying interesting or problematic aspects of the design problem. This may lead to greater explorationof the alternatives available to the engineer. However, this information may also be useful in an automatedenvironment. With the dependency information, it is possible to tailor the search procedure to the genera-tion of more complex solutions. The basic principle is to re-do problems which have not been successfullysolved, transforming the problems using the dependency information. With proper transformations, it ispossible to automatically generate processes with recycle streams.

The key is to identify subproblems which should be attempted again with new conditions. In attemptingto design flowsheets with recycle streams, we use a simple heuristic: if a solution (out of the N-best list)for a subproblem is infeasible and has at least one unit node which performs some type of conversion (asopposed to pure separation: one which changes the composition when comparing the union of the feedswith the union of the products), then this solution can be used as a basis for the automatic recycle streamgeneration method. In the example above, this would occur whenever the reactor was the first unit in thepartial solution to a subproblem and anywhere above that (in terms of graph traversal) when backtrackingin the search procedure.

If the condition is met, we enter an iterative procedure. In this procedure, a new subproblem is defined.The feed associated with the current subproblem is qualified, adding a pair of qualifiers for each depen-dency. The qualifiers request that the solution to this new problem both create the stream identified bythe dependency and that the solution may make use of such a stream, as an extra feed, in any one loca-tion in the flowsheet. The use of qualifiers in a dynamic programming context is described by Fraga.8 Ifthis new subproblem is successful, the solution is inserted into the list of N-best solutions for the currentproblem. If unsuccessful, we iterate, creating a new subproblem using newly identified dependencies. Theiteration procedure continues until a new subproblem is successfully solved or until a predefined numberof iterations is exceeded (the maximum number of iterations to perform may be specified by the user).

The overall procedure is similar to a sequential modular approach for steady state simulation with thedependencies as tear streams.6 Mathematically, it is a form of fixed point iteration (repeated substitution)and, as such, is not guaranteed to converge in general, although the dependencies provide good initialguesses for the tear streams. Regardless, the procedure works well for a large variety of problems andhence is a useful addition to the synthesis method. It should be noted that the philosophy behind thesynthesis approach is that we attempt to generate good solutions easily and efficiently, encouraging theuser to experiment with the synthesis tool. Solutions generated by the tool are expected to be furtherrefined using more rigorous continuous optimization (cf. eg. Stair & Fraga26), modelling, and simulationtools.

As described above, the procedure will always identify recycle structures in which the recycle stream isfed back to a reactor or similar unit. This need not always be the best solution however. This is nota problem because the iterative procedure is attempted for any subproblem which has a solution which


8

matches the criteria of non-feasibility and conversion properties. If N, in the sense of N-best, is larger than1, and because we only store at most one feasible solution in that list, there will always be at least onenon-feasible solution available to iterate on. This ensures that recycle streams will be sent to where theobjective function drives them.

If we now attempt the motivating example, given above, using the automatic recycle mode, the followinghappens:

� The search procedure eventually backtracks to the “10A 10B" node preceding the reactor unit (inFigure 6). The best solution to this subproblem is not feasible and has a dependency list consistingof the subproblem with stream “3A 3B” (the unconsumed reactants, assuming a conversion rate of70% in the reactor).� The same problem is attempted but with two extra qualifiers: one that specifies that the stream “3A3B” can be used as an extra feed anywhere in the solution to this problem and one that requires theproduction of that same stream.� The solution to this new subproblem is found, but it is also infeasible. However, the dependency listnow has the subproblem with associated stream “4A 4B” (again, the unconsumed reactants: 30% of(10 + 3) of each of the components, rounded to the nearest integer).� The problem is attempted yet again but with new qualifiers. This time, a feasible solution is foundwith the recycle stream identified as “4A 4B”.� The search procedure now backtracks further, to the problem associated with stream “10A 10B10D”. For this problem, we now have one feasible solution (based on the automatic recycle structureidentified in the previous steps) and at least one non-feasible solution (the one shown in Figure 6).The iterative procedure is again attempted, based on the non-feasible solution. This leads to the useof the same qualifiers as identified before and allows for the possibility of having the recycle streamleading back to this node instead of just before the reactor. The use of the same qualifiers, combinedwith the dynamic programming aspects of the underlying search method, leads to an efficient methodas much of the search has already been handled.

The final process flowsheet for the motivating example is shown in Figure 8. Fig 8

3.4 Multiple iteration variables

In the discussion above, we have described how it is possible to iterate on the dependencies of the sub-problem we wish to solve. However, the method described only works for problems in which multipledependencies all converge at the same rate. The example presented exhibits such behaviour, trivially sobecause there is only one dependency. If, on the other hand, there are different recycle loops that need tobe identified, and each of these converges at a different rate, the method will fail to find a feasible solution.In iterating, only the dependencies identified in the latest solution are used in the next iteration. However,if one of the dependencies from the previous solution has been correctly converged, it will cease to be adependency and will not be used as a recycle qualifier in the next iteration. This leads to cycling: thesolution to the new subproblem will have the same dependency reappear and any left-over dependencieswill not converge.

This problem is overcome by iterating with not only new dependencies found in the solution to the currentiteration but also including any dependencies that disappear (or disappeared previously) due to conver-gence. Figure 9 shows the final algorithm for implementing automatic recycle stream identification using Fig 9iterative dynamic programming (IDP). The call to the IDP procedure would be inserted at the very end ofthe Solve procedure shown in Figure 1, applying the IDP procedure to each of the N-best solutions, partialor complete, found for the current subproblem.


9

4 Case Studies

To show the effectiveness of the new automatic recycle structure generation algorithm, we consider twoproblems: a conceptual level synthesis problem with two reactions and separation and the problem ofsynthesizing Hydrogen Fluoride. Both examples have multiple recycle loops and the successful generationof these loops should be a good test of the new algorithm.

4.1 Example IV: Conceptual level reaction/separation problem

This problem was used by Luyben and Luyben27 as a complex example for the study of flexibility andcontrollability analysis. We used it8 to test the then new recycle stream capabilities, introduced throughthe use of qualifiers. The new techniques described in this paper should enable us to generate the solutionto this problem with less effort. In particular, the user should not have to a priori decide on the recyclestructure.

To summarize, the problem consists of two reactions:

+ �-,/.102�4335�467.98:�-,

where A and E are raw feeds and C and F are the desired products. This is a symmetric problem except forthe relative volatilities of the components. One of the products of the first reaction is needed as a reactantfor the second reaction and vice versa.

This problem is first solved by allowing the use of one instance of each reactor without automaticallygenerating recycle streams. The solution generated is shown in Figure 10. The structure shown is not Fig 10surprising and identifies two product streams (“7C” and “6F”) and two other streams (“3A 3B” and “6B1D 1E”) which could not be processed. Running this problem again with automatic generation of recycleloops yields the process shown in Figure 11. The convergence of the dependencies for this problem is Fig 11shown in Table 1. Again, the structure chosen is not surprising and likely corresponds to what an engineer Tab 1would have considered next.

4.2 Example V: Production of Hydrogen Fluoride

We now present an example applying the techniques described above to a more detailed, less conceptual,problem. In particular, we look at the production of Hydrogen Fluoride ( ; 8 ). A detailed account of theprocess of using the synthesis tool for this problem, showing the steps taken in an exploratory mode in-cluding the effect and targetted use of discretization, is given by Laing and Fraga.22 This problem requiresthe introduction of several new unit models, described briefly below. The feed to the process is assumed tobe solid fluorspar ( 0=<>8�? with trace amounts of 0=<>0 @BA , CED @F? , and ; ?�@ ). The units are

an acid blender which adds ; ? C @FG to its feed using a combination of concentrated acid and oleum (98%; ? C @FG and 2% ; ? C ? @FH respectively). The total amount of acid is set to meet a specified ratio ofacid to fluorspar and the proportion of oleum is set to eliminate any water from the product,

a kiln reactor performing 3 parallel reactions with two outputs: a solid product consisting of 0=< C @ G andunreacted 0=<�8 ? and the reactor offgas including HF and other volatiles, and

an HF absorber which recovers the HF from a gas stream using cold sulphuric acid.


10

The models for these units and the corresponding cost correlations used are described by Laing andFraga.22 Although it is known that the components considered in this case study do exhibit non-idealbehaviour, for this study only ideal physical property correlations were used.

Using the method described in this paper to solve this problem results in the flowsheet shown in Figure 12. Fig 12The output of the process consists of the desired product, two waste streams, one solid and one liquid, andtwo recycled streams, essentially acid and water streams. This process is similar to that identified in theBUSS patent and the whole exploratory process was completed in five logical steps.

5 Conclusions

Process synthesis can be a valuable tool when used in the early stages of design. It enables an engineerto effectively prune a possibly large set of alternative structures, resulting in a small number of goodalternatives. However, it is sometimes difficult at the early stages to identify all the information neededto pose the problem for the synthesis tool in order to generate complete feasible structures. This paperhas introduced a novel technique, integrated into a dynamic programming based graph search procedure,which allows the synthesis procedure to generate partial solutions. These partial solutions are selectedfrom the solution space based on a combination of heuristics, the status hierarchy, and objective functionvalues, all of which are under user control. Partial solutions enable the engineer to identify the need fornew technologies or to specify modified problem formulations, encouraging the use of a synthesis tooliteratively as an exploration device early in the design process.

Furthermore, the generation of partial solutions, combined with an iterative dynamic programming ap-proach, provides the capability of automatically identifying and optimizing recycle loops. This leads to thegeneration of more complex structures without making the use of the tool an overly complex task. A prioriknowledge of the recycle structure of the process is no longer needed and thus any unconscious decisionsare avoided early on, leading to a more unbiased search of the solution space. Novel processes are thereforemore likely to be generated, enhancing the chances of generating profitable solutions.

Having access to information describing the reasons for success or failure of a synthesis run could beused as part of a design support system, such as the KBDS system,28,29 to provide targetted aid. Adesign support system could automatically browse unsolved problems and present the user with appropriatesuggestions or hints to enable further analysis.

Acknowledgements

The author gratefully acknowledges the support of the United Kingdom Engineering and Physical SciencesResearch Council (EPSRC) and E I du Pont de Nemours and Company. The author also wishes to thankDrs R Lakshmanan and D M Laing for many useful and thought provoking discussions.

References

1. Seader, J. D. & Westerberg, A. W., 1977, A combined heuristic and evolutionary strategy for synthe-sis of simple separation sequences, AIChE J., 23(6), 951-954.

2. Stephanopoulos, G. & Westerberg, A. W., 1976, Studies in process synthesis - II Evolutionary syn-thesis of optimal process flowsheets, Chem Eng Sci, 31, 195-204.

3. Smith, R. & Linnhoff, B., 1988, The design of separators in the context of overall processes, ChemEng Res Des, 66, 195-228.

4. Mizsey, P. & Fonyo, Z., 1990, Toward a more realistic overall process synthesis - the combinedapproach, Computers chem. Engng, 14(11), 1213-1236.


11

5. Omtveit, T., Wahl, P. E., & Lien, K. M., 1992, Decomposed algorithmic synthesis of reactor-separation-recycle systems, Computers chem. Engng, 18(11/12), 1115-1124.

6. Douglas, J. M., 1988, Conceptual Design of Chemical Processes, McGraw-Hill Book Company(New York), 377ff.

7. Douglas, J. M. & Stephanopoulos, G., 1995, Hierarchical approaches in conceptual process design:Framework and computer-aided implementation, in Foundations of Computer-Aided Process Design,AIChE Symposium Series, 91, 183-197.

8. Fraga, E. S., 1996, The automated synthesis of complex reaction/separation processes using dynamicprogramming, Trans I Chem E, 74(A2), 249-260.

9. Friedler, F., Varga, J. B., Fehér, E., & Fan, L. T., 1996, Combinatorially accelerated branch-and-bound method for solving the MIP model of process network synthesis, in State of the Art in GlobalOptimization: Computational Methods & Applications, C A Floudas & P M Pardalos, Editors, K-luwer Academic Publishers, Dordrecht, 609-626.

10. Grossmann, I. E. & Kravanja, Z., 1995, Mixed-integer nonlinear programming techniques for processsystems engineering, Computers chem. Engng, 19(Suppl), S189-S204.

11. Smith, E. M. B. & Pantelides, C. C., 1995, Design of reaction/separation networks using detailedmodels, Computers chem. Engng, 19(Suppl.), S83-S88.

12. Kravanja, Z. & Grossmann, I. E., 1994, New developments and capabilities in PROSYN - an auto-mated topology and parameter process synthesizer, Computers chem. Engng, 18(11/12), 1097-1114.

13. Pibouleau, L., Floquet, P., & Domenech, S., 1988, Optimal synthesis of reactor-separator systems bynonlinear programming model, AIChE J., 34(1), 163-166.

14. Cordero, J. C., Davin, A., Floquet, P., Pibouleau, L., & Domenech, S., 1997, Synthesis of optimal re-actor networks using mathematical programming and simulated annealing, Computers chem. Engng,21(Suppl.), S47-S52.

15. Friedler, F., Tarjan, K., Huang, Y. W., & Fan, L. T., 1993, Graph-theoretic approach to processsynthesis: polynomial algorithm for maximul structure generation, Computers chem. Engng, 17(9),929-942.

16. Fraga, E. S. & McKinnon, K. I. M., 1994, CHiPS: A process synthesis package, Trans I Chem E,72(A3), 389-394.

17. Johns, W. R. & Romero, D., 1979, The automated generation and evaluation of process flowsheets,Computers chem. Engng, 3, 251-260.

18. Fraga, E. S., 1997, FiSH: Fully-integrated Synthesis Hierarchy,http://www.ucl.ac.uk/~ucecesf/FiSH/.

19. Fraga, E. S., 1996, Discrete optimization using string encodings for the synthesis of complete chem-ical processes, in State of the Art in Global Optimization: Computational Methods & Applications,C A Floudas & P M Pardalos, Editors, Kluwer Academic Publishers, Dordrecht, 627-651.

20. Larson, P.-A., 1988, Dynamic Hashing, Comm. ACM, 31, 446-457.

21. Oliver, I., 1993, Programming Classics: Implementing the world’s best algorithms, Prentice Hall,New York, 281ff.

22. Laing, D. M. & Fraga, E. S., 1997, A case study on the synthesis of a Hydrofluoric Acid processusing CHiPS, Computers chem. Engng, 21, Suppl., S53-S58.


12

23. Fraga, E. S. & McKinnon, K. I. M., 1995, A portable code for process synthesis using workstationclusters and distributed memory multicomputers, Computers chem. Engng, 19(6/7), 759-773.

24. Fraga, E. S. & McKinnon, K. I. M., 1994, The use of dynamic programming with parallel computersfor process synthesis, Computers chem. Engng, 18(1), 1-13.

25. Rathore, R. N. S., van Wormer, K. A. & Powers, G. J., 1974, Synthesis Strategies for MulticomponentSeparation Systems with Energy Integration, AIChE J., 20(3), 491-502.

26. Stair, C., & Fraga, E. S., 1995, Optimization of unit operating conditions for heat integrated processesusing genetic algorithms, Proceedings of the 1995 I Chem E Research Event, Institution of ChemicalEngineering, Rugby, 95-97.

27. Luyben, M. L. & Luyben, W. L., Design and control of a complex process involving two reactionsteps, three distillation columns, and two recycle streams, Proceedings of the 1994 Fall AIChE Meet-ing, 1994.

28. Bañares-Alcántara, R., 1995, Design Support Systems for Process Engineering - I. Require-ments and Proposed Solutions for a Design Process Representation, Computers chem. Engng., 19(3),267-277.

29. Bañares-Alcántara, R. & Lababidi, H., 1995, Design Support Systems for Process Engineering - II.KBDS: An Experimental Prototype, Computers chem. Engng., 19(3), 279-301.


13

List of Figures

1 Algorithm describing solution procedure including use of status hierarchy. . . . . . . . . . 14

2 Best complete solution for Rathore et al25 separation sequence synthesis problem. . . . . . 14

3 Best partial solution for the Rathore et al25 separation sequence synthesis problem. . . . . 15

4 Best sequence for 10 component separation problem. . . . . . . . . . . . . . . . . . . . . 16

5 Best partial solution for 10 component separation problem. . . . . . . . . . . . . . . . . . 17

6 Best partial solution to simple reaction/separation process synthesis problem. . . . . . . . 17

7 Second best solution to simple reaction/separation problem. . . . . . . . . . . . . . . . . . 18

8 Best solution for simple reaction/separation problem generated with automatic recyclestructure algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

9 Iterative dynamic programming algorithm for multiple recycle stream generation. . . . . . 18

10 Partial solution to two reaction, separation problem. . . . . . . . . . . . . . . . . . . . . . 19

11 Reaction/Separation problem with automatically identified recycle structure. . . . . . . . . 20

12 Final flowsheet for the HF production process identified using the automated synthesisprocedure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

List of Tables

1 Description of dependencies and previously identified recycle streams for each iteration ofthe iterative dynamic programming algorithm. . . . . . . . . . . . . . . . . . . . . . . . . 15


14

Procedure Solve(Problem p)sol I { J , NOTECH}best list I Jinsert sol in best listfor each unit u do

for each alternative design d possible for u do{0} I u.design(p.feed,d)if design successful then

sol I {u,d,{O},NOUTIL}satisfy heating/cooling requirementsif successful thensol.status I 0

end ifif {O} is empty thensol.status I PRODUCT

elsefor each output o in {O} do

sp I new Problem(o)Solve(sp)sol.status I sol.status + sp.status

end forend ifinsert sol in best list

end ifend for

end forend Procedure

Figure 1: Algorithm describing solution procedure including use of status hierarchy.

A

E D C

B

Figure 2: Best complete solution for Rathore et al25 separation sequence synthesis problem.


15

A

C

B

DE

Figure 3: Best partial solution for the Rathore et al25 separation sequence synthesis problem.

Table 1: Description of dependencies and previously identified recycle streams for each iteration of theiterative dynamic programming algorithm.

Iteration Dependencies Converged Recycle Streams

1 3 A 3 B, 6 B 1 D 1 E2 4 A 4 B, 9 B 1 D 1 E3 10 B 1 D 1 E 4 A 4 B4 4 A 4 B, 10 B 1 D 1 E


16

A B

CD

E F

GH

I

J

Figure 4: Best sequence for 10 component separation problem.


17

A

B

CD

E

FG

H

IJ

Figure 5: Best partial solution for 10 component separation problem.

3A 3B

10D

10A

10B

10D

7C

Figure 6: Best partial solution to simple reaction/separation process synthesis problem.


18

10D

10A

10B

10D

7C

3B3A

Figure 7: Second best solution to simple reaction/separation problem.

M

10D

10A

10B

10D

4A 4B

10C

Figure 8: Best solution for simple reaction/separation problem generated with automatic recycle structurealgorithm.

idp-alg

Figure 9: Iterative dynamic programming algorithm for multiple recycle stream generation.


19

M

M

3A 3B 7C

10B

6B 1D 1E

6F

10A

7E

Figure 10: Partial solution to two reaction, separation problem.


20

M

M

M

10A

4A 4

B

10B

1D

1E

10C

10F

4A 14B 1D 1E

10E

Figure 11: Reaction/Separation problem with automatically identified recycle structure.


21

KLKLKKLKLKKLKLKKLKLKKLKLKKLKLKKLKLKKLKLKKLKLK

MLMLMMLMLMMLMLMMLMLMMLMLMMLMLMMLMLMMLMLMMLMLMH SO

2 4

Reactor D1Fluorspar

M

D2

Vapour effluent

HF

Excess

Makeup

M

HF +

A1Makeup

SolidEffluent

H SO2

H SO2

4

4

H SO2 4

Figure 12: Final flowsheet for the HF production process identified using the automated synthesis proce-dure.


Documents

The Generation and Use of Partial Solutions in Process Synthesis