This repository contains a set of data (domain,problems,plans) used in [Asai2014].

• [Asai2014] Asai, M.; Fukunaga, A: 2014. Fully Automated Cyclic Planning for Large-Scale Manufacturing Domains. In ICAPS 2014. pdf

Cell assembling system is a system in which each worker (robot) assembles a complex product in a relatively small “cell” where the equipments are quickly accessible with minimum motion. Compared to the large automated production line, cell assembling systems suit the demand of assembling relatively small number (~100) of products, particularly experimental or custom-made products, because of the flexibility of the system. The problem arises because the assembling plan changes frequently. To maximize the productivity, the planner have to minimize the total makespan.

Sequential version: STRIPS, with negated preconditions, action costs and hierarchical type structure. Temporal version: Simple temporal STRIPS, i.e., actions with durations, but using only the “conservative” fragment of temporal planning. (:numeric-fluents,:durative-actions)

Products called “bases” are assembled by robot arms in the cells. Each cell consists of an arm, assembling tables and machines for special purpose (e.g. oiling, painting). The objective is to minimize makespan. The temporal version encodes this objective directly. In the sequential version, cost is used as an (approximate) proxy for makespan, but a temporal plan must be produced by post-scheduling the sequential solution plan.

The task is focused on the efficient motion of arms. Job dependencies (e.g. attatching X should be done before painting Y) should be already encoded in the problem, so guessing the dependencies is not the task of planners.

Also, the components to be picked up from trays and attached to bases are free (as in beer) and indistinguishable. When an arm picks up a part from a tray, it seems as if one part exists in two places at the same time i.e. (holding arm part) and also (at part tray). However, this actually means that there is another part in the tray which was supplied immediately.

It contains 5+1 directories. First 5 correspond to instances of mass manufacturing problem. Additionally, a directory ACP/generator contains Common Lisp scripts to output those template problems.

Each of problem directories contains:

domain.pddl

a domain file.

p1.pddl

a template problem.

p1.plan

the best template plan obtained by solving it with Fast Downward(LAMA2011). Plans were obtained easily and FD has searched the entire state space in most cases.

p4.pddl, … p1024.pddl

mass manufacturing problems.

[modelname]-SS-[MS3..]-TOTAL-[N].plan.total

solutions obtained by ACP for each N-products manufacturing problems. This is a sequential plan before the postprocessing (minimum-slack scheduler) – our scheduler does not have a proper formatter that complies the temporal plan output format of VAL-4 (an official PDDL+ plan validator).

The generator contains a function for building a random cell-assembly problem. However, in order to actually run the generator, a bit of work is required, especially if you are not familier with common lisp development environment.

First of all, you have to obtain a conforming implementation of common lisp (such as sbcl). You also have to install quicklisp. After that, place this repo in local-systems directory, git submodule init to obtain the dependent systems and (ql:quickload :pddl.builder.cell-assembly). E-Mail me if you need a further guidance. I hope more and more people are interested in Common Lisp because it nicely fits in writing PDDL files (see how the core part seems exactly like the PDDL files themselves). I think even non-lispers would be interested in the code.

For those who are already familier with Common Lisp: When calling write-models-many, don’t forget giving the same random-state if you want to get the same problem.

It contains the temporal versions of the domains and problems in ACP directory. They are made in order to run temporal planners like CPT4, yahsp and DAE_yahsp on those domains. They are manually and minimally changed from the original ones.

The modification detail mainly consists of:

1. translate :action-costs -> :durative-action
2. stop using :negative-preconditions
3. use TOTAL-TIME rather than TOTAL-COST

Below is an illustration of CELL-ASSEMBLY models. Only the brown tables are connected to the conveyor.