User Documentation for Archimedes 3.x

Introduction

Archimedes accepts a 3D CAD model in ACIS format and performs sophisticated reasoning about the assembly in order to automatically deduce one or more geometrically valid assembly sequences. Through an efficient graphical user interface, the user can constrain the planner in a wide variety of ways to reflect manufacturing realities that can not be automatically derived. A search for an optimal plan can also be performed, though this portion of the software is less mature than other parts of the program in version 3.0. Applications of the software range from simple CAD model checkout and rapid visualization of assembly processes to design-for-assembly, planning of manufacturing systems, and automation of programming of robotic assembly cells.

Examples, technical paper, and the latest version of this document are available at the project's web site.

Note 1: This document is not a comprehensive guide to use of Archimedes, but it should be adequate to lead a wide range of readers to successfully apply Archimedes to their problems. Comments/suggestions are welcome. Please use the "Mail" button in the address at the top of the document.

Note 2: If you print this document rather than reading it online, some of the graphics may get automatically trimmed on the right edge. Typically this will not cause serious loss of information.

Overview

CAD Data Format:

Graphical User Interface:

Technical Overview of Planning Process

A data structure called a "non-directional blocking graph" is used during planning to help determine which parts or subassemblies might be moveable at a given point in the assembly process. (Note that for technical reasons, Archimedes actually plans for the assembly in reverse, beginning with the last operation which results in the whole assembly.) To test the possibility of a part or set of parts being moved, a "sweep test" is done. For speed, this test is implemented as a special viewing function which uses the 3D hardware graphics of the computer's display, through GL calls. Thus, the computer must have appropriate z-buffer display hardware and GL library for Archimedes to be effective. Without this hardware support the planning time typically is impractically long. (Though we may provide alternative software algorithms to the z-buffer requirement in subsequence upgrades to Archimedes.)

Generating the First Assembly Plan

Constraining the Plan

Plan Optimization

Output

Plans can be recorded in video form if the computer host supports direct video out (such as many SGI computers do) Or, RGB frames of each animation step can be produced, or in some cases MPEG movies can be output as needed. In addition, a variety of script outputs can be obtained, to assist in implementing the chosen assembly sequence in a software assisted manufacturing system, or performing more elaborate animations in a production quality graphics program.

Because of all the demands on the computer's graphics abilities, Archimedes is currently only running on Silicon Graphics Inc (SGI) computers running the IRIX operating system. However, it has also run quite effectively on IBM RS/6000 computers using AIX, and the graphics facilities needed by Archimedes appear to be coming rapidly to PCs.

Model Setup

When you perform your own ACIS transformation using some other tool, you will need to somehow provide the .asy file to Archimedes. Typically the easiest way to do this is to simply assure that all the parts in the assembly are modelled in the same reference frame, in which case the form of the .asy becomes trivial. That is, the transformation matrix becomes an identity matrix, and the translation is all zeros. For example, see this .

Note that the sequence numbers that appear after each part or assembly file name are optional.

Note that Archimedes expects models to use millimeters as their standard unit. This is because all the tools in Archimedes' tool library are in millimeters. If your model is in inches (as indicated in the *.asy file) then Archimedes will ask you if you wish to convert to millimeters. You should normally reply yes, unless you are not going to use tools, and have a reason not to use millimeters. If your .asy file does not indicate a scale, Archimedes will assume that millimeters are intended, but a warning note will be posted.

The Archimedes Main Windows

The Archimedes program uses two main windows: one for status and commands, and a second for animation and graphical interaction. These are shown below.

The "main window" (on the left) has seven subwindows, alternately cream color and dark red in background.

1. The first (cream color background) has a series of pull-down menus along the top (labelled File, Model, etc.) When you click on one of these a menu of related options pops up, and you can drag the mouse down to the menu item desired. We will discuss each menu option in separate sections below.
2. The second subwindow (dark red background) is a general status window, which tells the nature of the action which is going on now. (In this screen grab it just says "Archimedes Status".)
3. The third subwindow (cream background) is a scrolling area of detailed status messages that Archimedes is posting for the user's possible interest/use.
4. The fourth subwindow (dark red background) contains four primary action buttons. These are primarily for controlling/stopping the planning process.
5. The fifth subwindow (cream background) is the constraint window. It contains a scrolling area listing all current constraints, and a row of action buttons which precisely duplicate those in the "Constraint" pull down window, for convenience.
6. The sixth subwindow is just a label window is just a separator/label.
7. The seventh and last subwindow is a scrolling list off all current model overrides which have been created with the "Model" pull down menu.

Note that the fourth, or middle, window contains the four primary action buttons.

1. "Go" is the button used to tell Archimedes to attempt the planning process. You will usually click this after each time you add a new constraint or model override, to try to get the plan you want.
2. "Pause" can be used to pause the planning process. When "Pause" is clicked the button changes to "Resume", which you can select to continue.
3. "Abort" will stop the planning process at the next appropriate point. It may take a minute to reach an appropriate stopping point in complicated assemblies. Generally, Archimedes will leave a valid, partial assembly plan existing when it aborts, and you can view the partial plan in the animation window.
4. The "Reset GUI" button is available for the occasional situation that may arise in which an accidental closing of a window or some other situation causes the graphical user interface (the "GUI") to freeze. Usually, clicking this button will return Archimedes to a normal state from which you can continue work. If a freeze occurs which is not due to user accident, please report it to the Archimedes project for debugging.

Process Overview

• Load an ACIS model, with associated .asy file, via the File menu. If appropriate, restore any previously saved constraints, overrides, via the File/Restore function. (Usually all the latest constraints, parameters, etc are automatically loaded, but you have the option to save multiple files of such data and load them piecemeal.)
• Try to generate a first assembly plan by clicking on "Go" in the middle subwindow of the main window. Generally, we expect there to be some problem with the CAD model than will prevent an immediate plan being found. Typically, this is due to part models overlapping in space. When the planner fails, it drops you into "debug" mode, which usually will help you locate the problem.
• Then, you use the Model menu to "override" the difficulty in the model. For example, if a screw has been modelled too large for its hole, than you can use the "Force a Snapfit or similar" option to specify how this screw should be inserted. The fundamental model problem thus does not have to be resolved before you can proceed, though ideally one would at some point correct the model.
• Iterate on the above two steps until Archimedes produces a complete first plan.
• View this plan in the animation window, and determine what action or actions are clearly "wrong". That is, which actions must be done some particular way due to a non-geometric constraint. For example, Archimedes' first plan might suggest that a particular subassembly be used which is clearly problematic.
• Use the Constraint menu to find an appropriate constraint which accurately expresses the actual factory constraint, without over specifying how the process must be done. (So as to leave Archimedes maximum flexibility in later planning.)
• Click on Go again, and replan. Then, view the new plan to see what further constraint might be needed.
• Continue this plan-view-constrain-plan cycle until all relevant constraint have been discovered. At this point you may wish to record the animation, or produce some other output.
• If you are using the optimation feaure in Archimedes, you are now ready to specify your optimization parameters, and initiate a search for an optimal plan.

A Comment about Problem Size

The Archimedes Menus

The File Menu

File/Load

When you click on an assembly name, an outline of the assembly structure will appear in a moment in the right half of the display. This is to help you determine whether this is actually the file you want. To load that assembly, either double click it, or click on "Accept".

Note that there is a button for "Parameters". These parameters are for special situations in which the contact analysis does not work properly and some adjustments in assumptions need to be made. You will probably want to contact the Archimedes support team for instructions if you need to use these parameters.

File/Save

• name.params, which contains all the values of parameters in the Options and Optimization menus, plus such details as the most recent viewing angles in the animation window.
• name.constraints, which contains the complete description of every constraint you have defined through the Constraints menu.
• name.overrides, which contains the complete description of every model override you have defined through the Model menu.
• name.plan, which contains the current assembly sequence plan that is available for view in the animation window.

File/Restore

Note you can also reset the parameters to their initial state if you have gotten things confused. And, there is no such thing as adding "more" plans, so that button is blank.

File/Export

Also, the menu item for SLP files is a type of export function, and will not be available unless you have the /Export facility.

It is worth noting that by default Archimedes generally places the output files in the directory from which the CAD model was loaded.

File/Quit

The Model Menu

For example, suppose your CAD model contains a flexible cable which winds through the assembly in a way much too complicated for Archimedes to handle with simple straight line motions. There are a couple of options to allow Archimedes to proceed in a meaningful way:

1. You can click on "Suppress Collision Checking" and then indicate by clicking on that part in the animation window that Archimedes is not to concern itself with collisions of other parts with that one. Thus, the resulting assembly plan will include the part, but other parts may collide with it as they are inserted into the assembly.
2. You can temporarily remove the part by "Remove Parts by PICK" or another Remove option. Then, after you have selected which part or parts are to be removed, they will disappear from the display and will be ignored during assembly planning. However, you can un-remove them at any time by selecting "Remove Parts by PICK" again and adjusting the set of removed parts to not include that part.

( Note: remember that if you are using a menu such as the Model menu frequently, you may want to use a tear-off menu like the one above, so the menu stays statically on the screen. To do this, just click on the first entry in the pull-down menu, which looks like "------------".)

In subsections below we will discuss each override briefly. Note that the mode of interaction is fairly uniform in all these cases: generally, you will be presented with an opportunity to graphically indicate the part(s) concerned by clicking on them in the animation window. A reminder window will tell you exactly what items you should be indicating, (such as the parts to be temporarily removed), and will list remind you of several optional clicks available. See the graphic below for a typical situation when doing a model adjustment. In almost all cases, you will at least have the ability to:

• select a part by clicking on it (the part will then show as bright green)
• unselect a (bright green) part by clicking on it again
• hide any specific part by clicking on it
• un-hide all parts
• if appropriate, select/unselect/hide or unhide a group of parts by clicking on its name in the SubAssemblies box, then clicking on the desired function (i.e., Hide SubAssembly). (Note: double clicking on the subassembly name is equivalent to single clicking on it then clicking on Select/Unselect.)
• zoom in to a specific portion of the scene by clicking on any point, which then becomes the center of a new, zoomed in view
• zoom out, without changing the center of view
• reset the zooming to normal
• to expand the view window by 10% in each direction. (In some Tcl/Tk versions expanding the window directly by dragging the window corners will create undesirable affects--so this alternate method is supplied. This method is also precisely reversible.)
• to shrink the view window by one increment.

There is one extra window that bears some explanation. Some of the overrides require you to specify a direction of action. When this happens a window like the one at left appears. When this window appears the animation window view is temporarily changed to a special view that is consistent with the terms "left", "right", etc, in this trajectory dialog window. If the direction of action is one of the six primary axial directions, then you can just click on that direction. If not, you will have to give the coordinates of the direction numerically (true, its clumsly...this is an example of the kinds of tradeoffs we have had to make in an effort to not overspend effort on niceties.) You should always note carefully the nature of the direction vector being requested: sometimes it may be an INSERTION vector, and sometimes not.

Model/Suppress contact analysis

Model/Declare more contacts for a part

Model/Add thread to a cylinder

Model/Force a threaded mate

Model/Force a snap fit or similar

Model/Suppress collision checking

Model/Change part color

Each click on a part will result in a new override, which shows immediately in the Overrides table. If you accidentally color a part you didn't mean to color, just delete the corresponding override from the table. (See Delete function below.) The part will return to its original color. (See the idea? the original color is still there, but "overridden".)

Model/Remove parts by PICK

Note that Archimedes attempts to adjust the context as far as possible for removed parts. For example, if you have a constraint listing a part in a cluster (see discussion of constraints), and then you remove that part, then the cluster constraint will continue to be valid. The removed part is just ignored, and the remaining parts continue to be a cluster. In some cases, a constraint will be invalidated or confused by the removal of a part. In these cases the constraint will automatically be SUSPENDED, with a note to the user that this has been done.

Equally, if you edit the set of removed parts and un-remove the part (i.e., unselect it from the set of parts to be removed) than Archimedes will in most cases automatically reactivate a related suspened constraint, with a note that this has been done. (Note: since we don't record whether the suspension was done automatic by Archimedes or done by the user, it is possible that a user-suspended constraint might re reactivated in this manner. This seems like a rare subcase.)

Model/Remove parts by NAME

Model/Delete highlighted override

The Constraint Menu

Constraints are the tools you use to tell Archimedes about non-geometric requirements on the assembly plan. This is a rich and varied subject in the assembly planning literature, and in actual factory situations. The Archimedes project has developed a unified set of constraints which you invoke in a fairly uniform manner to place a significant range of requirements on the assembly process. To be effective in use of constraints you will probably need to understand some of the technical background. Our organization and naming system for constraints is presented in the ICRA'96 paper. A more technical overview than is presented here is given in the ICRA'97 paper.

A brief summary of the available constraints will presented at the end of this document.

This is the constraint manipulation menu. Each function is discussed in following subsections. Note that this menu is duplicated with the five buttons below the constraint table in the main menu. This is for historical reasons, and for easier manipulation of constraints, since you will probably find yourself doing a lot of this.

Constraint/Add a constraint

Note that the list is constraints is longer than shows normally in the window, so you may need to scroll down to get to the constraint you want. The names are from the ICRA'96 paper, with some new constraints which are named in the same spirit.

The only thing you must select in this box before clicking on "OK" is the constraint type. If you do not fill in the name or description Archimedes will fill in a default (but not useful) name, and a blank description. You should choose a name meaningful to you, as the constraint type and this name are how you will recognize the constraint in the constraint list that is built in the main window.

Each time you click on a constraint type a help box will appear at the bottom of the "Define a Constraint" window explaining exactly what that constraint does. However, you may find the descriptions difficult to understand initially. Some experimentation and reading of the ICRA papers should be helpful.

Constraint/Edit highlighted constraint.

To edit a constraint, click on it in the main window, then select this function. You will then fall directly into the same code which let you define the constraint in the first place. Note that you cannot change the constraint type via editing, as the type is fundamental to the definition process. If you wish to change the type you simply need to delete the constraint and start over. Also, if you wish to edit the constraint name, just click on the name to highlight it and then select "Edit". A separate dialog box will let you edit the name.

(Note that currently the optional description field is not actually used for anything. It may be in the future.)

Constraint/Delete highlighted constriant

To delete a constraint, click on its type field, then select this function. You will be asked to verify that you really mean it. Often, you will be better off using a "suspend" (see below).

Constraint/Suspend highlighted constriant

Often you may wish to temporarily remove the effect of constraint, for example when trying to determine what is causing the planning process to fail. If you delete the constraint, you will have to go through the whole definition process again to get it back. This would be an unacceptable burden. So, you may instead just click on the constraint (i.e., its type field) and select "Suspend". The constraint will then have no affect whatever, until such time as you reactivate (i.e., un-suspend) it. This feature is very handy and you will probably use it frequently.

Constraint/Activate highlighted constriant

To un-suspend a constraint, click on it (i.e., its type field) and select "Activate".

The Debug Menu

Debug/Examine the assembly

If you simply want to see the assembly, and maybe part names, use this function. It gives you access to all the usual features of moving, hiding, zooming, etc, that you have available when defining a constraint. However, instead of a click on a part causing the part to be selected, it instead causes the name, color name, and sequence number of the part to be displayed in the status window.

Debug/Debug the assembly

When planning fails for some reason, particularly if the problem is due to some conflict with constraints, the facilities available to you in this menu are very helpful in determining what went wrong.

When Debug/Debug is selected, you will first be asked to select the parts in the assembly that you want to be in the set to be debugged. You will have the option of selecting all the parts with one click. After selecting the parts to be debugged, the menu box below appears.

This same menu box will appear automatically when the planner fails, with the problem part set automatically selected. We say that Archimedes is in "debug mode" when this menu box is on the screen, whether you selected it directly, or fell into it from the planning process.

There are four debugging facilities (plus a "Quit" button):

• Examine the subassembly
  The facility is the same as Debug/Examine, discussed just above, except that typically less than the whole assembly is involved.

• Try all pairs
  In this mode Archimedes exhaustively takes each pair of contacting parts and treats the pair as a subassembly to be disassembled. Of course, normally one would expect any two parts to be disassemblable. The only common cases in which they would not be are:
  1. when the model is incorrect and the two parts are overlapping. In this case you must either correct the model or use a model override to specify to Archimedes how to handle the situation.
  2. when the two parts are physically locked together, such as when a snapfit part is used. Again, you will have to use an override to tell Archimedes what to do here. Currently, Archimedes cannot directly deal with any flexible parts.

• Try to remove a chosen subassembly
  Sometimes it may not be apparent why Archimedes is having a problem disassembling a set of parts. Frequently it is because of an unexpected interaction between user defined constraints. In this mode, you will be asked to select a part or parts to remove (one part typically) and a direction to try to remove it. Archimedes will then attempt that action, and will give details in the status window of the result. Specifically, you will receive data about
  1. any contact blockings that are present (i.e., parts which are immediately blocking each other from contact considerations rather than a more distant collision during the removal).
  2. the status of each constraint concerning this proposed action (i.e., whether each constraint considers it valid).
  3. any collsions that occur when the parts are removed in the specified direction.

• Try a trajectory with all parts This facility is rather similar to "Try to remove a chosen subassembly", except that Archimedes tries to remove each part in a specified direction individually. Here is an example of the type of output you will receive:

  ...
  Part unpin_05...
  Part unpin_05 collides with a3_07.
  Operation not valid: parts collide.
  Part hipin_06...
  Part a3_07...
  Part a3_07 collides with spacer_08.
  Operation not valid: parts collide.
  Part spacer_08...
  Part spacer_08 collides with 1lockring_11.
  Operation not valid: parts collide.
  ...
  

  Note that parts unpin_05, a3_07, and spacer_08 are diagnosed as having collisions, and one part each collides with is listed. (There may be other collisions also...only one is listed.) But part hipin_06 has no such diagnosis, indicating that there were no problems removing it.

• Quit This gets you out of Debug mode and returns you to the main window.

Debug/Check for part overlaps

Debug/Clear cache of previous collision detections

Debug/Set random seed

Debug/Suppress progress messages

Debug/Suppress progress messages

Debug/ ****'s special

Debug/Redraw everything

The Options Menu

Options/Displays/Show Graphics

Options/Displays/Show Bitmaps

Options/Modes/Only Linear

Options/Modes/Only Connected

Options/Modes/Plan Grasping

Disabled options

The Optimization menu

Optimization/Optimization

Optimization/Edit operation costs

1. The cost of an insertion. This cost applies to each part or subassembly insertion. Note that the total number of insertions in a plan is equal to the number of parts in the plan, even if subassemblies are used.
2. The extra cost of using a subassembly. This cost adds to the insertion cost. You may want to set this to zero so use of subassemblies is not penalized.
3. The cost of an inversion. This cost is added any time an explicit reorientation is done.

Guidelines/Hints for Handling Hard Problems

Conversion to ACIS format with PTC2ACIS.

Our experience has been that such failures often happen with tiny parts with some surface pathology. If this is the case, you may want to just delete the part for now. You should consider this to be a last resort, though, because deleting even a tiny part may cause problems for Archimedes. You may need to use Archimedes' "Declare more contacts for a part" override to restore proper connectivity to nearby parts after deleting a problem part.

To delete the part in Pro/E, just load the model into Pro/E, delete the part using the usual menu operations, and then re-save each subassembly which contained the part, at any level of the subassembly hierarchy. Then do the conversion to ACIS again.

Loading a model into Archimedes

jam_nut.sat 2869
        0.0000000000         1.0000000000         0.0000000000 
       -1.0000000000         0.0000000000         0.0000000000 
        0.0000000000         0.0000000000         1.0000000000 
        7.4750000000         0.0000000000         0.0000000000 
fwd_guide.sat 1660
        0.0000000000         0.0000000000         1.0000000000 
        1.0000000000         0.0000000000         0.0000000000 
        0.0000000000         1.0000000000         0.0000000000 
       -0.3750000000         0.0000000000         0.0000000000 
#sml_oring.sat 1665
#        0.0000000000        -1.0000000000         0.0000000000 
#        1.0000000000         0.0000000000         0.0000000000 
#        0.0000000000         0.0000000000         1.0000000000 
#        0.0700000000         0.0000000000         0.0000000000 
fwd_key.sat 1663
        0.0000000000        -0.7071067812        -0.7071067812 
       -1.0000000000         0.0000000000         0.0000000000 
        0.0000000000         0.7071067812        -0.7071067812 
        0.8750000000        -2.2466196652        -2.2466196652 

Preparing to Process a Large Assembly

Temporary Removal of Irrelevant Parts

Please note that you must be careful not to delete any parts which would cause the remaining assembly to be disconnected, or otherwise unworkable. For example, if you are working with a rocket design, and are interested in the guidance system in the nose, you could probably safely "remove" all the fins. You might be able to remove the whole tail section, but be aware of connectedness problems you might be causing thereby. Minor connectedness problems can be corrected by hand by using the "Model/Declare more contacts for a part" override.

Checking the model for part overlap

• The models are somehow locked together in such a way that no straight-line motion will separate them. Typically this is because the parts are overlapping in space. Some traditional CAD modelling practices lead to this situation. For example, modelling screws using their threads' outside diameters, and the corresponding holes with their inside diameters, will cause such overlaps. You will have to use some override (such as a "mate override") to deal with each such case.
• You have defined some constraint that is violated by taking a particular pair of parts apart. If you perform this test before you define any constraints, you will have fewer confusing reports of problems.

Grouping sets into REQ_SUBASSEMBLY's

Grouping sets into REQ_SUBASSEMBLY_WHOLE's

Ungrouping REQ_SUBASSEMBLY_WHOLE's

You should do such ungroupings in small bunches, so you can easily tell where problems occur. You will probably need to add more constraints every time you release more parts for planning, as you will see more "strange" things happen with the newly planned parts.

That's all...

Summary of Available Constraints in Archimedes 3.0

• PRH_STATE:Requires that a given state (i.e., a defined set of parts constituting a stage in the assembly) not appear at any time in the assembly plan.
• PRH_SUBASSY:Disallows any moving subassembly from containing a defined set of parts.
• REQ_CLUSTER:Requires that a defined set of parts be assembled as a cluster: that is, assembled as a sequence among themselves (in no particular order), without interruption by other parts.
• REQ_FASTENER:Requires that a defined fastener part (or cluster of fastening parts) be assembled immediately after all the parts to be fastened have all been placed in the assembly.
• REQ_LINEAR_CLUSTER:Requires that a defined set of parts be assembled as a cluster, and in linear fashion. (That is, with exactly one part added at a time.)
• REQ_LINEAR_PARTS:Requires that a controlled set of parts be assembled linearly (i.e., one at a time) anytime they are forming a liaison with members of a second defined set of parts. The parts are not required to be assembled sequentially. (See REQ_CLUSTER instead if that is what is needed.)
  Note: this definition is more complex than may seem necessary on first thought. However, note that all parts are always assembled linearly when they are first placed in the assembly. Thus, a more careful description is needed.
• REQ_ORDER_FIRST:Require that a part (or cluster of parts) be first in the assembly process.
  Note that this constraint may not work in the normally expected manner if the plan is non-linear. In non-linear plans all this constraint can do is assure that the controlled parts are in the stationary part of the assembly when other parts are added to them. To achieve the results you want you may need to put some or all of the other parts in a REQ-LINEAR-* constraint.
• REQ_ORDER_LAST:Require that a part (or cluster of parts) be last in the assembly process.
• REQ_ORDER_LIAISON:Requires that ALL liaisons among a given (first) set of parts be established before ANY liaisons in a given (second) set of parts are established. No requirement is imposed on the order of liaison establishment within either set. (Though you may, for example, use a REQ_CLUSTER in addition to this constraint to require one of the sets to be assembled as a cluster.) Also, the second set of liaisons is not required to be established immediately after the first set.
  Note: In the case of non-linear plans, the meaning is that the first group of liaisons must be established before the involved parts are joined to any parts which constitute a liaison in the second set.
• REQ_ORDER_PART"Requires that ALL parts in a given set of parts be placed into the assembly before any of the parts in a given second set. No requirement is imposed on the order of assembly within either set. (Though you may, for example, use a REQ_CLUSTER in addition to this constraint to require one of the sets to be assembled as a cluster.) Also, the second set is not required to immediately follow the first set. In other words, this constraint simply imposes an assembly precedence between two set of parts.
  Note: In the case of non-linear plans, the meaning is that the first group must be complete before it is joined to any parts of the second group...but the second group may have been 'previously' assembled -- as a separate subassembly, for example. In particular, in the case of non-linear plans, REQ_ORDER_PART constraints with just one part in the first set have no effect.
• REQ_PART_SPECIAL:Allows the user to determine interactively whether each proposed action with a part (or any of a set of parts) is acceptable.
  Note: the number of responses required by the user can be too high for practical use unless other constraints are added to minimize the number of alternatives involving the controlled set of parts.
• REQ_PATHS_AXIAL:Require that all assembly actions which form liaisons among a chosen set of parts be along specifically chosen axial directions.
• REQ_STACK:Requires that a specified group of parts be assembled in stack-like fashion: that is, one at a time, all in the same specified direction.
• REQ_SUBASSY:equires that a defined set of parts appear as a subassembly at some time in the assembly plan. This could be as either a subassembly which is being inserted, or as the stationery assembly being inserted into, or as the union of the two.
• REQ_SUBASSY_WHOLE:Requires that a defined set of parts be a subassembly. (See REQ_SUBASSY.) In addition, this constraint tells the planner not to bother disassembling these parts any further.
• REQ_SUBSEQUENCE:Requires that a given set of parts be assembled as a cluster, but with a number of sub-cluster constraints obeyed also. You may choose whether the order of subclusters will be obeyed as an ASSEMBLY sequence or a DISASSEMBLY sequence.
  (Alternatively, you may think of this constraint as a sequence of clusters which must be assembled or disassembled in sequence, without interruption by other parts.)
  if each cluster is defined as a single part, then this constraint can be used to request that an exact part assembly or disassembly sequence be followed.
• REQ_SUCCESS_PART:Requires that the plan be considered a success (and 'disassembly' planning terminated ASAP) when a defined group of parts has been removed from the assembly.
  (Note: in Archimedes 3.0, using optimization with this constraint does not act as one would expect. That is, early removal of the part is not achieved. There are technical difficulties in the cost function implementation. This situation is improved in version 3.1.)
• REQ_TOOL:Requires that at least one of a user-defined list of tool applications be valid for a particular assembly operation. You must interactively define each valid operation (one or more). The planner will determine the free parameters such as working angles of a wrench.