Abstract

Cooperative three-dimensional (3D) printing (C3DP)—a representative realization of cooperative manufacturing (CM)—is a novel approach that utilizes multiple mobile 3D printing robots for additive manufacturing (AM). It makes the make-span much shorter compared with traditional 3D printing due to parallel printing. In C3DP, collision-free scheduling is critical to the realization of cooperation and parallel operation among mobile printers. In the extant literature, there is a lack of methods to schedule multi-robot C3DP with limited resources. This study addresses this gap with two methods. The first method, dynamic dependency list algorithm (DDLA), uses a constraint-satisfaction approach to eliminate solutions that could result in collisions between robots and collisions between robots with already-printed materials. The second method, modified genetic algorithm (GA), uses chromosomes to represent chunk assignments and utilizes GA operators, such as the crossover and mutation, to generate diverse print schedules while maintaining the dependencies between chunks. Three case studies, including two large rectangular bars in different scales and a foldable sport utility vehicle (SUV), are used to demonstrate the effectiveness and performance of the two methods. The results show that both methods can effectively generate valid print schedules using a specified number of robots while attempting to minimize the make-span. The results also show that both methods generate a print schedule with equal print time for the first two case studies with homogeneous chunks. In contrast, the modified GA outperforms the DDLA in the third case study, where the chunks are heterogeneous in volume and require different times to print.

1 Introduction

Led by major industrial countries, the initiative of Industry 4.0 [1] is poised to reshape the traditional manufacturing landscape, pointing the future of manufacturing toward data-driven smart factories with digital manufacturing machines and robots to meet the changing demand of customers. Cooperative manufacturing (CM) is an emerging manufacturing paradigm, where a group of smart manufacturing robots can move across the entire 2D factory floor and work together for heterogeneous production of multiple jobs under minimal human intervention. Compared with traditional production line manufacturing, CM offers several advantages in terms of autonomy, scalability, and dynamic reconfigurability. These advantages can enable CM to provide a framework to meet the demand of manufacturing for changing markets, thus providing a new pathway in developing future smart factories.

The cooperative 3D printing (C3DP) system is one manifestation of such a CM system concept that utilizes multiple mobile 3D printing robots to print large-scale objects cooperatively [24]. In C3DP (Fig. 1), a large part is first divided into multiple chunks, which are then assigned to multiple robots to work cooperatively in parallel to fabricate the allocated chunks.

Fig. 1
Demonstration of C3DP: two mobile printers working cooperatively
Fig. 1
Demonstration of C3DP: two mobile printers working cooperatively
Close modal

Though promising, the research and application of C3DP are still in their infancy due to the challenges in integrating multi-robot systems (MRS) and additive manufacturing (AM). Typical challenges include the discretization of the AM process and the scheduling and operational planning for the printing tasks in a dynamically changing environment without collisions. In our prior work, we proposed a multi-stage architecture for the C3DP process. These stages include geometric discretization (e.g., the geometric partition of part into chunks [2]), scheduling (i.e., task assignment and planning [4,5]), path planning (i.e., collision-free moving path planning for mobile robots to transition from one workstation to another [6]), and motion planning (i.e., collision-free infill paths generation for neighboring robots to work together during printing). In addition, we identified the geometric and operational constraints in C3DP and their mathematical representations, including the potential collisions between robots as well as the collisions between robots and the already-printed materials [5]. Based on these concepts, we developed a heuristic-based scheduling approach for C3DP. It is the first working schedule for C3DP. The heuristic approach was developed based on the assumption that the number of available robots is unlimited. In addition, the heuristic approach is limited by its optimality and generalizability. To overcome these limitations, we developed a generative approach to scheduling C3DP that can exhaustively search the design space to generate a variety of print schedules for a specified number of chunks with unlimited robots [4]. Such an exhaustive-search approach becomes intractable with the increase in the number of chunks.

In this study, we present two C3DP scheduling methods that consider the resource constraints (e.g., with a limited number of robots) for C3DP scheduling, which can significantly reduce the search space for valid solutions. This work is a continuation of our prior study [7] and uniquely contributes to the C3DP literature in the following three aspects:

  • Optimization: While the previous study focuses on generating valid scheduling strategies, the current study searches for the best scheduling strategy in the design space using the stochastic approach (i.e., the modified genetic algorithm with collision check method) and a constraint-satisfaction approach (i.e., the directed dependency list algorithm method).

  • Tractability and scalability: The generative framework presented in our previous study exhaustively searches the entire design space, which is not tractable even for a small-scale problem. The current study reduces the size of the design space using two different methods: stochastic and constraint satisficing methods. They are capable of searching the design space of large-scale problems in a relatively short time (as discussed in Sec. 5).

  • Resource utilization: While our previous work allows users to specify the number of robots available for a job, the developed generative framework considers all possible schedules in the design space, even if some do not fully utilize all the available robots. The current study has a resource-constrained protocol to ensure that all the available robots will be fully utilized for printing.

The summary of our previous studies, along with the scope of this study, is presented in Fig. 2. In C3DP, the scheduling contains two dependent operations: (1) the chunk assignment, i.e., the allocation of chunks (subtasks) to the available mobile printers and (2) the robot scheduling, which determines the order of the chunks to be printed (both in parallel as well as in series). The objective of this study is to develop scheduling methods for C3DP by taking constraints in the chunk assignment and print sequencing into consideration with limited resources. Such methods take geometric dependencies between chunks (generated from the chunking operation [4]) as an input. It then assigns the chunks and schedules the robots to reduce the make-span.

Fig. 2
Summary of transition from our prior work to current work
Fig. 2
Summary of transition from our prior work to current work
Close modal

The remainder of the paper is organized as follows. In Sec. 2, existing research on manufacturing process scheduling and planning is reviewed from which and the research gaps are identified. In Sec. 3, the problem is formulated, and two methods, i.e., Dynamic Dependency list Algorithm (DDLA) and Modified Genetic Algorithm with collision check (MGA-CC), are developed for near-optimal C3DP scheduling in Sec. 4. Section 5 presents the performance of the two methods in three different case studies. In Sec. 6, the paper is concluded with future works and closing thoughts.

2 Literature Review

Task scheduling and assignment with multiple robots or machines have been researched extensively, especially in the fields of integrated process planning and scheduling (IPPS), operations research (OR), and MRS, for solving different types of problems (e.g., shape formation, assembly operation, etc.). Based on the research fields and the types of problems, the literature can be categorized into three different groups. The commonalities and differences between these research fields are highlighted in a Venn diagram in Fig. 3.

Fig. 3
Venn diagrams showing the similarities and differences between different research fields and C3DP
Fig. 3
Venn diagrams showing the similarities and differences between different research fields and C3DP
Close modal

2.1 Process Planning and Scheduling for Job Shop Problems.

The job shop problem deals with multi-operation scheduling for multiple stationary machines. This is one of the most common problems in IPPS and OR research. Such problems focus on batching and minimizing the make-span of multiple jobs arriving at different times. For example, Jin et al. presented a modified hybrid honey-bee-mating optimization approach with integrated simulated annealing to minimize the make-span of the production process with multiple jobs and multiple static machines [8]. Similarly, Shao et al. used modified GA to minimize the make-span of a similar production process and to balance the utilization of machines [9]. The use of mathematical modeling is widely used in IPPS as well as OR research. For example, Gong et al. used mathematical modeling to remanufacturing-oriented IPPS problems [10]. Meng et al. used MILP (mixed-integer linear programming) models for energy-aware flexible job shop scheduling problems [11]. A more detailed review of the use of different mathematical models along with meta-heuristic methods used in job shop scheduling problems and its perspective under industry 4.0 is presented by Zhang et al. [12].

A class of problems similar to the job shop problems is multi-robot assembly scheduling, where multiple robotic arms are used for carrying out a predetermined sequence of assembly operations. For example, Tereshchuk et al. proposed an efficient scheduling algorithm for task allocation in assembling aircraft structures using robotic arms. The algorithm relies on the workload balancing of the tasks among the robots as well as ensures collision-free scheduling [13].

2.2 Task Scheduling of Discrete Tasks for Multi-Robot Systems.

Discrete tasks are the tasks that can be solved by taking a discrete number of steps, e.g., pick and place assembly, pattern formations, search and rescue [14], etc. The use of multi-robot systems to address such discrete problems is commonly seen. For example, Padmanabhan Panchu et al. presented a multi-objective optimization for multi-robot task allocation with precedence constraints for nonmanufacturing tasks such as foraging [15]. Similarly, Korsah et al. demonstrated an integrated task allocation and scheduling method for a team of pioneer robots operating in an indoor environment. The integrated system consists of an offline planner for task allocation that takes cross-schedule into consideration and a distributed online plan execution strategy [16,17]. Gerkey and Mataric developed an auction-based task allocation system called MURDOCH, a distributive approach for multi-robot task allocation [18]. The use of the auction-based algorithm for task scheduling has also been used by McIntire et al. for tasks with precedence constraints [19]. A more detailed review of the market-based approaches, along with other decentralized approaches used in task scheduling, is presented by Gini in their recent work [20]. While the aforementioned problems focus solely on solving discrete tasks using multiple robots, other studies add another level of complexity by introducing static obstacles to the working environment. For example, Xu et al. presented a modified Ant Colony Optimization (ACO) algorithm to solve a dynamic task allocation problem for multiple robots by posing it as a multiple traveling salesman problem with static obstacles [21]. In another example, Li et al. proposed a task assignment of MRS based on an improved genetic algorithm, where n robots are used to search a large search area [22]. More recently, the use of a learning algorithm and machine vision is increasingly seen in multi-robot scheduling problems. For example, Wang and Gombolay presented a novel graph attention network-based scheduler that learns features of scheduling problems and generates a solution for multi-robot assembly operations [23]. Li and Yang has provided a more detailed review of the use of machine vision in multi-robot scheduling algorithms [24].

2.3 Scheduling in Parallel Computing.

In parallel computing, multiple processors simultaneously execute a set of computations. Although parallel computing does not have robots moving to accomplish different tasks like in MRS, nor do they have uncertain timing constraints like in job shop problems, parallel computing shares commonality with our problem in the sense that there are limited resources to support a set of subtasks. For example, Kmiecik et al. proposed different search techniques, including random search, Tabu Search, and simulated annealing to solve multi-processors, multi-tasks scheduling problems with logical constraints [25]. Siriluck et al. and Vegda et al. used ACO [26] and a random search technique [27], respectively, in grid computing for distributed heterogeneous systems to minimize tardiness time. Jung et al. proposed a messy genetic algorithm (GA) to handle discrete design variables and multi-objective optimization formulation to exploit parallel computing for the decomposition method (to determine an optimal number of subsystems in a large multidisciplinary method) [28]. Khan provides a detailed review of studies of job scheduling in parallel computing in Ref. [29].

In addition to this, several studies fall under the umbrella of collaborative robotics [3033], where humans work in close proximity with robots to accomplish manufacturing tasks. While such work has some overlapping with C3DP and could be an integral part of smart factories for Industry 4.0 and thus, deserve recognition, the human-robot collaborative robotics require a different set of constraints, safety features, control, and physical interaction. Thus, collaborative robotics is not discussed further.

Although the different studies presented above share certain commonalities with the research on C3DP, they do not fully address the problem in the multi-robot C3DP (see Fig. 3). This is because C3DP requires collaboration between mobile robots during manufacturing, where robots are working in close proximity to one another. Manufacturing processes, unlike assembly operations and discrete tasks, are extremely sensitive to interruptions and collisions. Thus, C3DP requires collaboration while overcoming three different types of constraints encountered in different research fields. First, there are uncertain timing constraints where we do not know when or where the next print task will take place ahead of time. Second, there are spatial constraints, where multiple mobile robots working together need to manufacture a part without colliding with each other or the printed part (geometric constraints). And finally, there are logical constraints, which represent the dependency between the tasks (Operations constraints). None of the studies discussed above takes all three type of constraints into account during manufacturing (though collision avoidance is taken into account in path planning, where the environment is discretized and robots reduced to point mass, the approaches are difficult to adapt for collision avoidance while manufacturing) with the exception of work done by Tereshchuk et al. Although they take all spatial, logical, and timing constraints during manufacturing into account, the robots are not mobile, and their workspace is predetermined. So, collision-free solutions are determined beforehand at once. The C3DP problem, however, has an extra level of complexity because the robots are moving around, and as a result, two types of collision need to be considered: the collision between a robot and a printed part (R2P collision) and the collision between active printing robots (R2R collision). While the literature discussed above includes static constraints in the MRS environment, the R2P collision constraints in C3DP are dynamically changing and dependent on the scheduling itself. In addition, the existing literature does not provide adequate guidance on how to avoid R2R collision during manufacturing.

3 Resource-Constrained Scheduling Problem Formulation

In C3DP, the chunking operation partitions a part in n chunks represented as C = {c1, c2, c3…………cn}. A dependency list D describes the geometric dependencies between the chunks (e.g., one chunk sitting on top of another), where D is the output of the chunking and can be represented as D = {c0:[], c1:[], c2:[c1], c3:[c0, c1], …}. The keys represent the chunks, and the values represent their dependencies. The dependency list provides information about which chunks can be printed first and which chunks must wait until their dependencies are completed. For example, c0 and c1 can be printed first because they have no dependency, whereas c3 cannot be printed until both c0 and c1 are printed. For example, if we look at the three chunks in Fig. 4. The dependency list can be represented as {0:[], 1:[0], 2:[0]}, meaning that chunk 0 must be printed first, followed by chunk 1 and chunk 2. But the dependency list itself is not enough to generate a print schedule, especially in the case where resources are limited. This is because it does not consider spatial constraints. The total number of available printing robots is m, represented as R = {r1, r2, r3… … … …rm}. The individual print time for each chunk is represented as T = {t1, t2, t3… … … …, tn}. Each printing robot can only print one chunk at a time. Once the chunk is completed, the printing robot moves on to the next assigned chunk location. Since the print time of a chunk is much longer than the time it takes for printers to move from one location to another, the travel time is not considered for calculating the total print time.

Fig. 4
A part with 3 chunks. Chunk 0 has to be printed prior to chunk 1 and 2.
Fig. 4
A part with 3 chunks. Chunk 0 has to be printed prior to chunk 1 and 2.
Close modal

The objective function is, therefore, to minimize the print completion time of the chunk that is printed last (cij) and it is subjected to the following constraints:

  1. Definition of cij
    mincij=min(max(sij+tj))
  2. Dependency constraints
    si,jsk,l>0,jl;i,kR;{cj:[cl]}D
  3. R2R collision constraints (no collision between the active printing robots)
    SViSVj=ij;i,jR
  4. R2P collision constraints (no collision between the robot and the already-printed part during travel)
    RiPj=,iR,jC
  5. One chunk, one robot constraint (One chunk can only be printed by a single robot; a chunk must be completed before the printing robot can move to the next chunk for printing)
    iRjCxijk=1
    iRkCxijk=1

Variables definition:

xijk: Binary variable, 1 if robot i prints chunk j before chunk k, 0 otherwise

sij: Start time of chunk j on robot i

Notation definition:

{max (sij + tj)}: Start time of last chunk j printed on robot i plus the print time of chunk j

SVi,t: Swept volume of robot i at time t

Ri,t: 3D space occupied by robot i at time t

Pj: 3D space occupied by the printed chunk j at time t

R: {r1, r2, r3 ………… rm}, set of robots

C: {c1, c2, c3 ………… cn}, set of chunks

T: {t1, t2, t3 …………, tn}, print time of chunks

D:{c0: [], c1: [], c2: c1, c3: [c0, c1],…}, dependency list

4 Methodology

To address the research gaps identified in Sec. 2, new methods that take the following unique characteristics in C3DP are required.

  • The R2R collision between printing robots while they are cooperatively printing assigned chunks.

  • The potential R2P collisions between the printed part and the active robots.

  • The dynamic environment due to the increase of printed volume over time.

In this section, we present two methods, DDLA and modified genetic algorithm with collision check (MGA-CC), to generate collision-free C3DP schedules, aiming to minimize the total print time under limited printing resources. Both methods significantly reduce the solution space by using a geometric dependency list as an input, which eliminates any solutions that violate the geometric dependency relationship between the chunks. In DDLA, the dependency list is used as a starting point to group nondependent chunks (i.e., the chunks that can be printed together without collision) to generate a print sequence. It uses the FIFO (first in, first out) approach for the chunk assignment. By contrast, the MGA-CC randomly generates a population of initial chunk assignments and uses the dependency list in conjunction with the chunk assignments to generate print schedules. Genetic operators are then applied to modify the chunk assignments until a specified criterion is met. Both DDLA and MGA-CC have a collision check incorporated, which checks for the potential R2P and R2R collisions.

4.1 Method 1: Dynamic Dependency List Algorithm.

The flowchart of the Dynamic Dependency List algorithm method is presented in Fig. 5. Once a part is divided into smaller chunks, the chunks are indexed, and a geometric dependency list is created. In addition to the geometric dependency, the spatial constraints (geometrical dimension as well as the location of chunks) should also be considered to ensure that the print schedule is valid. For example, if referring to Fig. 4, even if the geometric dependency is taken into consideration, a collision could still happen if chunks 1 and 2 are printed simultaneously. One way to make sure such a collision does not happen is to check the swept volume of robots printing the said chunks as presented in Eq. (1). Thus, before scheduling these two chunks in the same time slot, potential collisions between the robots, while they are printing (not the collision while they are moving from one print location to another), need to be checked. To address this issue, the DDLA uses the following three steps:

  • Based on the dependency list, a batch sequence is created. A batch sequence is a list of chunks that can potentially be printed together. An example is shown in Fig. 6, where the initial dependency list is presented in Fig. 6(a). Based on this dependency list, a batch sequence is created, as shown in Fig. 6(b). All the chunks that do not have any dependencies are grouped together to create a batch sequence. The total number of available robots is not considered while creating the batch sequence. Once the batch sequence is generated, we need to check for collision between the active robots to ensure that the chunks that are in the same batch can be printed together. To check for such collision, we use a swept volume of robots as outlined in our previous study [3]
    SVi(t)SVj(t)=,i=1,2,3,n;j=1,2,3,n;ji
    (1)
    where SVi(t) is the swept volume of robot i, and SVj(t) is the swept volume of robot j. If the intersection between the swept volumes of the printing robots is anything other than null, as presented in Eq. (1), there is potential for collision between the robots, and the chunks should not be printed at the same time.
  • Once the batch sequence is created, the algorithm checks whether the batched chunks can be printed without violating Eq. (1). Based on the number of printing robots (m) and the total number of chunks in the first batch (b), one of the following two scenarios will take place.

    • If the number of available robots is greater than or equal to the number of chunks in a batch, i.e., bm and SVi(t)SVj(t)=, the chunks are scheduled to be printed together. The chunk assignment takes place based on availability, i.e., the first robot available for printing is assigned to the chunk. For example, in the batch sequence in Fig. 6(b), the first batch contains chunk 0 and chunk 1. Since no collision could happen when printing these chunks, they are added to the print schedule as a first print sequence.

    • If the number of chunks in a batch is greater than the number of available robots, i.e., b > m, Eq. (1) will check which chunks can be printed simultaneously without collisions so that those chunks will be scheduled. A greedy approach is then used to sort chunks based on print time in descending order. Doing so allows grouping larger chunks together. This ensures that each print sequence takes the shortest time to print by reducing idling or waiting. For example, if the first batch in a batch sequence has ten chunks, but only four robots are available for printing, first, a collision check is conducted. After that, if six of them can be printed together, the chunks are sorted based on print time in descending order. The first four chunks are chosen and added to the print schedule as the next print sequence. The remaining two chunks will be added to the rest of the chunks that are not scheduled yet. The two chunks will not be automatically scheduled next because, for each print sequence, we want to maximize parallel printing. On the other hand, if b mod m = 0 (i.e., the remainder of when the number of chunks in a batch is divided by the number of robots is equal to zero), and chunks can be simultaneously printed, then b ÷ m sequences will be added to print schedules (i.e., the number of sequences added to the print schedule is equal to the result of the division of the number of chunks in a batch by the number of robots). For example, if eight chunks (b = 8) could be printed together without collisions, and four (m = 4) robots are available, two print sequences (each print four chunks at a time) will be added to the print schedule.

  • After a print sequence is added to the print schedule, the dependency list is updated by removing all the chunks that have already been added to the schedule. The dependency list is updated because doing so allows the algorithm to generate a print sequence with chunks that have their dependencies already satisfied.

Fig. 5
Flowchart showing the different step of Dynamic Dependency List Algorithm
Fig. 5
Flowchart showing the different step of Dynamic Dependency List Algorithm
Close modal
Fig. 6
A part is divided into nine chunks numbered 0–8: (a) resulting dependency list and (b) batch sequence obtained from dependency list
Fig. 6
A part is divided into nine chunks numbered 0–8: (a) resulting dependency list and (b) batch sequence obtained from dependency list
Close modal

This process is repeated until the full print schedule is created. The advantage of this method is that it is computationally efficient and scalable. Although the number of the print sequence is optimized using this method, the chunk assignment follows first-come-first-out and may result in a suboptimal chunk assignment. This method is especially useful in the situation where each print sequence must be completed prior to starting the next print sequence, i.e., synchronous tasks.

4.2 Method 2: Modified Genetic Algorithm With Collision Check.

The genetic algorithm has widely been used in both IPPS and MRS task allocation because it provides satisfactory performance for combinatorial problems [34]. Each solution in GA is represented in the form of a chromosome, so the first step is to encode the printing schedule in the form of a chromosome. Once encoding is done, the initial population will be generated, and then followed by evaluation, selection, and genetic operator application. The flow of the MGA-CC algorithm is presented in Fig. 7.

Fig. 7
Flowchart showing the different step of MGA-CC
Fig. 7
Flowchart showing the different step of MGA-CC
Close modal

4.2.1 Encoding of Individual Chromosome.

The chromosome representation for the C3DP task assignment is presented in Fig. 8. If a part is divided into n chunks, there are n genes in the chromosome, and the index number of the gene is the chunk number. Each of the genes has a machine number encoded onto it, which corresponds to the robot number assigned to the chunk. For example, the chromosome in Fig. 8 has zero encoded at index zero and two encoded at index one. This means that chunk zero is to be printed by robot zero, and chunk one is to be printed by robot two. Though the chromosome representing chunks assignment is necessary, it is not sufficient to determine the printing order of chunks because it does not include information regarding dependencies between the chunks. Thus, the chromosome is used with the dependency list to determine the printing order of the chunks.

Fig. 8
Chromosome encoding in C3DP
Fig. 8
Chromosome encoding in C3DP
Close modal

4.2.2 Random Generation of the Initial Population.

The first generation of the population is generated randomly for a given number of chunks and the available robots. To generate a random chunk assignment, an empty array with the same size as the number of chunks will be filled with randomly generated robot numbers following a uniform distribution. This random gene generation approach is continued until the size of the population reaches the predetermined threshold for population size.

4.2.3 Evaluation Using a Fitness Function.

The fitness function is used to evaluate the performance of each chromosome. Since it is a minimization problem, the lower the value of the fitness, the better is the chromosome. The total path traveled between the print sequences is not taken into consideration. So, the fitness function solely focuses on the make-span through the assignment of chunks to the available printers. To determine the make-span, two things need to be considered: the dependency between the chunks and the next availability of the assigned robot. Since a chunk cannot start printing until all its dependencies are finished printing, Eq. (2) can be used to determine when a chunk can be printed
Tstart(Ci)=max{T(C1),T(C2),T(C3),.,T(Cn)
(2)
where Tstart(Ci) is the start time for printing chunk i, T(C1) is the completion time for chunk 1, C1 … … … Cn are the dependencies of chunk Ci which are to be printed prior to starting the chunk.
A chunk might have all its dependencies satisfied but still might not be printed because the robot assigned to print that chunk might be in operation. Equation (3) takes both factors into account and calculates the start time of a chunk on the assigned printing robot, where Mj is the next available print time on the machine j, and Tstart,ij is the actual start time for the chunk i on the machine j
Tstart,ij=max(Tstart(Ci),Mj)
(3)
The completion time of chunk i is given by Eq. (4), which is the sum of the start time of chunk i and the print time of that chunk
Tend,ij=Tstart,ij+T(Ci)
(4)
where T(Ci) is the time it takes to print chunk Ci. Since the robots are assumed to be homogenous, there is no difference in the completion time of the same chunk, even if a different robot prints it.

4.2.4 Collision Check.

Following Eq. (1), if there is a collision between the robots, one of the robots can be reassigned to print a different chunk. If no other chunks are available for printing, one of the robots must wait until the other robot finished printing its assigned chunk. The extra waiting time is added to the objective function and works like a penalty value, which reduces the fitness value of the print schedule. So, its likelihood of being selected for the next round of population generation will be decreased. If there is no delay, the time is updated based on the reassignment and updated schedule, as shown in Fig. 7.

4.2.5 Genetic Operation.

Three genetic operators are used in MGA-CC: selection, crossover, and mutation. First, chromosomes are to be selected for reproduction, and genetic operators of mutation and crossover are applied to them to generate the next generation of the population. Elitism is implemented to ensure that the fit individuals are passed on to the next generation of the population. Thus, the top 25% of the elite individuals are passed on to the next generation without the application of genetic operators to them. During every iteration, new chromosomes are added to the population to replace the chromosome with a low fitness value. This is done to avoid getting trapped in local optima.

4.2.5.1 Selection method for individual.

There are different selection methods for reproduction to generate the next generation of the population. Some of the popular selection methods are tournament selection method [35], roulette method [36], rank-based selection method [35], and random selection method [37]. To keep the population diverse and avoid premature convergence, the random selection method is adopted at the beginning of the implementation, and the roulette wheel method is used toward the end of the implementation. In the random selection method, an individual chromosome is randomly chosen from the pool of the entire current population for reproduction. On the other hand, in the roulette wheel method, a fitter individual has a higher probability of selection for reproduction. Once the parents are selected, genetic operations such as crossover and mutation are applied to them.

4.2.5.2 Crossover operation.

Crossover requires two parents and produces two offspring. Two-point crossover is implemented in this study as the preferred choice of crossover. In the two-point crossover, two random points are selected in the chromosome, as shown in Fig. 9(a). The segments between the selected points are swapped between the parents resulting in two children. Such crossovers reassign the chunks to different robots but do not change the order of the chunks.

Fig. 9
(a) Two-point crossover and (b) single-point mutation
Fig. 9
(a) Two-point crossover and (b) single-point mutation
Close modal
4.2.5.3 Mutation operation.

Mutation requires a single parent and result in a single offspring. The mutation operator is implemented as follows: Once a parent is selected, a mutation point is chosen randomly in the parent chromosome. The mutation point then undergoes a reassignment to a different robot for printing. This assignment is done randomly. The process is shown in Fig. 9(b).

5 Performance Evaluation

In order to compare the two proposed methods, we demonstrate the application of the methods in three different cases in the C3DP setting. The cases range from a very simple part resulting in 20 chunks that are to be printed with four robots, as shown in Fig. 11, to a much larger one, where a part results in 200 chunks that are to be printed using ten robots. In addition to this, a third case study presents a more complicated geometry with different chunk sizes and is to be printed using available robots, as shown in Fig. 14. Two out of three case studies presented here (case study I and case study III) were also used to demonstrate the generative framework in our previous studies [4,7]. Although two same case studies are adopted in the current work, it is fundamentally different from our prior because this is the first time we have developed optimization methods for C3DP scheduling with limited resources.

To simplify the problem, we make the following assumptions for all the case studies that are presented in this section.

  1. The chunking process is not part of the scheduling process and is predetermined. The desired part is provided to the chunker [3], which outputs required information for task assignment and scheduling such as chunks dependencies, coordinates of the chunks, etc.

  2. The number of available robots is defined by a user.

  3. The path planning is not considered, and thus, any collision that might occur while the robots are traveling from one print location to another is not considered as well. The robots spend most of the time printing (roughly >95%) compared with traveling. Moreover, the collision-free path planning for multiple robots is a non-deterministic polynomial hard (NP-hard) problem. It may change the entire problem to a multi-level decision-making problem, which is worthy of a separate study in our future work.

In order to evaluate the proposed approaches, the quality of the solution (how good the total print time is compared with one another) and the execution time were used as evaluation metrics. Since the MGA-CC is a stochastic approach, measuring the actual runtime might give a better idea of the scalability of the approach. Therefore, the comparison between the two algorithms is presented in terms of execution time rather than the number of function evaluations or the number of iterations.

5.1 Benchmark Test.

Conventionally, the scheduling of multiple jobs in multiple machines is formulated as a mathematical problem. The problems are then solved using exact methods, which include commercial solvers such as cplex, or some meta-heuristic techniques that might not provide exact results but are computationally less taxing than the exact methods. The exact methods include dynamic programming methods, which try to find the optimal schedule by complete enumeration, or linear programming-based (LP-based) approaches such as MILP that used the branch-and-bound algorithm. While both of these approaches provide the exact solution, they are computationally expensive and do not scale to larger problems. For example, the approaches can easily solve the problem presented in case studies I and III; however, case study II is too large to solve within a reasonable timeframe. But, we can use them as benchmark tests to solve the multi-robot scheduling problem in C3DP for case studies I and III to compare the results of the two approaches presented in the paper with that of exact methods.

Thus, we use the MILP solver, which implements an LP-based branch-and-bound algorithm to solve the problem and compare the results with the ones from the proposed approaches. However, aside from the issue of scalability, another issue plagues the implementation of MILP for C3DP scheduling—the MILP lacks the ability to incorporate the dynamic constraints, where the chunks are printed by the assigned robots in a sequence that is not known beforehand. This makes it difficult to add dynamic collision avoidance constraints. To circumvent this issue, the chunks that would cause robots to collide in printing were identified first, manually, prior to the implementation of MILP. Once identified, constraints were added individually to avoid schedules that result in such collisions. However, case study II is too large to manually add constraints because it contains 200 chunks and ten robots. Thus, no benchmark test is presented for case study II.

5.2 MGA-CC: Parameters.

The performance of evolutionary algorithms such as MGA-CC largely depends on the configuration values for mutation and crossover operations. In addition, the performance also depends on how many chromosomes are generated for the population. Thus, it is important that the parameters are carefully chosen, but since the problem of C3DP is novel, there are no standard values that could be adopted from the literature. Thus, to determine the proper values of the different parameters, a sensitivity analysis was conducted. For the crossover rate, an initial value of 0.10 was chosen and increased by 0.1 for every new data point. Similarly, an initial mutation rate of 0.05 was chosen and was modified by 0.01 for every new data point. Once the initial values and the increment or decrement values were determined, multiple runs of the algorithm were carried out with different combinations of the sampled values. The number of iterations required to obtain a minimum solution was used as the evaluation metric. Figure 10 shows the change in metric (number of iterations required to obtain the solution) in response to the independent parameters’ baseline value (i.e., the crossover and mutation rates). A crossover rate of 0.40 and a mutation rate of 0.05 were used as initial configurations to create the graph. It can be observed that if the mutation rate is halved to 0.025, it has a larger significance (results in a larger change in the used metric) compared with if the mutation rate was doubled to 0.10. On the other hand, the change in the number of iterations required to obtain a minimum solution is not as sensitive to the crossover rate change.

Fig. 10
Simple sensitivity analysis used to determine crossover rate and mutation rate using number of iterations used to obtain final solution as metric
Fig. 10
Simple sensitivity analysis used to determine crossover rate and mutation rate using number of iterations used to obtain final solution as metric
Close modal

For the population size, a general rule of thumb is that a smaller population size provides quicker convergence, albeit a caveat that it might get trapped in the local minima. Since the case studies involve two smaller problems and one medium-scale problem, the population size of 50 was chosen, which provides a good balance between diversity and the computational efficiency of the algorithm. Based on the result of the tests, the population size of 50, the mutation rate of 0.05, and the crossover rate of 0.40 are adopted for all three case studies. The algorithm typically converges after 500 iterations for every case study.

5.2.1 Case Study I: 20 Chunks, Four Printing Robots.

For the first case study, a simple rectangular bar is divided into 20 chunks, with four columns and five rows. Four robots are available for printing in this case. The rectangular bar, with its dimension along with the chunks, is presented in Fig. 11. Since the path planning is not considered, there are possible multiple optimal chunk assignments. In this case, chunk volumes are homogenous, i.e., each chunk takes the same amount of time to be printed. Using a print speed of 16 mm3/s, it takes the printer roughly about 10.42 h to print a chunk. The resulting chunk assignment, as well as the print schedules, are presented in Table 1 along with other pertinent information such as the total make-span and the time it took the methods to achieve the solution. Though both methods generate the same print schedule, the chunk assignment is different. The chunk assignment and the print schedule obtained using DDLA are presented in Fig. 12(a), and the one obtained using MGA-CC in Fig. 12(b). The print schedules are represented using a directed dependency tree (DDT) where the node represents a chunk to be printed, and the edge represents a dependency relationship between the two connecting chunks. It can be observed in both print schedules that only two robots are used for printing the chunks, whereas all four robots are used after the first two print sequences. The dependency list ({0: [], 1: [], 2: [0, 1], 3: [1], 4: [0, 2], 5: [1, 2, 3], 6: [4, 5, 2], 7: [5, 3], 8: [4, 6], 9: [5, 6, 7], 10: [8, 9, 6], 11: [9, 7], 12: [0, 2], 13: [1, 2, 3], 14: [2, 12, 13], 15: [3, 13], 16: [12, 14], 17: [13, 14, 15], 18: [16, 17, 14], 19: [17, 18]}) that was used as input allows only two (chunk 0 and chunk 1) chunks to be printed first because only chunk 0 and chunk 1 have no dependencies that need to be satisfied. Once they are printed, the chunk that has chunk 0 and chunk one as dependencies can be printed next (chunk two and chunk 3).

Fig. 11
Rectangular block showing the chunks line, exploded view of the chunks that combine to make a rectangular block and top view of exploded chunks with chunk number marked
Fig. 11
Rectangular block showing the chunks line, exploded view of the chunks that combine to make a rectangular block and top view of exploded chunks with chunk number marked
Close modal
Fig. 12
(a) DDT of print schedule along with the chunk assignment obtained using DDLA, (b) DDT of print schedule along with the chunk assignment obtained using modified GA, (c) the change of objective function value with the new iteration of population generation in modified GA, and (d) the print schedule along with chunk assignment obtained using MILP
Fig. 12
(a) DDT of print schedule along with the chunk assignment obtained using DDLA, (b) DDT of print schedule along with the chunk assignment obtained using modified GA, (c) the change of objective function value with the new iteration of population generation in modified GA, and (d) the print schedule along with chunk assignment obtained using MILP
Close modal
Table 1

Comparison between the two developed approaches using different metrics (case study I)

DDLAMGA-CC
Chunk assignment{Robot 0: [0, 2, 12, 14, 8, 10], Robot 1: [1, 3, 13, 15, 9, 11], Robot 2: [4, 6, 16, 18], Robot 3: [5, 7, 17, 19]}{Robot 0: [0, 4, 15, 16, 18], Robot 1: [3, 5, 11, 14, 17], Robot 2: [2, 7, 8, 10, 12], Robot 3: [1, 6, 9, 13, 19]}
Print schedule{1: [0, 1], 2: [2, 3], 3: [12, 13, 4, 5], 4: [14, 15, 6, 7], 5:[16, 17, 8, 9], 6:[18, 19, 10, 11]}{1: [0, 1], 2: [2, 3], 3: [12, 13, 4, 5], 4: [14, 15, 6, 7], 5:[16, 17, 8, 9], 6:[18, 19, 10, 11]}
Make-span62.52 h62.52 h
Computation time<0.10 s0.132 s
DDLAMGA-CC
Chunk assignment{Robot 0: [0, 2, 12, 14, 8, 10], Robot 1: [1, 3, 13, 15, 9, 11], Robot 2: [4, 6, 16, 18], Robot 3: [5, 7, 17, 19]}{Robot 0: [0, 4, 15, 16, 18], Robot 1: [3, 5, 11, 14, 17], Robot 2: [2, 7, 8, 10, 12], Robot 3: [1, 6, 9, 13, 19]}
Print schedule{1: [0, 1], 2: [2, 3], 3: [12, 13, 4, 5], 4: [14, 15, 6, 7], 5:[16, 17, 8, 9], 6:[18, 19, 10, 11]}{1: [0, 1], 2: [2, 3], 3: [12, 13, 4, 5], 4: [14, 15, 6, 7], 5:[16, 17, 8, 9], 6:[18, 19, 10, 11]}
Make-span62.52 h62.52 h
Computation time<0.10 s0.132 s

Both methods result in a make-span of 62.52 h. While the DDLA method took 0.1 s to obtain the print schedule and assignment, MGA-CC took about 0.132 s. This is due to the fact that MGA-CC has to run 500 iterations of population generation even though it converged in less than 100 iterations, as presented in Fig. 12(c). Even though the DDLA uses heuristics to assign the chunks to the robots, the homogeneity of the chunk printing time allows all the robots to complete printing their assigned chunk simultaneously. Thus, no robots must wait to start the next print sequence. And that is the reason the make-spans for both methods are the same. If the chunks are nonhomogeneous, the make-span will likely differ, as observed in case study III. Finally, MILP calculated the optimal make-span of 62.52 h as well. Though the schedule generated by MILP is the same as the one generated by DDLA and MGA-CC, as shown in Table 1, the chunk assignment is different. The schedule and the assignment obtained using MILP are presented in Fig. 12(d). MILP took 6.97 s to get the said solution, making it slower than both the DDLA and MGA-CC.

5.2.2 Case Study II: 200 Chunks and Ten Printing Robots.

For the second case study, a part is chosen that has a similar geometry to the first case study, but the size of the part is much larger (500 cm × 80 cm × 1.5 cm), thus resulting in 200 chunks (5 rows and 40 columns). Each chunk takes about the same time to print as in the first case study (10.42 h printed at 16 mm3/s print speed). For this printing task, ten printing robots are available for printing, though ideally, 40 robots would be required for printing the part. Thus, the resources available are one-quarter of what is ideally required for the print job. Since this is a very large print job with 200 chunks, outlining the entire schedule and chunk assignment for 200 chunks takes a larger space. Thus, the print schedule and chunks assignment are not presented, and only the make-span and computation times are provided in Table 2. Both DDLA and MGA-CC calculated the make-span to be 218.82 h, but as observed in the smaller-scale problem in the case study I, the chunk assignment is quite different. Again, this can be attributed to the homogeneity of the chunks where chunks can be printed by the assigned robots in a synchronous manner, where all ten robots can finish printing the previous chunks and start printing new chunks together simultaneously. While DDLA took 0.208 s to compute the make-span, the MGA-CC took more than 6× the time to compute the exact same make-span. But as observed in Fig. 13, the MGA-CC converged to the solution in less than 200 iterations.

Fig. 13
The change of objective function value with the new population generation in modified GA
Fig. 13
The change of objective function value with the new population generation in modified GA
Close modal
Table 2

Comparison between the two developed approaches using different metrics (case study II)

DDLAMGA-CC
Make-span218.82 h218.82 h
Computation time0.208 s1.432 s
DDLAMGA-CC
Make-span218.82 h218.82 h
Computation time0.208 s1.432 s

5.2.3 Case Study III: 24 Chunks and Four Printing Robots.

For the third case study, a part with more complicated geometry is chosen to test the generality of the methods. We use a toy folding sport utility vehicle (SUV) with a dimension of 157.6 cm × 140 cm × 3.6 cm. Since the part is larger compared with the first case study, we use a larger print speed (40 mm3/s using a print nozzle of 1 mm diameter) to reduce the print time for the individual chunk. The part and the resulting 24 chunks are presented in Fig. 14. The part is divided into three columns and eight rows, but it can be observed in Fig. 14(c) that the chunks in each row are very different in terms of size and shape and, thus, will have different printing times. Four robots are available for printing the part. Table 3 presents the chunk assignment and print schedule generated using both DDLA and MGA-CC along with the make-span and time it took each method to compute the solution. In addition, the chunk assignment, along with the print schedule represented using DDT, is presented in Fig. 15. The DDT shows that even though the print sequences or the order in which chunks are printed remains the same for both methods, the assignment is quite different from one another, and the make-span is different for that reason. This is expected as DDLA generates print sequence first based on the dependency list and assigns chunks to robots based on FIFO. It lacks a sophisticated approach required to track overall available times on all robots and assign chunks based on such availability. And though the homogeneity of chunks allowed the method to overcome such necessity in the first two case studies, the heterogeneity of chunks in this case study exposes its weakness. Though a more sophisticated approach of chunks assignment could be added to the method, it will impact the computational efficiency of the method, making it computationally slower. On the other hand, this is where MGA-CC demonstrates its superiority as it can find a near-optimal chunk assignment based on a given dependency list compared to the DDLA method. The make-span for MGA-CC was much shorter (106.04 h) compared with that of DDLA (114.17 h). The graph presented in Fig. 15(c) shows the objective function value change over the new population iteration for MGA-CC. Thus, the MGA-CC was able to obtain a shorter make-span in slightly longer computational time and shows that it is better fitted for the C3DP scheduling problem where chunks have different shapes and sizes, resulting in different print times. Since the scale of the problem is small enough, where manually adding dynamic constraints to avoid a collision is manageable, MILP was used to solve the problem as well. The optimal make-span obtained using MILP was 106.04 h, which is the same as the one obtained using MGA-CC. While it only took MGA-CC 0.326 s, it took MILP over 10 s to obtain the same solution. The schedule and the assignment obtained using MILP are presented in Fig. 15(d).

Fig. 14
(a) Folded 3D model of a printed SUV vehicle, (b) top view of unfolded STL model of a SUV vehicle, and (c) rectangular block showing the chunks line, exploded view of the chunks that combine to make a rectangular block and top view of exploded chunks [7]
Fig. 14
(a) Folded 3D model of a printed SUV vehicle, (b) top view of unfolded STL model of a SUV vehicle, and (c) rectangular block showing the chunks line, exploded view of the chunks that combine to make a rectangular block and top view of exploded chunks [7]
Close modal
Fig. 15
(a) DDT of print schedule along with the chunk assignment obtained using DDLA, (b) DDT of print schedule along with the chunk assignment obtained using modified GA, (c) the change of objective function value with the new iteration of population generation in modified GA, and (d) the print schedule along with chunk assignment obtained using MILP
Fig. 15
(a) DDT of print schedule along with the chunk assignment obtained using DDLA, (b) DDT of print schedule along with the chunk assignment obtained using modified GA, (c) the change of objective function value with the new iteration of population generation in modified GA, and (d) the print schedule along with chunk assignment obtained using MILP
Close modal
Table 3

Comparison between the two developed approaches using different metrics (case study III)

DDLAMGA-CC
Chunk assignment{Robot 0: [0, 2, 13, 5, 8, 16, 19, 11, 21, 23], Robot 1: [1, 3, 14, 15, 17, 9, 20, 22], Robot 2: [4, 6, 10], Robot 3: [12, 7, 18]}{Robot 0: [0, 2, 3, 6, 16, 18, 23], Robot 1: [6, 10, 11, 13, 14, 17], Robot 2: [1,7, 12,19, 20, 21], Robot 3: [4, 5, 8, 9, 15, 22]}
Print schedule{1: [0, 1], 2: [2], 3: [13, 3, 4, 12], 4: [5, 14], 5: [16, 15, 6, 7], 6: [8, 17], 7: [19, 9, 10, 18], 8: [11, 20], 9: [21, 22], 10: [23]}{1: [0, 1], 2: [2], 3: [13, 3, 4, 12], 4: [5, 14], 5: [16, 15, 6, 7], 6: [8, 17], 7: [19, 9, 10, 18], 8: [11, 20], 9: [21, 22], 10: [23]}
Make-span114.17 h106.04 h
Computation time0.15 s0.326 s
DDLAMGA-CC
Chunk assignment{Robot 0: [0, 2, 13, 5, 8, 16, 19, 11, 21, 23], Robot 1: [1, 3, 14, 15, 17, 9, 20, 22], Robot 2: [4, 6, 10], Robot 3: [12, 7, 18]}{Robot 0: [0, 2, 3, 6, 16, 18, 23], Robot 1: [6, 10, 11, 13, 14, 17], Robot 2: [1,7, 12,19, 20, 21], Robot 3: [4, 5, 8, 9, 15, 22]}
Print schedule{1: [0, 1], 2: [2], 3: [13, 3, 4, 12], 4: [5, 14], 5: [16, 15, 6, 7], 6: [8, 17], 7: [19, 9, 10, 18], 8: [11, 20], 9: [21, 22], 10: [23]}{1: [0, 1], 2: [2], 3: [13, 3, 4, 12], 4: [5, 14], 5: [16, 15, 6, 7], 6: [8, 17], 7: [19, 9, 10, 18], 8: [11, 20], 9: [21, 22], 10: [23]}
Make-span114.17 h106.04 h
Computation time0.15 s0.326 s

As mentioned, case II is a scaled-up version of the case I, where case I have 20 chunks, whereas case II has 200 chunks. And between the two case studies, the computation time for MGA-CC increased by 10×. On the other hand, DDLA is a deterministic approach, and between cases I and II, the computation time went up by 2×. Thus, the complexity of DDLA is bounded by O(dnm), where d is the number of discrete bins in the dependency list, n is the number of tasks or chunks, and m is the number of robots.

5.2.4 Comparison With the Heuristic Strategy.

In our previous study [4], we proposed a heuristic-based print strategy and demonstrated it using a rectangular bar that is the same as the one shown in the first case study. The comparison of the heuristic print strategy (Fig. 16(a)) with the one obtained using the two methods shows that they are exactly the same print schedule. However, the chunk assignment that is based on the number of available printing resources plays an important role in determining the actual total print time. For example, in case study II, where the part has a larger number of chunks, but ten robots are available, while 40 robots would be ideal for printing, the heuristic print strategy could still work well; but since the printing resources are limited, only a certain number of chunks can be printed in parallel. Thus, in such cases, the chunk assignment plays an important role in reducing the total print time.

Fig. 16
DDT of print schedule generated using heuristic strategy for (a) case I and (b) case II [7]
Fig. 16
DDT of print schedule generated using heuristic strategy for (a) case I and (b) case II [7]
Close modal

Similarly, the folding SUV used in the third case study was used in our earlier study, for which the print schedule was generated using human heuristics (Fig. 16(b)). The print schedule generated by both methods is the same as the one generated using heuristics, but the total print time is longer for the heuristic print strategy (123.30 h for heuristic versus 106.04 h for MGA-CC). This is because the heuristic approach does not consider the chunk assignment. A proper chunks assignment minimizes waiting time and reduces make-span.

6 Conclusions and Future Work

This paper presents two methods for resource-constrained scheduling of multi-robot cooperative 3D printing, i.e., the DDLA and the modified GA with collision check (MGA-CC). Both methods use the dependency relationship between chunks as input but are different in the searching of design space. To demonstrate and compare the performance of these two methods, three case studies are conducted. For the first two case studies with homogeneous chunks in terms of printing time, both methods generated a print schedule with the same make-span. For the third case study, however, the MGA-CC method resulted in shorter overall print time even though the print schedule was the same for both methods. This can be attributed to the chunk assignment, where MGA-CC reduces the wait time of the robots by tracking their availability and thus, reducing the make-span. The DDLA method is expected to work best for synchronous tasks, where multiple chunks can be started together and completed together (e.g., shape formation). That is why DDLA was able to match the MGA-CC for the first two cases and not do the same for the third case study.

However C3DP, which falls under the umbrella of cooperative manufacturing, can contribute to the further development of Industry 4.0 with fully autonomous robots integrated collision-free path planning and motion planning. The proposed approaches for multi-robot scheduling lack such path planning and motion planning and do not yet demonstrate their interaction with scheduling. This is the limitation of the current study. Thus, to overcome this limitation and to take the next step in creating an autonomous manufacturing factory for Industry 4.0, a study of scalable and efficient algorithm path planning for the multi-robot manufacturing system will be part of our future work.

Acknowledgment

This material is based on upon work supported by National Science Foundation under Award Number 1914249. Any opinions, findings, and conclusions or recommendations expressed in this publication are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.

Conflict of Interest

There are no conflicts of interest.

Data Availability Statement

The datasets generated and supporting the findings of this article are obtainable from the corresponding author upon reasonable request. Data provided by a third party listed in Acknowledgment.

References

1.
Schaefer
,
D.
,
2017
, “
Industry 4.0—A Holistic Perspective
,”
Future Steel Form
,
Warsaw, Poland
,
June 14–15
.
2.
Poudel
,
L.
,
Sha
,
Z.
, and
Zhou
,
W.
,
2018
, “
Mechanical Strength of Chunk-Based Printed Parts for Cooperative 3D Printing
,”
Procedia Manufacturing
,
26
, pp.
962
972
. https://doi.org/10.1016/j.promfg.2018.07.123
3.
McPherson
,
J.
, and
Zhou
,
W.
,
2018
, “
A Chunk-Based Slicer for Cooperative 3D Printing
,”
Rapid Protyp. J.
,
24
(
9
), pp.
1436
1446
. 10.1108/RPJ-07-2017-0150
4.
Poudel
,
L.
,
Sha
,
Z.
, and
Zhou
,
W.
,
2019
, “
Computational Design of Scheduling Strategies for Multi-Robot Cooperative 3D Printing
,”
Proceedings of the ASME 2019 International Design Engineering Technical Conferences and Computers and Information in Engineering Conference. Volume 1: 39th Computers and Information in Engineering Conference
, pp.
V001T02A014-01
V001T02A014-09
. https://doi.org/10.1115/DETC2019-97640
5.
Poudel
,
L.
,
Bair
,
C.
,
McPherson
,
J.
,
Sha
,
Z.
, and
Zhou
,
W.
,
2019
, “
A Heuristic Based Scaling Strategy For Cooperative 3D Printing
,”
ASME J. Comput. Inf. Sci. Eng.
,
20
(
4
), p.
041002
. https://doi.org/10.1115/1.4045143
6.
Elagandula
,
S.
,
Poudel
,
L.
,
Sha
,
Z.
, and
Zhou
,
W.
,
2020
, “
Multi-Robot Path Planning for Cooperative 3D Printing
,”
Proceedings of the ASME 2020 15th International Manufacturing Science and Engineering Conference. Volume 1: Additive Manufacturing; Advanced Materials Manufacturing; Biomanufacturing; Life Cycle Engineering; Manufacturing Equipment and Automation
, pp.
V001T01A034-1
V001T01A034-10
. https://doi.org/10.1115/MSEC2020-8390
7.
Poudel
,
L.
,
Zhou
,
W.
, and
Sha
,
Z.
,
2020
, “
A Generative Approach for Scheduling Multi-Robot Cooperative 3D Printing
,”
ASME J. Comput. Inf. Sci. Eng.
,
20
(
6
), p.
061011
. https://doi.org/10.1115/1.4047261
8.
Jin
,
L.
,
Zhang
,
C.
, and
Shao
,
X.
,
2015
, “
An Effective Hybrid Honey Bee Mating Optimization Algorithm for Integrated Process Planning and Scheduling Problems
,”
Int. J. Adv. Manuf. Technol.
,
80
(
5
), pp.
1253
1264
. 10.1007/s00170-015-7069-3
9.
Shao
,
X.
,
Li
,
X.
,
Gao
,
L.
, and
Zhang
,
C.
,
2009
, “
Integration of Process Planning and Scheduling – A Modified Genetic Algorithm-Based Approach
,”
Comp. Oper. Res.
,
36
(
6
), pp.
2082
2096
. 10.1016/j.cor.2008.07.006
10.
Gong
,
G.
,
Deng
,
Q.
,
Chiong
,
R.
,
Gong
,
X.
,
Huang
,
H.
, and
Han
,
W.
,
2020
, “
Remanufacturing-Oriented Process Planning and Scheduling: Mathematical Modelling and Evolutionary Optimisation
,”
Int. J. Prod. Res.
,
58
(
12
), pp.
3781
3799
. 10.1080/00207543.2019.1634848
11.
Meng
,
L.
,
Zhang
,
C.
,
Shao
,
X.
, and
Ren
,
Y.
,
2019
, “
MILP Models for Energy-Aware Flexible Job Shop Scheduling Problem
,”
J. Clean. Prod.
,
210
, pp.
710
723
. 10.1016/j.jclepro.2018.11.021
12.
Zhang
,
J.
,
Ding
,
G.
,
Zou
,
Y.
,
Qin
,
S.
, and
Fu
,
J.
,
2019
, “
Review of Job Shop Scheduling Research and Its New Perspectives Under Industry 4.0
,”
J. Intell. Manuf.
,
30
(
4
), pp.
1809
1830
. 10.1007/s10845-017-1350-2
13.
Tereshchuk
,
V.
,
Stewart
,
J.
,
Bykov
,
N.
,
Pedigo
,
S.
,
Devasia
,
S.
, and
Banerjee
,
A. G.
,
2019
, “
An Efficient Scheduling Algorithm for Multi-Robot Task Allocation in Assembling Aircraft Structures
,”
IEEE Robot. Aut. Lett.
,
4
(
4
), pp.
3844
3851
. 10.1109/LRA.2019.2929983
14.
Moosavian
,
S. A. A.
,
Kalantari
,
A.
,
Semsarilar
,
H.
,
Aboosaeedan
,
E.
, and
Mihankhah
,
E.
,
2009
, “
ResQuake: A Tele-Operative Rescue Robot
,”
ASME J. Mech. Des.
,
131
(
8
), p.
081005
. https://doi.org/10.1115/1.3179117
15.
Padmanabhan Panchu
,
K.
,
Rajmohair
,
M.
,
Sundar
,
R.
, and
Baskarair
,
R.
,
2018
, “
Multi-Objective Optimisation of Multi-Robot Task Allocation with Precedence Constraints
,”
Def. Sci. J.
,
68
(
2
), pp.
175
182
. 10.14429/dsj.68.11187
16.
Korsah
,
G. A.
,
Kannan
,
B.
,
Browning
,
B.
,
Stentz
,
A.
, and
Dias
,
M. B.
,
2012
, “
xBots: An Approach to Generating and Executing Optimal Multi-Robot Plans with Cross-Schedule Dependencies
,”
2012 IEEE International Conference on Robotics and Automation
,
Saint Paul, MN
,
May 14–19
.
17.
Booth
,
K. E. C.
,
2016
, “
Optimization Approaches to Multi-Robot Planning and Scheduling
,”
The 26th International Conference on Automated Planning and Scheduling
,
London, UK
,
June 12–17
.
18.
Gerkey
,
B. P.
, and
Mataric
,
M. J.
,
2002
, “
Sold!: Auction Methods for Multirobot Coordination
,”
IEEE Trans. Robot. Aut.
,
18
(
5
), pp.
758
768
. 10.1109/TRA.2002.803462
19.
McIntire
,
M.
,
Nunes
,
E.
, and
Gini
,
M.
,
2016
, “
Iterated Multi-Robot Auctions for Precedence-Constrained Task Scheduling
,”
Proceedings of the 2016 International Conference on Autonomous Agents & Multiagent Systems, AAMAS'16
, pp.
1078
1086
. DOI: 10.5555/2936924.2937082
20.
Gini
,
M.
,
2017
, “
Multi-robot Allocation of Tasks with Temporal and Ordering Constraints
,”
Proc. AAAI Conf. Art. Intell.
,
31
(
1
). https://ojs.aaai.org/index.php/AAAI/article/view/11145
21.
Xu
,
Z.
,
Xia
,
F.
, and
Zhang
,
X.
,
2009
, “
Multi-robot Dynamic Task Allocation Using Modified Ant Colony System
,”
Artificial Intelligence and Computational Intelligence. AICI 2009. Lecture Notes in Computer Science
,
5855
, pp.
288
297
. https://doi.org/10.1007/978-3-642-05253-8_32
22.
Li
,
S.
,
Xu
,
X.
, and
Zuo
,
L.
,
2015
, “
Task Assignment of Multi-Robot Systems Based on Improved Genetic Algorithms
,”
2015 IEEE International Conference on Mechatronics and Automation (ICMA)
,
Beijing, China
,
Aug. 2–5
.
23.
Wang
,
Z.
, and
Gombolay
,
M.
,
2020
, “
Learning Scheduling Policies for Multi-Robot Coordination With Graph Attention Networks
,”
IEEE Rob. Aut. Lett.
,
5
(
3
), pp.
4509
4516
. 10.1109/LRA.2020.3002198
24.
Li
,
J.
, and
Yang
,
F.
,
2018
, “
Research on Multi-Robot Scheduling Algorithms Based on Machine Vision
,”
EURASIP J. Image Video Process
,
2018
(
1
), pp.
1
11
. doi:10.1186/s13640-018-0355-x
25.
Kmiecik
,
W.
,
Wojcikowski
,
M.
,
Koszalka
,
L.
, and
Kasprzak
,
A.
,
2010
, “
Task Allocation in Mesh Connected Processors With Local Search Meta-Heuristic Algorithms
,”
Asian Conference on Intelligent Information and Database Systems
,
Hue City, Vietnam
,
Mar. 24–26
.
26.
Lorpunmanee
,
S.
,
Sap
,
M. N.
,
Abdullah
,
A. H.
, and
Chompoo-inwai
,
C.
,
2007
, “
An Ant Colony Optimization for Dynamic Job Scheduling in Grid Environment
,”
Int. J. Comp. Inf. Sci. Eng.
,
1
(
5
), pp.
1343
1350
.
27.
Vegda
,
D. C.
, and
Prajapati
,
H. B.
,
2014
, “
Scheduling of Dependent Tasks Application Using Random Search Technique
,”
Souvenir 2014 IEEE International Advance Computing Conference (IACC)
,
Gurgaon, India
,
Feb. 21–22
.
28.
Jung
,
S.
,
Park
,
G.-B.
, and
Choi
,
D.-H.
,
2013
, “
A Decomposition Method for Exploiting Parallel Computing Including the Determination of an Optimal Number of Subsystems
,”
ASME J. Mech. Des.
,
135
(
4
), p.
041005
. https://doi.org/10.1115/1.4023554
29.
Khan
,
I. R.
,
2017
, “
The Study of job Scheduling in Parallel Computing
,”
Global Sci-Tech-Indian J.
,
9
(
3
), pp.
177
184
. 10.5958/2455-7110.2017.00022.2
30.
Vicentini
,
F.
,
2020
, “
Collaborative Robotics: A Survey
,”
ASME J. Mech. Des.
,
143
(
4
), p.
040802
. https://doi.org/10.1115/1.4046238
31.
She
,
Y.
,
Song
,
S.
,
Su
,
H.-J.
, and
Wang
,
J.
,
2020
, “
A Comparative Study on the Effect of Mechanical Compliance for a Safe Physical Human–Robot Interaction
,”
ASME J. Mech. Des.
,
142
(
6
), p.
063305
. https://doi.org/10.1115/1.4046068
32.
Liao
,
T.
, and
MacDonald
,
E. F.
,
2020
, “
Manipulating Users’ Trust of Autonomous Products With Affective Priming
,”
ASME J. Mech. Des.
,
143
(
5
), p.
051402
. https://doi.org/10.1115/1.4048640
33.
(Roger) Jiao
,
J.
,
Zhou
,
F.
,
Gebraeel
,
N. Z.
, and
Duffy
,
V.
,
2020
, “
Towards Augmenting Cyber-Physical-Human Collaborative Cognition for Human-Automation Interaction in Complex Manufacturing and Operational Environments
,”
Int. J. Prod. Res.
,
58
(
16
), pp.
5089
5111
. DOI:10.1080/00207543.2020.1722324
34.
Schirru
,
R.
,
Pereira
,
C. M. D. N. A.
,
Chapot
,
J. L. C.
, and
Silva
,
F. C.
,
1997
, “
A Genetic Algorithm Solution for Combinatorial Problems – The Nuclear Core Reload Example
,”
Proceedings of the 11 ENFIR: Meeting on Reactor Physics and Thermal Hydraulics
,
28
(
24
), pp.
357
360
. http://carpedien.ien.gov.br:8080/handle/ien/1706
35.
Razali
,
N. M.
, and
Geraghty
,
J.
,
2011
, “
Genetic Algorithm Performance With Different Selection Strategies in Solving TSP
,”
Proc. World Congress Engineering
,
2
(
1
), pp.
1
6
.
36.
Lipowski
,
A.
, and
Lipowska
,
D.
,
2012
, “
Roulette-Wheel Selection via Stochastic Acceptance
,”
Physica A: Stat. Mech. Appl.
,
391
(
6
), pp.
2193
2196
. 10.1016/j.physa.2011.12.004
37.
Reeves
,
C. R.
,
1995
, “
A Genetic Algorithm for Flowshop Sequencing
,”
Comp. Oper. Res.
,
22
(
1
), pp.
5
13
. 10.1016/0305-0548(93)E0014-K