Minimization wait-free flexible manufacturing system completion time heuristic search scheduling method

Abstract

The invention discloses a heuristic search scheduling method for minimizing completion time of a wait-free flexible manufacturing system, and provides three heuristic functions which consider path flexibility and resource flexibility at the same time so as to more accurately estimate residual cost to better guide algorithm search. Two one-step back-off strategies are established, the search efficiency is further improved according to the sequence of exchange operation, two exchange rules are provided, and invalid exchange is avoided; a heuristic function, a one-step back-off strategy and a deadlock avoiding strategy are combined together, and the performance of the algorithm is far better than that of an existing algorithm when the algorithm is embedded into a search process.

Description

Technical Field

[0001] The present invention belongs to the technical field of flexible manufacturing systems, and particularly relates to a heuristic search scheduling method for minimizing the completion time of a no-wait flexible manufacturing system. Background Art

[0002] The no-wait scheduling problem widely exists in real life, such as steel manufacturing, wafer manufacturing, network communication, food production, etc. At present, the research on the no-wait scheduling problem is widely concentrated on flow shops and job shops. For example, Zhu et al. recorded in reference [1] (J. Zhu and X. Li, “An effective meta-heuristic for no-wait job shops to minimize makespan,” IEEE Trans. Autom. Sci. Eng., vol. 9, no. 1, pp. 189-198, 2011.) split the no-wait scheduling problem into a schedule sub-problem and a job sequencing sub-problem, and proposed a schedule algorithm and a job sequencing algorithm based on an improved local search algorithm. Since it is generally assumed that there is enough buffer space in flow shop and job shop problems, the consideration of deadlocks in the system is ignored. In a flexible manufacturing system (FMS), due to the high degree of resource sharing, it is prone to deadlocks. Once a deadlock occurs, the system will come to a standstill and be unable to complete the processing tasks, resulting in economic losses and serious consequences. Recently, the deadlock control problem and deadlock-free scheduling problem of flexible manufacturing systems have received extensive attention from researchers. A small number of researchers have studied the deadlock control problem of flexible manufacturing systems. Piroddi et al. recorded in reference [2] (L. Piroddi, R. Cordone, and I. Fumagalli, “Selective siphon control for deadlock prevention in Petri nets,” IEEE Trans. Syst. Man Cybern. A, Syst. Humans, vol. 38, no. 6, pp. 1337-1348, 2008.) proposed a deadlock control strategy for flexible manufacturing systems based on the Petri net model of the system and compared it with existing deadlock control methods. The results show that this strategy has higher permissiveness.

[0003] Scheduling is the foundation for ensuring the operating performance of the system. The deadlock-free and wait-free scheduling method not only needs to ensure that the system is deadlock-free, but also needs to consider wait-free and ensure the operating performance of the system. Therefore, it is more complex than the deadlock control of the system and the scheduling problem that only considers deadlock-free. Only a few researchers have studied the deadlock-free and wait-free scheduling problems of FMS. Wang et al. recorded in the literature [3] (X. Wang, K. Xing, Y. Feng, and Y. Wu, “Scheduling of flexible manufacturing systems subject to no-wait constraints via Petri nets and heuristic search,” IEEE Trans. Syst. Man Cybern., Syst., vol. 51, no. 10, pp. 6122-6133, 2019.) studied the deadlock-free and wait-free scheduling problems of FMS and proposed a heuristic search algorithm to minimize the makespan of FMS.

[0004] Currently, the deadlock-free and wait-free scheduling technologies for FMS have the following disadvantages:

[0005] 1) The existing heuristic functions ignore the path flexibility and resource flexibility of FMS, resulting in inaccurate estimation of the remaining cost;

[0006] 2) The heuristic function may lead the search in the wrong direction, but currently there is a lack of a correction method for this wrong guiding direction. Summary of the Invention

[0007] In order to overcome the deficiencies of the prior art, the present invention provides a heuristic search scheduling method for minimizing the makespan of a wait-free flexible manufacturing system, and proposes three heuristic functions that simultaneously consider path flexibility and resource flexibility to more accurately estimate the remaining cost to better guide the algorithm search; two one-step backtracking strategies are established to exchange the order of jobs, thereby improving the search efficiency, and two exchange rules are proposed to avoid invalid exchanges; by combining the heuristic function, the one-step backtracking strategy, and the deadlock avoidance strategy together and embedding them into the search process, the performance is much better than the existing algorithms.

[0008] The technical solutions adopted by the present invention to solve its technical problems are as follows:

[0009] Step 1: Model the flexible assembly system;

[0010] Step 1.1: Petri net;

[0011] A Petri net is a directed bipartite graph that includes two types of vertices: places and transitions. Places are represented by circles, transitions are represented by rectangles or thick solid lines, and there are directed arcs connecting places and transitions. Let \(Z = \{0, 1, 2, \ldots\}\), \(Z + ^+ = \{1, 2, 3, \ldots\}\), \(Z k ^k = \{1, 2, \ldots, k\}\), where \(k \in Z + ; The specific definition of a Petri net is as follows:

[0012] A Petri net is a triple \(N=(P, T, F)\), where \(P\) is the set of places, \(T\) is the set of transitions, and \(F\) is the set of directed arcs. \(P\) and \(T\) are finite, non - empty, and disjoint sets, that is,

[0013] In the Petri net \(N=(P, T, F)\), given a vertex \(x\in P\cup T\), use · \(^{\bullet}x = \{y\in P\cup T|(y, x)\in F\}\) and \(x · ^{\bullet}=\{y\in P\cup T|(x, y)\in F\}\) to represent the preset and postset of \(x\) respectively. Given a set use · ^{\bullet}X=\cup x∈X · ^{\bullet}x\) and \(X · ^{\bullet}=\cup x∈X x^{\bullet} · ;

[0014] The state or marking of a Petri net \(N=(P, T, F)\) is a mapping \(M: P\rightarrow Z * ^+\), for a place \(p\in P\) and a marking \(M\), \(M(p)\) represents the number of tokens in place \(p\) under the marking \(M\). The number of tokens in a place is represented by the number of black dots or a positive integer. A Petri net \(N\) with an initial marking \(M_0\) is called a marked Petri net, denoted as \((N, M_0)\);

[0015] The marking is represented by a vector, that is, \(M=(M(p_1), M(p_2), \ldots, M(p |P| _n)) T \), and \(\sum p∈P M(p)p\) represents the marking \(M\);

[0016] Given a Petri net \(N=(P, T, F)\), \(t\in T\) is a transition in \(N\), and \(M\) is a marking in \(N\). If If M(p)>0, then the transition t is said to be enabled under the marking M, denoted as M[t>; firing the transition t under the marking M will cause the system to transition from the marking M to the marking M′, denoted as M[t>M′, where, M′(p) = M(p) - 1; M′(p) = M(p) + 1; otherwise, M′(p) = M(p); For the transition sequence τ = t1t2…t k , t i ∈T, i∈Z k , if M i [t i >M i+1 , where M1 = M, then τ is said to be feasible under M;

[0017] Step 1.2: Timed Place PN Model of FMS;

[0018] The PN scheduling model PNS consists of m types of resources and can produce l types of products through n types of parts; The set of part types is represented by Q = {q, q∈Z n}; Let represent the total number of parts, where is the number of parts of type q to be processed; The set of resource types is represented by R = {r1, r2, …, r m}; The capacity of resource r i is represented by C(r i ); Let r ij be the j-th instance of the resource, where

[0019] The total number of processing routes in the system is K; A processing route consists of a series of operations; Let w k = o k1 o k2 ...o kl ...o kLk represent the k-th processing route, where o kl is the l-th operation, L k is the number of operations in w k ; Let R(o kl )∈R represent the resources required for o kl ; The set of all processing routes in the system is marked as Ω = {w1, w2, …, w K}; Given q∈Z n , let be the set of processing routes for parts of type q; There is at least one route available for processing parts of type q, i.e., |Ω q |≥1; Add two virtual operations o qs and o qe, respectively used to identify the start and end of the processing of q-type parts; the u-th processing route of q-type parts can be marked as where and w q(u) ∈Ω q ; if two different processing routes contain the same operations, they will be merged into one operation;

[0020] Let p qs and p qe respectively represent the operations o qs and o qe , let p q(u)l represent the operation place of operation o q(u)l , t q(u)l and t q(u)(l+1) respectively represent the start and completion transitions of o q(u)l , where w q(u) ∈Ω q , l ∈ Z Lq(u) ; a processing route w q(u) in FMS is modeled by the path ; once the operation t q(u)(l-1) is completed, the transition t q(u)l must be triggered immediately; the PN model representation of the identification of the processing route of q-type parts is:

[0021] (N q , M q0 ) = (P q ∪{p qs , p qe}, T q , F q , M q0 ), q ∈ Q

[0022] where, P q = ∪ 1≤u≤|Ωq| {p q(u)1 , p q(u)2 ,..., p q(u)Lq(u)} and M q0 is the initial identification, and for any p ∈ P q ∪{p qe}}, there is M q0 (p) = 0; in N q , for any t ∈ T q , | · t| = |t · | = 1; if |p · |>1, then p is a branch place, where the part can choose its processing route;

[0023] In the FMS, the resource repository is denoted as r i ; Let P R represent all the resource repositories; the quantity of available r i type resources is represented by the number of tokens in the resource repository r i ; C(r i ) is the initial marking quantity of r i ;

[0024] Let R(p) ∈ R denote the resources required by the operation repository p; in the PN model, arcs are respectively added from R(p) to · each transition in p, and arcs from each transition in p · to R(p); Let F R represent the set of arcs related to the resource repository; the marked PN can model the entire system:

[0025] (N, M0) = (P ∪ P s ∪ P f ∪ P R , T, F, M0)

[0026] where P = {P q |q ∈ Q}, P s = {p qs |q ∈ Q}, P f = {p qe |q ∈ Q}, T = {T q |q ∈ Q}, F = F Q ∪ F R , F Q = {F q |q ∈ Q}; the initial marking M0 is defined such that for any p qs ∈ P s , there is for any p ∈ P ∪ P f , M0(p) = 0; for any r i ∈ P R , M0(r i ) = C(r i );

[0027] Let M f represent the final marking when all parts are processed, where for there is M f (p qe ) =

[0028] M0(p qs ); for there is M f (p) = 0; for All have M f (r i ) = C(r i );

[0029] For p ∈ P, let o be the corresponding operation; let d(o) be the processing time of operation o; assign a time delay d(p) = d(o) to p, and for all have d(p) = 0; such a place - timed PN model for a flexible assembly system is called the PN scheduling model PNS;

[0030] Step 1.3: Deadlock controller of PNS;

[0031] Let (C, μ C ) = (P C , T C , F C , μ C ) represent a PN dead - lock controller; each control place in P C can be regarded as a special resource, called a control resource; the tokens in the control resource place represent the number of control resource instances, and the arcs related to the control resources represent their allocation and release situations; then, the controlled PNS, i.e., CPNS, can be modeled by a marked PN, that is Let represent the set of control resources required by the operation place p;

[0032] Step 2: Hybrid heuristic search algorithm;

[0033] Step 2.1: Combined search graph;

[0034] In an FMS, a part may have multiple alternative processing routes; therefore, there may be multiple route - selection schemes corresponding to different completion times for a part sequence; to distinguish different route - selection schemes, a CSG is defined, where the vertices of the graph are the combinations of part sequences and their corresponding route - selection schemes;

[0035] Let G(N C , M C0 ) = (V, E) represent the CSG of the FMS, where V is the vertex set and E is the directed - arc set; a vertex v = (S J , S W ) contains a part sequence S J , and the i - th part in S J is S J [i] ∈ Z Φ , and for all have t ∈ Z |SJ |, S J [k] ≠ S J[t]; It also includes a route selection plan for S J , that is, S W , where the i-th route in S W , that is, S W [i], is the route corresponding to S J [i]; if S J [i] is a q-type part, then S W [i] ∈ Ω q ; if there exists a part J i and a route w j that satisfy w j ∈ Ω is a route of J i , S J2 = S J1 J i , and S W2 = S W1 w j , then there exists an arc pointing from vertex v1 = (S J1 , S W1 ) to v2 = (S J2 , S W2 ); let dep(v) = |S J | represent the depth of v in G(N C , M C0 );

[0036] Let represent the initial vertex, where is an empty string, and v f = (S Jf , S Wf ) represents the final vertex, indicating that all parts have been arranged;

[0037] Step 2.2: New heuristic function;

[0038] Use the heuristic function f(v) = g(v) + h(v) to assign a priority value to each vertex v ∈ V, where g(v) is the cost from v0 to v, and h(v) is the estimated cost from v to v f ;

[0039] Let h*(v) represent the actual minimum cost from v to v f ; if for all have h(v) ≤ h*(v), then h(v) is admissible;

[0040] The first heuristic function h1(v) estimates the remaining time for each resource to be occupied by the unassigned parts according to g(v); h1(v) is calculated in two steps: First, calculate the minimum total time of r i , i ∈ Z m type resources required to process all unassigned parts at vertex v; Second, analyze each idle interval of each r i instance, and then calculate the maximum time that all unassigned parts can utilize a certain idle interval under the constraints of no waiting and no deadlock;

[0041] Let J(q, v) denote the set of unassigned parts of type q at vertex v, and w q(k) be the k-th processing route of parts of type q, where If the l-th operation in route w q(k) , denoted as o q(k)l , requires r i type of resource, then let δ(r i , o q(k)l ) = 1; otherwise, let δ(r i , o q(k)l ) = 0, where and i ∈ Z m ; Let Ψ(r i , v) denote the minimum total time of r i type resources required to process all unassigned parts under vertex v; Define:

[0042]

[0043] Let α(v) denote the scheduling scheme obtained for vertex v using the TA algorithm; Due to the constraints of no deadlock, no waiting, and precedence constraints, there are idle intervals between the parts already arranged on the resources, which are identified as type 1 idle intervals; Let τ(r ij , v) denote the number of type 1 idle intervals of resource r ij in the Gantt chart of α(v); Let δ(r ij , v, l) and ε(r ij , v, l) denote the start time and end time of the l-th type 1 idle interval in resource r ij , respectively, where l = 1, 2,..., τ(r ij , v); Then a type 1 idle interval is represented as {δ(r ij , v, l), ε(r ij , v, l)};

[0044] Let χ(r ij , v) denote the completion time of the last part already arranged on resource r ij under vertex v; On resource rij Scheduling the un - scheduled parts after the last scheduled part may create idle intervals, which are identified as type - 2 idle intervals, i.e., {χ(r ij ,v),X}, where X is a time variable indicating that an unscheduled part will occupy resource r starting from time X ij ;

[0045] For type - 1 idle intervals {δ(r ij ,v,l),ε(r ij ,v,l)}, the interval from its earliest available time to ε(r ij ,v,l) is used to estimate its longest available time; for type - 2 idle intervals {χ(r ij ,v),X}, the interval from χ(r ij ,v) to its earliest available time is used to estimate the shortest time that will be generated;

[0046] Step 2.2.1: Earliest start time algorithm;

[0047] Given a vertex v and an idle interval {a,b} in resource r ij , an earliest start time EST algorithm is proposed to calculate the earliest start time of the parts that can use {a,b} and satisfy the no - waiting and no - deadlock constraints; the EST algorithm starts searching from the earliest available time of the idle interval and once a part that can use {a,b} starting from time is found, the EST algorithm returns If no part can use {a,b} starting from time, then is incremented; such a process is repeated continuously until a part is found or ;

[0048] EST algorithm:

[0049] Input: Vertex v of (N C ,M C0 ), resource r ij and the idle interval {a,b} of resource r ij ;

[0050] Output:

[0051] Initialization: Apply the TA algorithm to vertex v to obtain the scheduling scheme α(v) and {δ(r ij ,v,l),ε(r ij ,v,l)} of resource r ij , where i ∈ Zm , l ∈ {1, 2, …, τ(r ij ), v};

[0052] Step 2.2.1.1: Let

[0053] Step 2.2.1.2: If then execute Steps 2.2.1.2.1 to 2.2.1.2.3; otherwise, jump to Step 2.2.1.3;

[0054] Step 2.2.1.2.1: Let q = 1;

[0055] Step 2.2.1.2.2: If q ≤ n and when, execute Steps 2.2.1.2.2.1 to 2.2.1.2.2.2; otherwise, jump to Step 2.2.1.2.3:

[0056] Step 2.2.1.2.2.1: For each w q(k) ∈ Ω q execute Step 2.2.1.2.2.1.1;

[0057] Step 2.2.1.2.2.1.1: For each o xy ∈ w q(k) and R(o xy ) = r i execute Steps 2.2.1.2.2.1.1.1 and 2.2.1.2.2.1.1.2;

[0058] Step 2.2.1.2.2.1.1.1: Assume o xy at the starting time on r i is and calculate the interval time required for each resource and control resource related to w q(k) when arranging a type - q part with a processing route of w q(k) and satisfying the non - waiting constraint;

[0059] Step 2.2.1.1.1.1.1.2: If the idle interval times of all resources and control resources related to w q(k) can meet the interval time requirements calculated in Step 2.2.1.2.2.1.1.1, then jump to Step 2.2.1.4;

[0060] Step 2.2.1.2.2.2: Increment q by 1 and jump to Step 2.2.1.2.2;

[0061] Step 2.2.1.2.3: Increment by 1 and jump to step 2.2.1.2;

[0062] Step 2.2.1.3: Return

[0063] Let denote the earliest time when the l-th type-1 idle interval can be used, where l = 1, 2, …, τ(r ij , v); Let denote the earliest time to schedule the unscheduled parts after the last part on resource r ij ;

[0064] Let denote the total time that the type-1 idle interval of resource r ij can be occupied; The first heuristic function is defined as follows:

[0065]

[0066] Define Lemma 1: h1(v) is admissible;

[0067] Two heuristic functions, denoted as h2(v) and h3(v) respectively, are developed by estimating the remaining processing time of each type of part for v = (S J , S W );

[0068] Let S Jq denote a permutation of the parts in J(q, v) arranged in ascending order; h2(v) assigns the parts in S Jq to each route in Ω q in turn, that is, the l-th part in S Jq selects the {l mod |Ω q |}-th route in Ω q ; Let S Wq2 denote the route selection result for S Jq generated by this route selection strategy; Then, a vertex v q2 = (S J S Jq ; S W S Wq2 ) is derived from vertex v;

[0069] It is defined as follows:

[0070]

[0071] Step 2.2.2: Greedy strategy;

[0072] h3(v) selects routes for the parts in S Jq through the following greedy strategy GS for Ωq The route in

[0073] Algorithm GS:

[0074] Input: A vertex v = (S J ; S W ), and a part type q ∈ Z n ;

[0075] Output: A new vertex v q3 = (S J S Jq ; S W S Wq3 );

[0076] Step 2.2.2.1: Let v q3 = v, v t = v;

[0077] Step 2.2.2.2: Let i = 1;

[0078] Step 2.2.2.3: If i is less than or equal to |J(q, v)|, execute Steps 2.2.2.3.1 to 2.2.2.3.5, otherwise jump to Step 2.2.2.5;

[0079] Step 2.2.2.3.1: Let k be the i-th part in J(q, v);

[0080] Step 2.2.2.3.2: Let g m = MAX; MAX is an infinitely large value

[0081] Step 2.2.2.3.3: Let j = 1;

[0082] Step 2.2.2.3.4: If j is less than or equal to |Ω q |, execute Steps 2.2.2.3.4.1 to 2.2.2.3.4.5, otherwise jump to Step 2.2.2.3.5;

[0083] Step 2.2.2.3.4.1: Let w t be the j-th route in Ω q ;

[0084] Step 2.2.2.3.4.2: Assume v q3 = (S J1 ; S W1 ), let g1 = g(S J1 k; S W1 w t );

[0085] Step 2.2.2.3.4.3: If g1 < gm , then g m = g1, v t = (S J1 k; S W1 w t );

[0086] Step 2.2.2.3.4.4: v q3 = v t ;

[0087] Step 2.2.2.3.4.5: Increment j by 1 and jump to Step 2.2.2.3.4;

[0088] Step 2.2.2.3.5: Increment i by 1 and jump to Step 2.2.2.3;

[0089] Step 2.2.2.5; Return v q3 ;

[0090] h3(v) is defined as follows:

[0091]

[0092] Step 2.3: Hybrid Heuristic Search HHS;

[0093] Step 2.3.1: HHS algorithm;

[0094] Let dep t and dep b represent the maximum depth and minimum depth of vertices respectively. The distance between the maximum depth and the minimum depth is denoted as height, which is a constant. The vertices in the current search window consist of two types: explored vertices and unexplored vertices. Let ne(d) and nu(d) represent the number of explored vertices and unexplored vertices at depth d respectively. Let CLOSED and OPEN represent the set of explored vertices and the set of unexplored vertices respectively. max_top is a constant used to limit the number of unexplored vertices at the maximum depth dep t ;

[0095] In the preparation stage, the set of explored vertices CLOSED is initialized as an empty set, while the set of unexplored vertices OPEN contains only the initial vertex v0. Using the heuristic function, in each search step, the most promising vertex, that is, the vertex with the minimum f(v) value, is selected from the set. The selected vertex is then explored and moved into the CLOSED set. Arranging the unassigned parts of the selected vertex generates a new unexplored vertex, and some promising vertices will be put into the OPEN set. At the same time, when the number of unexplored vertices at the minimum depth nu(dep b ) = 0 or the number of unexplored vertices at the maximum depth nu(dept ) When it is > max_top, the dynamic window moves downward; this process is repeated until all parts are arranged; the HHS algorithm is as follows:

[0096] HHS algorithm:

[0097] Input: height, max_top, (N C , M C0 );

[0098] Input: a final vertex v and its corresponding scheduling scheme α(v);

[0099] Initialization: dep b = 0, dep t = height, OPEN = {v0},

[0100] Step 2.3.1.1: If OPEN is not equal to Execute steps 2.3.1.1.1 to 2.3.1.1.5, otherwise execute step 2.3.1.6:

[0101] Step 2.3.1.1.1: If nu(dep b ) = 0, then dep b is incremented by 1, dep t is incremented by 1, otherwise execute step 2.3.1.1.2;

[0102] Step 2.3.1.1.2: Select an unexplored vertex v ∈ OPEN from OPEN that satisfies the minimum f(v) value and dep(v) < dep t , let OPEN = OPEN\{v}, CLOSED = CLOSED ∪ {v};

[0103] Step 2.3.1.1.3: If v is a final vertex, return vertex v and its corresponding scheduling scheme α(v), otherwise execute step 2.3.1.1.4;

[0104] Step 2.3.1.1.4: Execute steps 2.3.1.1.4.1 and 2.3.1.1.4.2 for each unarranged part where q ∈ Z n and J ∈ J(q, v));

[0105] Step 2.3.1.1.4.1: For each processing route of J being and w q(k) ∈ Ω q ), execute steps 2.2.1.1.4.1.1 and 2.3.1.1.4.1.4;

[0106] Step 2.3.1.1.4.1.1: Let v = (S o J,S r w q(k) );

[0107] Step 2.3.1.1.4.1.2: If there exists a vertex v ∈ OPEN ∪ CLOSED whose route part S r is a permutation of S r w q(k) , then execute Steps 2.3.1.1.4.1.2.1 to 2.3.1.1.4.1.2.3; otherwise, execute Step 2.3.1.1.4.1.3;

[0108] Step 2.3.1.1.4.1.2.1: OPEN = OPEN ∪ {v};

[0109] Step 2.3.1.1.4.1.2.2: If nu(dep t ) > max_top, then discard the vertices in the unexplored vertex set OPEN with depth dep b , increment dep b by 1, increment dep t by 1, and otherwise jump to Step 2.3.1.1.4.1;

[0110] Step 2.3.1.1.4.1.2.3: Jump to Step 2.3.1.1.4.1;

[0111] Step 2.3.1.1.4.1.3: If its route part S r is a permutation of S r w q(k) , and f(v) > f(v), then OPEN = OPEN \ {v} ∪ {v}; otherwise, jump to Step 2.3.1.1.4.1;

[0112] Step 2.3.1.1.4.1.4: Go to Step 2.3.1.1.4.1;

[0113] Step 2.3.1.1.4.2: Go to Step 2.3.1.1.4;

[0114] Step 2.3.1.1.5: Jump to Step 2.3.1.1;

[0115] Step 2.3.1.1.6: Return the vertex v and its corresponding scheduling scheme α(v);

[0116] Step 2.4: One-step Backward Exchange Strategy OBE;

[0117] Step 2.4.1: OBE1:

[0118] Given a vertex v, if v ≠ OBE1(v), then such a trigger of the strategy is called a valid trigger; otherwise, it is called an invalid trigger.

[0119] Algorithm OBE1:

[0120] Input: A vertex v = ((S J [1], S J [2],..., S J [i]); (S W [1], S W [2],..., S W [i]));

[0121] Output: A vertex v1;

[0122] Step 2.4.1.1: v1 = ((S J [1], S J [2],..., S J [i - 2], S J [i], S J [i - 1]); (S W [1], S W [2],..., S W [i - 2], S W [i], S W [i - 1]));

[0123] Step 2.4.1.2: If f(v1) < f(v), then return v1; otherwise, execute Step 2.4.1.3;

[0124] Step 2.4.1.3: Return v;

[0125] Two rules are given:

[0126] Rule 1: Given a vertex v = ((S J [1], S J [2],..., S J [i - 1], S J [i]); (S W [1], S W [2],..., S W [i - 1], S W [i])), if S W [i] = S W [i - 1], then OBE1 is not triggered;

[0127] Rule 2: Let v = ((S J [1], S J[2],...,S J [i - 2],S J [i - 1],S J [i]); (S W [1],S W [2],...,S W [i - 2],S W [i - 1],S W [i])), v1 = ((S J [1],S J [2],...,S J [i - 2],S J [i],S J [i - 1]); (S W [1],S W [2],...,S W [i - 2],S W [i],S W [i - 1])), v2 = ((S J [1],S J [2],...,S J [i - 2],S J [i]); (S W [1],S W [2],...,S W [i - 2],S W [i])), and v3 = ((S J [1],S J [2],...,S J [i - 2],S J [i - 1]); (S W [1],S W [2],...,S W [i - 2],S W [i - 1])); Let τ(v) be the start time of the last part in vertex v; if τ(v) - τ(v2) ≤ τ(v1) - τ(v3), then the OBE1 policy will not be triggered;

[0128] Step 2.4.2: OBE2:

[0129] Based on Rule 1 and Rule 2, the OBE2 policy is proposed. Different from OBE1 which performs OBE operations on all vertices, OBE2 only performs OBE operations on vertices that meet the conditions in Rule 1 and Rule 2;

[0130] Algorithm OBE2:

[0131] Input: A vertex v = ((S J [1],SJ [2],...,S J [i - 1],S J [i]); (S W [1],S W [2],...,S W [i - 1],S W [i])), (i ∈ Z Φ );

[0132] Output: a vertex v1;

[0133] Step 2.4.2.1: Let v1 = ((S J [1],S J [2],...,S J [i - 2],S J [i],S J [i - 1]); (S W [1],S W [2],...,S W [i - 2],S W [i],S W [i - 1])), v2 = ((S J [1],S J [2],...,S J [i - 2],S J [i]); (S W [1],S W [2],...,S W [i - 2],S W [i])), v3 = ((S J [1],S J [2],...,S J [i - 2],S J [i - 1]); (S W [1],S W [2],...,S W [i - 2],S W [i - 1]));

[0134] Step 2.4.2.2: If S W [i] ≠ S W [i - 1], execute Step 2.4.2.2.1, otherwise execute Step 2.4.2.3;

[0135] Step 2.4.2.2.1: If τ(v) - τ(v2)) > τ(v1) - τ(v3), then return the result of v for executing OBE1, otherwise execute Step 2.4.2.3;

[0136] Step 2.4.2.3: Return v.

[0137] A computer program that causes a computer to execute the above heuristic search scheduling method.

[0138] An electronic device, comprising: a processor and a memory; the memory is used to store a computer program, and the processor is used to execute the computer program stored in the memory so that the electronic device executes the above heuristic search scheduling method.

[0139] A computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the above heuristic search scheduling method is implemented.

[0140] A chip, comprising: a processor, configured to call and run a computer program from a memory, so that a device installed with the chip executes the above heuristic search scheduling method.

[0141] A computer program product, the computer program product includes a computer storage medium, the computer storage medium stores a computer program, the computer program includes instructions that can be executed by at least one processor, and when the instructions are executed by the at least one processor, the above heuristic search scheduling method is implemented.

[0142] The beneficial effects of the present invention are as follows:

[0143] (1) The present invention proposes three heuristic functions that simultaneously consider path flexibility and resource flexibility, which can more accurately estimate the remaining cost and thus better guide the algorithm search;

[0144] (2) The present invention establishes two one-step backward strategies, which can not only correct and avoid incorrect search directions, but also avoid ineffective backward exchange operations;

[0145] (3) By combining the heuristic function, the one-step backward strategy, and the deadlock avoidance strategy, and embedding them into the search process, the problems of inaccurate estimation of the heuristic function in the existing heuristic search algorithm and the lack of corresponding error correction methods for incorrect search directions are overcome. Description of the Drawings

[0146] Figure 1 It is the PNS model of the FMS tested in the present invention. Detailed Embodiments

[0147] The present invention will be further described below with reference to the drawings and embodiments.

[0148] To overcome the deficiencies of the prior art, the present invention provides a hybrid heuristic search scheduling method for an FMS with the goal of minimizing the makespan under no-wait scheduling constraints. First, based on the simulation of future resource occupancy and job arrangements, three heuristic functions are proposed that simultaneously consider deadlock-free and wait-free constraints, as well as path flexibility and resource flexibility. Second, two one-step backward exchange strategies are established to avoid blind exchanges by formulating rules for changing the order of adjacent jobs, thereby improving the search efficiency.

[0149] The steps of the technical solution adopted by the present invention to solve its technical problems are as follows:

[0150] Step 1: Flexible assembly system modeling;

[0151] Step 1.1 Petri net preliminary knowledge;

[0152] A Petri net is a directed bipartite graph that includes two types of vertices: places and transitions. Among them, places are represented by circles, transitions are represented by rectangles or thick solid lines, and places and transitions are connected by directed arcs. Z = {0, 1, 2,...}, Z + = {1, 2, 3,...}, Z k = {1, 2,..., k}, where k ∈ Z + ; The specific definition of a Petri net is as follows:

[0153] A Petri net is a triple N = (P, T, F), where P is the set of places, T is the set of transitions, F is the set of directed arcs, and P and T are finite, disjoint, non-empty sets, that is

[0154] In the Petri net N = (P, T, F), given a vertex x ∈ P ∪ T, use · x = {y ∈ P ∪ T | (y, x) ∈ F} and x · = {y ∈ P ∪ T | (x, y) ∈ F} to represent the preset and postset of x respectively. Given a set Use · X = ∪ x∈X · x and X · = ∪ x∈X x · ;

[0155] The state or marking of the Petri net N = (P, T, F) is a mapping M: P → Z from the set of places to the set of non-negative integers *, for a position p ∈ P and a marking M, M(p) represents the number of tokens in position p under marking M. The number of tokens in a position is represented by the number of black dots or a positive integer. A Petri net N with an initial marking M0 is called a marked Petri net, denoted as (N, M0);

[0156] The marking is represented by a vector, i.e., M = (M(p1), M(p2), …, M(p |P| )) T , for simplicity, ∑ p∈P M(p)p represents the marking M;

[0157] Given a Petri net N = (P, T, F), t ∈ T is a transition in N, and M is a marking in N. If M(p) > 0, then the transition t is said to be enabled under marking M, denoted as M[t>; Firing the transition t under marking M will cause the system to change from marking M to marking M′, denoted as M[t>M′, where, M′(p) = M(p) - 1; M′(p) = M(p) + 1; otherwise, M′(p) = M(p); For a transition sequence τ = t1t2…t k , t i ∈ T, i ∈ Z k , if M i [t i >M i+1 , where M1 = M, then τ is said to be feasible under M;

[0158] Step 1.2 Timed PN model of the FMS positions;

[0159] The FMS of the present invention is the same as the FMS in reference [3], and their PN scheduling models (PN for Scheduling, PNS) are also the same. To save space, a simplified model is given in the present invention. The PN scheduling model PNS consists of m types of resources and can produce l types of products through n types of parts; The set of part types is represented by Q = {q, q ∈ Z n}; Let represent the total number of parts, where is the number of parts of type q to be processed; The set of resource types is represented by R = {r1, r2, …, r m}; The capacity of resource r i is represented by C(r i ); Let r ij be the j-th instance of the resource, where

[0160] The total number of processing routes in the system is K; a processing route consists of a series of operations; let w k = o k1 o k2 ... o kl ... o kLk represent the k-th processing route, where o kl is the l-th operation, and L k is the number of operations in w k ; let R(o kl ) ∈ R denote the resources required for o kl ; the set of all processing routes in the system is labeled as Ω = {w1, w2, …, w K}; given q ∈ Z n , let be the set of processing routes for q-type parts; there is at least one route available for processing q-type parts, i.e., |Ω q | ≥ 1; add two virtual operations o qs and o qe to identify the start and end of the processing of q-type parts respectively; the u-th processing route of q-type parts can be labeled as where and w q(u) ∈ Ω q ; it should be noted that two different processing routes may contain the same operation. For simplicity, they will be merged into one operation.

[0161] Let p qs and p qe represent the operations o qs and o qe respectively, let p q(u)l represent the operation place for the operation o q(u)l , and t q(u)l and t q(u)(l+1) represent the transitions at which o q(u)l starts and finishes respectively, where u ∈ Z |Ωq| , w q(u) ∈ Ω q , l ∈ Z Lq(u) ; a processing route w q(u) in the FMS is modeled by the path ; it should be noted that due to the no-waiting constraint, once the operation t q(u)(l-1) is completed, the transition t q(u)l must be triggered immediately; the PN model for identifying the processing route of q-type parts can be expressed as:

[0162] (N q , M q0 ) = (P q ∪ {p qs , pqe},T q ,F q ,M q0 ), q ∈ Q

[0163] Among them, P q = ∪ 1≤u≤|Ωq| {p q(u)1 , p q(u)2 ,..., p q(u)Lq(u)}, and M q0 is the initial marking, and for any p ∈ P q ∪ {p qe}, there is M q0 (p) = 0; In N q , for any t ∈ T q , | · t| = |t · | = 1; If |p · | > 1, then p is a branching place, where parts can choose their processing routes;

[0164] In FMS, the resource place is denoted as r i . Let P R represent all resource places. The number of available r i type resources is represented by the number of tokens in the resource place r i . C(r i ) is the initial marking number of r i .

[0165] Let R(p) ∈ R represent the resources required by the operation place p. To represent the allocation and release of R(p), in the PN model, arcs are added from R(p) to · each transition in p, and arcs are added from each transition in p · to R(p). Let F R represent the set of arcs related to the resource place. The following marked PN can model the entire system

[0166] (N, M0) = (P ∪ P s ∪ P f ∪ P R , T, F, M0)

[0167] Among them, P = {P q |q ∈ Q}, P s = {p qs |q ∈ Q}, P f = {p qe |q ∈ Q}, T = {T q|q ∈ Q}, F = F Q ∪ F R , F Q = {F q |q ∈ Q}. The initial marking M0 is defined such that for any p qs ∈ P s , there is For any p ∈ P ∪ P f , there is M0(p) = 0; for any r i ∈ P R , there is M0(r i ) = C(r i ).

[0168] Let M f represent the final marking when all parts are processed, where for there is M f (p qe ) = M0(p qs ); for there is M f (p) = 0. For there is M f (r i ) = C(r i ).

[0169] For p ∈ P, let o be the corresponding operation. Let d(o) be the processing time of operation o. Then, assign a time delay d(p) = d(o), in particular, for there is d(p) = 0. Such a timed PN model for a flexible assembly system is called a PN scheduling model (PN for Scheduling, PNS).

[0170] Step 1.3 Deadlock controller of PNS;

[0171] For an FMS, even if a candidate scheduling scheme satisfies the non - waiting constraint condition, it may still be infeasible due to deadlock problems. Therefore, a deadlock control strategy is needed.

[0172] Let (C, μ C ) = (P C , T C , F C , μ C ) represent a PN deadlock controller. P CEach control place in it can be regarded as a special resource, called control resource. Similar to the ordinary resources in PNS, the tokens in the control resource places represent the number of control resource instances, and the arcs related to the control resources indicate their allocation and release situations. Then, the Controlled PNS (CPNS) can be modeled by a marked PN, that is Let represent the set of control resources required for the operation place p.

[0173] Reference [3] has verified that scheduling algorithms integrated with more relaxed controllers tend to find better scheduling solutions. Therefore, the present invention adopts the optimal controller proposed in reference [2].

[0174] Step 2: Hybrid heuristic search algorithm;

[0175] In the no-wait scheduling problem, the start time of a part must match the part order. In addition, all operations of a part should be processed without interruption. Therefore, the no-wait scheduling problem can be divided into two sub-problems: the part sequencing problem, whose purpose is to find an optimal or sub-optimal part order; and the timetabling problem, which aims to determine a start time for each part in the part order. The timetabling sub-problem has been solved in reference [3] by proposing an algorithm called the Timetabling Algorithm (TA). Therefore, this patent focuses on solving the part sequencing problem.

[0176] In an FMS, a part may have multiple processing routes. Therefore, regarding the sequencing problem of FMS, its goal is not only to find a part order but also to determine the corresponding route selection scheme. Since the operation of an FMS can be traced through the combination space of the part order and the route selection scheme, the sequencing problem can be transformed into a search problem in this combination space. This problem can be solved by the Dynamic Window Search (DWS) algorithm mentioned in reference [3].

[0177] Inspired by the related work in reference [3], the present invention proposes three novel heuristic functions to efficiently guide the search process, and also proposes two One-step Back Exchange (OBE) strategies for correcting poor part sequences. They are all based on the Combined Search Graph (CSG) defined below.

[0178] Step 2.1: Combined search graph;

[0179] In an FMS, a part may have multiple alternative processing routes. Therefore, there may be multiple route selection schemes corresponding to different completion times for a part sequence. To distinguish different route selection schemes, the present invention defines a CSG, where the vertices of the graph are combinations of part sequences and their corresponding route selection schemes.

[0180] Let G(N C ,M C0 ) = (V, E) represent the CSG of the FMS, where V is the set of vertices and E is the set of directed arcs; a vertex v = (S J ,S W ) contains a part sequence S J , in S J the i-th part is S J [i] ∈ Z Φ , and for all have t ∈ Z |SJ |, S J [k] ≠ S J [t]; it also contains a route selection scheme for S J , that is, S W , where the i-th route in S W , that is, S W [i], is the route corresponding to S J [i]; if S J [i] is a part of type q, then S W [i] ∈ Ω q ; if there exists a part J i and a route w j , satisfying w j ∈ Ω is a route of J i , S J2 = S J1 J i , and S W2 = S W1 w j , then there exists an arc pointing from vertex v1 = (S J1 , S W1 ) to v2 = (S J2 , S W2 ); let dep(v) = |S J | represent the depth of v in G(N C , M C0 );

[0181] Let represent the initial vertex, where is the empty string, v f = (S Jf , SWf ) represents the final vertex, meaning that all parts have been arranged properly.

[0182] Step 2.2: New heuristic function;

[0183] The DWS algorithm assigns a priority value to each vertex v ∈ V using the heuristic function f(v) = g(v) + h(v), where g(v) is the cost from v0 to v, and h(v) is the estimated cost from v to v f The estimated cost can be obtained through TA mentioned in reference [3].

[0184] Let h*(v) denote the actual minimum cost from v to v f If for all h(v) ≤ h*(v), then h(v) is admissible.

[0185] To solve the scheduling problem of FMSs subject to no-wait constraints, Wang et al. designed three heuristic functions in reference [3]. However, these functions they designed did not consider resource flexibility (i.e., the case where there are multiple available instances of a resource) and routing flexibility (i.e., the case where there are multiple feasible processing routes for a part). Therefore, these heuristic functions cannot accurately estimate the cost from a vertex to the final vertex. To address this defect, the present invention proposes three new CSG-based heuristic functions.

[0186] The first heuristic function h1(v) estimates the remaining time that each resource is occupied by unarranged parts according to g(v). h1(v) is calculated in two steps. First, it calculates the minimum total time of r i (i ∈ Z m ) type resources required to process all unarranged parts at vertex v. Second, it analyzes each idle interval of each r i instance, and then calculates the maximum time that all unarranged parts can utilize a certain idle interval under the constraints of no-wait and no-deadlock.

[0187] Let J(q, v) denote the set of unarranged parts of type q at vertex v, and w q(k) be the k-th processing route of parts of type q, where If the l-th operation in route w q(k) , denoted as o q(k)l , requires r i type of resource, then let δ(r i , o q(k)l ) = 1; otherwise, let δ(r i , o q(k)l ) = 0, where and i ∈ Z m. Let Ψ(r i , v) denote the minimum total time of r i -type resources required to process all unassigned parts under vertex v. Define

[0188]

[0189] Let α(v) denote the scheduling scheme obtained for vertex v using the TA algorithm; due to the absence of deadlocks, waiting constraints, and precedence constraints, there are idle intervals between the parts already scheduled on the resources, which are identified as type-1 idle intervals; let τ(r ij , v) denote the number of type-1 idle intervals of resource r ij in the Gantt chart of α(v); let δ(r ij , v, l) and ε(r ij , v, l) denote the start time and end time of the l-th type-1 idle interval in resource r ij , respectively, where l = 1, 2, …, τ(r ij , v); then a type-1 idle interval is represented as {δ(r ij , v, l), ε(r ij , v, l)};

[0190] Let χ(r ij , v) denote the completion time of the last scheduled part on resource r ij under vertex v. Scheduling the unassigned parts after the last scheduled part on resource r ij may generate idle intervals, which are identified as type-2 idle intervals, i.e., {χ(r ij , v), X}, where X is a time variable that represents an unassigned part will start to occupy resource r ij from time X.

[0191] When scheduling the unassigned parts at vertex v, using type-1 idle intervals may be able to shorten the completion time. At the same time, considering the impact of type-2 idle intervals helps to accurately evaluate the remaining cost.

[0192] The unassigned parts may use the idle intervals multiple times, which makes it difficult to accurately calculate the longest time that type-1 idle intervals can be used and the shortest time that type-2 idle intervals will generate. To reduce the computational complexity, for the type-1 idle interval {δ(r ij , v, l), ε(r ij , v, l)}, use the interval time from its earliest available time to ε(r ij , v, l) to estimate the longest time it can be used. For the type-2 idle interval {χ(r ij, v), X}, the interval from χ(r ij , v) to its earliest available time is used to estimate the shortest time that will be generated.

[0193] Step 2.2.1: Earliest Start Time Algorithm;

[0194] Given a vertex v and an idle interval {a, b} in resource r ij , an Earliest Starting Time (EST) algorithm is proposed to calculate the earliest start time of the part that can use {a, b} and satisfies the no-waiting and no-deadlock constraints. The EST algorithm starts searching from . Once a part that can use {a, b} starting from

[0195] is found, the EST algorithm returns If no part can use {a, b} starting from , then such a process will be repeated continuously until a part is found or is reached.

[0196] Algorithm EST;

[0197] Input: Vertex v, resource r of (N C , M C0 ) and the idle interval {a, b} of resource r ij and resource r ij ;

[0198] Output: / * The earliest time when the idle interval can be used * /

[0199] Initialization: Apply the TA algorithm to vertex v to obtain the scheduling scheme α(v) and {δ(r ij , v, l), ε(r ij , v, l)} of resource r ij , where i ∈ Z m , l ∈ {1, 2, …, τ(r ij , v)};

[0200] Step 2.2.1.1: Let

[0201] Step 2.2.1.2: If , then execute Steps 2.2.1.2.1 to 2.2.1.2.3, otherwise jump to Step 2.2.1.3;

[0202] Step 2.2.1.2.1: Let q = 1;

[0203] Step 2.2.1.2.2: If q ≤ n and when, execute Steps 2.2.1.2.2.1 to 2.2.1.2.2.2, otherwise, jump to Step 2.2.1.2.3:

[0204] Step 2.2.1.2.2.1: For each w q(k) ∈Ω q execute Step 2.2.1.2.2.1.1;

[0205] Step 2.2.1.2.2.1.1: For each o xy ∈w q(k) and R(o xy ) = r i execute Steps 2.2.1.2.2.1.1.1 and 2.2.1.2.2.1.1.2;

[0206] Step 2.2.1.2.2.1.1.1: Assume that the starting time of o xy on r i is and calculate the interval time required for each resource and control resource related to w q(k) when arranging a type q part with a processing route of w q(k) and satisfying the no-wait constraint;

[0207] Step 2.2.1.1.1.1.1.2: If the idle interval times of all resources and control resources related to w q(k) can meet the interval time requirements calculated in Step 2.2.1.2.2.1.1.1, then jump to Step 2.2.1.4;

[0208] Step 2.2.1.2.2.2: Increment q by 1 and jump to Step 2.2.1.2.2;

[0209] Step 2.2.1.2.3: Increment by 1 and jump to Step 2.2.1.2;

[0210] Step 2.2.1.3: Return

[0211] Let denote the earliest time when the l-th type 1 idle interval can be used, where l = 1, 2, …, τ(r ij , v). Let denote the earliest time to arrange the unarranged parts after the last part on resource r ij under vertex v.

[0212] Let it represent the total time during which the type-1 idle intervals of resource r ij can be occupied. The first heuristic function is defined as follows:

[0213]

[0214] In Algorithm 1, the EST algorithm takes into account both resource flexibility (lines 5 and 6) and route flexibility (line 3). In h1(v), is calculated by the EST algorithm, and ij in Λ(r ,v) is also calculated by the EST algorithm. Therefore, h1(v) takes into account both resource flexibility and route flexibility.

[0215] Lemma 1: h1(v) is admissible.

[0216] Proof: Let Ψ * (r i ,v) be the actual time of resource r i of type required for all unassigned parts in vertex v. Since Ψ(r i ,v) represents the minimum total time of resource r i of type required to process all unassigned parts under vertex v, so Ψ * (r i ,v) ≥ Ψ(r i ,v). Let be the earliest time when the l-th time interval of resource r ij in α(v) can be actually used, where l = 1, 2, …, τ(r ij ,v), ε*(r ij ,v, l) be the latest time when the l-th time interval of resource r ij in α(v) can be actually used, and let Λ*(r ij ,v) represent the actual longest total time that all idle intervals of resource r ij can be used for unassigned parts at vertex v. Obviously, and ε(r ij ,v, l) ≥ ε*(r ij ,v, l), so Λ(r ij ,v) ≥ Λ*(r ij ,v). Let be the earliest time when unassigned parts can be actually scheduled after the last part on resource r ij under vertex v. Obviously,

[0217] Therefore, it can be obtained that:

[0218]

[0219] Two other heuristic functions, denoted as h2(v) and h3(v), are developed by estimating the remaining processing time of each type of part for v = (S J , S W ).

[0220] Let S Jq denote a permutation of the parts in J(q, v) arranged in ascending order. h2(v) assigns the parts in S Jq to the routes in Ω q in sequence. That is, the l-th part in S Jq selects the {l mod |Ω q |}-th route in Ω q . Let S Wq2 denote the route selection result for S Jq generated by this route selection strategy. Then, a vertex v q2 = (S J S Jq ; S W S Wq2 ) is derived from the vertex v

[0221] is defined as follows:

[0222]

[0223] Step 2.2.2: Greedy Strategy;

[0224] h3(v) selects routes in Ω Jq for the parts in S q through the following Greedy Strategy (GS).

[0225] Algorithm GS;

[0226] Input: A vertex v = (S J ; S W ), and a part type q ∈ Z n ;

[0227] Output: A new vertex v q3 = (S J S Jq ; S W S Wq3 );

[0228] Step 2.2.2.1: Let v q3 = v, v t = v;

[0229] Step 2.2.2.2: Let i = 1;

[0230] Step 2.2.2.3: If i is less than or equal to |J(q,v)|, execute Steps 2.2.2.3.1 to 2.2.2.3.5; otherwise, jump to Step 2.2.2.5;

[0231] Step 2.2.2.3.1: Let k be the i-th part in J(q,v);

[0232] Step 2.2.2.3.2: Let g m = MAX; / * Here MAX is an infinitely large value * /

[0233] Step 2.2.2.3.3: Let j = 1;

[0234] Step 2.2.2.3.4: If j is less than or equal to |Ω q |, execute Steps 2.2.2.3.4.1 to 2.2.2.3.4.5; otherwise, jump to Step 2.2.2.3.5;

[0235] Step 2.2.2.3.4.1: Let w t be the j-th route in Ω q ;

[0236] Step 2.2.2.3.4.2: Assume v q3 = (S J1 ; S W1 ), let g1 = g(S J1 k; S W1 w t );

[0237] Step 2.2.2.3.4.3: If g1 < g m , then g m = g1, v t = (S J1 k; S W1 w t );

[0238] Step 2.2.2.3.4.4: v q3 = v t ;

[0239] Step 2.2.2.3.4.5: j = j + 1, jump to Step 2.2.2.3.4;

[0240] Step 2.2.2.3.5: i = i + 1, jump to Step 2.2.2.3;

[0241] Step 2.2.2.5; Return v q3 ;

[0242] h3(v) is defined as follows:

[0243]

[0244] h2(v) and h3(v) adopt different route selection strategies to handle route flexibility. In the calculation process of g(v), the TA algorithm arranges the parts in vertex v to different resource instances according to the interval time. Since both h2(v) and h3(v) use the TA algorithm for calculation, they both consider resource flexibility. Therefore, h2(v) and h3(v) consider both resource flexibility and route flexibility simultaneously.

[0245] Step 2.3: Hybrid Heuristic Search;

[0246] The Hybrid Heuristic Search (HHS) algorithm is an enhanced A * search algorithm that searches the CSG through a dynamic window of a certain scale. For details, see Reference [3].

[0247] Step 2.3.1: HHS algorithm;

[0248] Let dep t and dep b represent the maximum depth and minimum depth of the vertex respectively. The distance between them, denoted as the height, is a constant. The vertices in the current search window consist of two types: explored vertices and unexplored vertices. Let ne(d) and nu(d) represent the number of explored vertices and unexplored vertices at depth d respectively. Let CLOSED and OPEN represent the set of explored vertices and the set of unexplored vertices respectively. max_top is a constant used to limit the number of unexplored vertices at the maximum depth dep t .

[0249] In the preparation stage, the set of explored vertices CLOSED is initialized to an empty set, while the set of unexplored vertices OPEN only contains the initial vertex v0. Using the proposed heuristic function, in each search step, the most promising vertex, that is, the vertex with the minimum f(v) value, is selected from the set. The selected vertex is explored and then moved into the CLOSED set. Arranging the unassigned parts of the selected vertex generates a new unexplored vertex. Some promising vertices will be put into the OPEN set. At the same time, when the number of unexplored vertices at the minimum depth nu(dep b ) = 0 or the number of unexplored vertices at the maximum depth nu(dep t ) > max_top, the dynamic window moves down. This process is repeated continuously until all parts are arranged. The HHS algorithm is as follows.

[0250] Algorithm HHS;

[0251] Input: height, max_top, (N C , M C0 );

[0252] Input: A final vertex v and its corresponding scheduling scheme α(v);

[0253] Initialization: dep b = 0, dep t = height, OPEN = {v0},

[0254] Step 2.3.1.1: If OPEN is not equal to Execute Steps 2.3.1.1.1 to 2.3.1.1.5, otherwise execute Step 2.3.1.6:

[0255] Step 2.3.1.1.1: If nu(dep b ) = 0, then dep b = dep b + 1, dep t = dep t + 1, otherwise execute Step 2.3.1.1.2;

[0256] Step 2.3.1.1.2: Select an unexplored vertex v ∈ OPEN from OPEN that satisfies the minimum f(v) value and dep(v) < dep t , let OPEN = OPEN\{v}, CLOSED = CLOSED ∪ {v};

[0257] Step 2.3.1.1.3: If v is a final vertex, return vertex v and its corresponding scheduling scheme α(v), otherwise execute Step 2.3.1.1.4;

[0258] Step 2.3.1.1.4: For each q ∈ Z n and for each unassigned part J ∈ J(q, v)), execute Steps 2.3.1.1.4.1 and 2.3.1.1.4.2;

[0259] Step 2.3.1.1.4.1: For each processing route of J being w q(k) ( and w q(k) ∈ Ω q ), execute Steps 2.2.1.1.4.1.1 and 2.3.1.1.4.1.4;

[0260] Step 2.3.1.1.4.1.1: Let \(v=(S o J,S r w q(k) );

[0261] Step 2.3.1.1.4.1.2: If there exists a vertex \(v\in OPEN\cup CLOSED\) whose route part \(S r is a permutation of \(S r w q(k) \), then execute Steps 2.3.1.1.4.1.2.1 to 2.3.1.1.4.1.2.3; otherwise, execute Step 2.3.1.1.4.1.3;

[0262] Step 2.3.1.1.4.1.2.1: \(OPEN = OPEN\cup\{v\}\);

[0263] Step 2.3.1.1.4.1.2.2: If \(nu(dep t )>max\_top\), then discard the vertices in the set \(OPEN\) of unexplored vertices with depth \(dep b \), \(dep b =dep b + 1\), \(dep t =dep t + 1\); otherwise, jump to Step 2.3.1.1.4.1;

[0264] Step 2.3.1.1.4.1.2.3: Jump to Step 2.3.1.1.4.1;

[0265] Step 2.3.1.1.4.1.3: If its route part \(S r is a permutation of \(S r w q(k) \), and \(f(v)>f(v)\), then \(OPEN = OPEN\setminus\{v\}\cup\{v\}\); otherwise, jump to Step 2.3.1.1.4.1;

[0266] Step 2.3.1.1.4.1.4: Go to Step 2.3.1.1.4.1;

[0267] Step 2.3.1.1.4.2: Go to Step 2.3.1.1.4;

[0268] Step 2.3.1.1.5: Jump to Step 2.3.1.1;

[0269] Step 2.3.1.1.6: Return the vertex \(v\) and its corresponding scheduling scheme \(\alpha(v)\);

[0270] In each step of the search, HHS selects promising vertices through a heuristic function. However, the heuristic function does not guarantee that the order of two adjacent parts and their processing routes is optimal. Exchanging the order of two adjacent parts and their processing routes may enhance the search ability and thus generate more promising vertices.

[0271] Step 2.4: One-step Back Exchange Strategy;

[0272] The strategy of attempting to exchange the order of the last two parts in a vertex and the order of the last two processing routes in the vertex is called the One-step Back Exchange (OBE) strategy. This patent proposes two OBE strategies, namely OBE1 and OBE2.

[0273] Step 2.4.1: OBE1:

[0274] Given a vertex v, if v ≠ OBE1(v), then such a triggering of the strategy is called a valid trigger; otherwise, it is called an invalid trigger.

[0275] Algorithm OBE1:

[0276] Input: A vertex v = ((S J [1], S J [2],..., S J [i]); (S W [1], S W [2],..., S W [i]));

[0277] Output: A vertex v1;

[0278] Step 2.4.1.1: v1 = ((S J [1], S J [2],..., S J [i - 2], S J [i], S J [i - 1]); (S W [1], S W [2],..., S W [i - 2], S W [i], S W [i - 1]));

[0279] Step 2.4.1.2: If f(v1) < f(v), then return v1; otherwise, execute Step 2.4.1.3;

[0280] Step 2.4.1.3: Return v;

[0281] Applying the OBE strategy to each vertex in the search process will incur a large computational cost. Therefore, it is necessary to propose rules that can reduce ineffective triggers. Two such rules are given below.

[0282] Rule 1: Given a vertex v = ((S J [1], S J [2],..., S J [i - 1], S J [i]); (S W [1], S W [2],..., S W [i - 1], S W [i])), if S W [i] = S W [i - 1], then OBE1 is not triggered.

[0283] Rule 2: Let v = ((S J [1], S J [2],..., S J [i - 2], S J [i - 1], S J [i]); (S W [1], S W [2],..., S W [i - 2], S W [i - 1], S W [i])), v1 = ((S J [1], S J [2],..., S J [i - 2], S J [i], S J [i - 1]); (S W [1], S W [2],..., S W [i - 2], S W [i], S W [i - 1])), v2 = ((S J [1], S J [2],..., S J [i - 2], S J [i]); (S W [1], S W [2],..., S W [i - 2], S W [i])), and v3 = ((S J [1], S J [2],..., S J [i - 2], S J[i - 1]); (S W [1], S W [2],..., S W [i - 2], S W [i - 1])). Let τ(v) be the start time of the last part in vertex v. If τ(v) - τ(v2) ≤ τ(v1) - τ(v3), then the OBE1 strategy will not be triggered.

[0284] Step 2.4.2: OBE2:

[0285] Based on Rule 1 and Rule 2, this patent proposes the OBE2 strategy. Different from OBE1 which performs the OBE operation on all vertices, OBE2 only performs the OBE operation on vertices that meet the conditions in Rule 1 and Rule 2.

[0286] Algorithm OBE2

[0287] Input: A vertex v = ((S J [1], S J [2],..., S J [i - 1], S J [i]); (S W [1], S W [2],..., S W [i - 1], S W [i]), (i ∈ Z Φ ));

[0288] Output: A vertex v1;

[0289] Step 2.4.2.1: Let v1 = ((S J [1], S J [2],..., S J [i - 2], S J [i], S J [i - 1]); (S W [1], S W [2],..., S W [i - 2], S W [i], S W [i - 1])), v2 = ((S J [1], S J [2],..., S J [i - 2], S J [i]); (S W [1], S W [2],..., S W [i - 2], S W [i])), v3 = ((S J[1], S J [2],..., S J [i - 2], S J [i - 1]); (S W [1], S W [2],..., S W [i - 2], S W [i - 1]));

[0290] Step 2.4.2.2: If S W [i] ≠ S W [i - 1], execute Step 2.4.2.2.1; otherwise, execute Step 2.4.2.3;

[0291] Step 2.4.2.2.1: If τ(v) - τ(v2)) > τ(v1) - τ(v3), then return the result of v executing OBE1; otherwise, execute Step 2.4.2.3;

[0292] Step 2.4.2.3: Return v.

[0293] Example:

[0294] Experimental results:

[0295] Table 1 Processing time of processes

[0296]

[0297] The HHS algorithm is implemented in C++ language and runs on a desktop computer equipped with a 3.6 GHz processor and 12 GB of memory. A widely studied FMS in reference [3] is used to test the effectiveness of the HHS algorithm. Its PNS model is as Figure 1 shown, and the processing times of the processes are listed in Table 1. A deadlock controller in reference [2] is adopted for this PNS model.

[0298] Ten instances from reference [3], denoted as T1 - T10, are tested. Their corresponding (M0(p 1s ), M0(p 2s ), M0(p 3s )) are (3, 5, 3), (5, 5, 5), (5, 10, 5), (10, 10, 10), (10, 20, 10), (20, 20, 20), (20, 30, 20), (30, 30, 30), (30, 50, 30), and (50, 50, 50) respectively. The parameter settings of the HHS algorithm are height = 3 and max_top = 6, which are the same as those in reference [3].

[0299] In this embodiment, two experiments are conducted. First, the proposed heuristic function is compared with existing heuristic functions. Second, the effectiveness of the OBE strategy is tested.

[0300] Experiment 1: Effectiveness of the proposed heuristic function;

[0301] Let MSP denote the completion time for each case. Let wh1+HHS and wh2+HHS denote the heuristic algorithms using the first and second heuristic functions in reference [3], respectively. We use the HHS algorithm to test the proposed heuristic functions, namely h1 - h3. The results are listed in Table 1, where the results of wh1+HHS and wh2+HHS are from reference [3].

[0302] Table 2 Scheduling results under heuristic functions

[0303]

[0304]

[0305] Since both h1 and wh1 can estimate the remaining time of resources, h1+HHS and wh1+HHS are compared. As shown in Table 2, h1+HHS outperforms wh1+HHS in all ten instances, with an average improvement of 22.2% in terms of completion time.

[0306] Since h2, h3, and wh2 all estimate the remaining time required for each type of part, h2+HHS, h3+HHS are compared with wh2+HHS. h2+HHS outperforms wh2+HHS in eight out of ten instances, with an average improvement in completion time. h3+HHS outperforms wh3+HHS in nine out of ten instances, with an average improvement of 25.3% in completion time. Therefore, using the HHS algorithm with the proposed heuristic function has a significant improvement compared to the HHS algorithm using existing heuristic functions.

[0307] Compared with h1+HHS and h2+HHS, h3+HHS shows the best performance, obtaining nine optimal solutions in ten instances. In addition, the average completion time of h3+HHS is 11.3% and 17.1% smaller than that of h1+HHS and h2+HHS, respectively. It can be concluded that the performance of h3 is better than that of h1 and h2.

[0308] Experiment 2: Effectiveness of the OBE strategy;

[0309] Table 3 Scheduling results under the OBE strategy

[0310]

[0311]

[0312] Let h3+HHS+OBE1 and h3+HHS+OBE2 denote the heuristic search algorithms that combine OBE1 and OBE2 under the condition of adopting the heuristic function h3. To test the effectiveness of the OBE strategy, the completion time and running time of h3+HHS, h3+HHS+OBE1, and h3+HHS+OBE2 are compared. The experimental results are listed in Table 3, where the time unit is seconds.

[0313] As can be seen from Table 3, the completion times of h3+HHS+OBE1 and h3+HHS+OBE2 are the same. They can find the optimal solution for nine out of ten instances, while h3+HHS can only find the optimal solution for three out of ten instances.

[0314] In terms of running time, h3+HHS performs better than h3+HHS+OBE1 and h3+HHS+OBE2. The main reason is that h3+HHS does not execute the OBE strategy. Although the running efficiency of h3+HHS+OBE1 and h3+HHS+OBE2 is relatively low, for the instances with 150 parts, their running time does not exceed 150 seconds, which is acceptable in industrial cases.

[0315] h3+HHS+OBE2 shows the same performance as h3+HHS+OBE1 but has a shorter running time, which benefits from the proposed rules. In summary, when the running time limit is relatively strict, h3+HHS is recommended; otherwise, h3+HHS+OBE2 is recommended.

[0316] Summary:

[0317] Based on the location-time Petri net model of FMS, for the scheduling problem of FMSs with non-waiting constraints and prone to deadlocks, three heuristic functions and two OBE strategies are proposed. The HHS algorithm searches for the vertex with the minimum completion time in the CSG under the guidance of these three proposed heuristic functions. To avoid inferior vertices, two OBE strategies are proposed to find more promising vertices by swapping the last two parts and their processing routes. The computational results on benchmark instances show that the proposed heuristic functions and OBE strategies can significantly improve the performance of the HHS algorithm. In the future, more precise OBE strategies should be studied to improve the search efficiency. In addition, it is also an interesting research direction to adjust and adapt the proposed heuristic functions and OBE strategies for flexible manufacturing systems with multiple resource requirements.

Claims

1. A heuristic search scheduling method for minimizing the completion time of a no-wait flexible manufacturing system, characterized in that: It includes the following steps: Step 1: Modeling of flexible assembly system; Step 1.1: Petri net; A Petri net is a directed bipartite graph with two types of vertices: place and transition. Places are represented by circles, transitions are represented by rectangles or thick solid lines, and places and transitions are connected by directed arcs. Let Z = {0, 1, 2, ...}, Z + ={1,2,3,…}, Z k ={1,2,…,k}, where k∈Z + ; The specific definition of Petri net is as follows: A Petri net is a 3-tuple N = (P, T, F), where P is a position set, T is a transition set, is a directed arc set, P and T are finite disjoint non-empty sets, that is, In the Petri net N = (P, T, F), given a vertex x∈P∪T, use · x = {y∈P∪T|(y,x)∈F} and x · ={y∈P∪T|(x,y)∈F} represents the preset and postset of x respectively. Given a set use · X = ∪ x∈X · x and X · =∪ x∈X x · ; The state or marking of a Petri net N = (P, T, F) is a mapping M: P → Z from a set of positions to a set of non-negative integers. * , for position p∈P and label M, M(p) represents the number of tokens in position p under label M, the number of tokens in the position is represented by the number of black dots or positive integers, the Petri net N with initial label M0 is called label Petri net, denoted by (N,M0); The identity is represented by a vector, that is, M = (M(p1), M(p2), …, M(p |P| )) T , use ∑ p∈P M(p)p represents the identifier M; Given a Petri net N = (P, T, F), t∈T is a transition in N, M is a marker in N, if If M(p)>0, then transition t is called enabled under the label M, denoted by M[t>; triggering the firing transition t under the label M will cause the system to transition from label M to label M′, denoted by M[t>M′, where M′(p)=M(p)-1; M′(p)=M(p)+1; otherwise, M′(p)=M(p); for the transition sequence τ=t1t2…t k , t i ∈T, i∈Z k , if M i [t i >M i+1 , where M1=M, then τ is feasible under M; Step 1.2: Timed Petri net model of FMS; The PN scheduling model PNS consists of m resources and can produce l products through n parts. The set of part types is represented by Q = {q,q∈Z n } indicates; represents the total number of parts, where is the number of q-type parts to be processed; the set of resource types is represented by R = {r1, r2, …, r m } indicates; resource r i The capacity is expressed as C(r i ) represents; let r ij is the jth instance of the resource, where The total number of processing routes in the system is K; a processing route consists of a series of operations; let represents the kth processing route, where o kl is the lth operation, L k Yes k The number of operations in kl )∈R represents o kl The required resources, the set of all processing routes in the system is marked as Ω = {w1,w2,…,w K }; Given q∈Z n ,make is the set of processing routes for type q parts; there is at least one route for type q parts to be processed, that is, |Ω q |≥1; add two virtual operations o qs and qe , which are used to mark the start and end of the processing of type q parts respectively; the u-th processing route of type q parts can be marked as in And w q(u) ∈Ω q ; Two different processing routes will be merged into one operation if they contain the same operation; Let p qs and p qe Respectively represent operation o qs and qe , let p q(u)l Represented as operation o q(u)l The operation library, t q(u)l and t q(u)(l+1) Respectively represent o q(u)l The transition between start and finish, where w q(u) ∈Ω q , A processing route in FMS q(u) Through the path To model; once the operation t q(u)(l-1) Complete, Transition q(u)l It must be triggered immediately; the identification PN model of the processing route of type q parts is expressed as: (N q ,M q0 )=(P q ∪{p qs ,p qe },T q ,F q ,M q0 ),q∈Q Among them, P q =∪ 1≤u≤|Ωq| {p q(u)1 ,p q(u)2 ,...,p q(u)Lq(u) }, and M q0 is the initial identifier, And for any p∈P q ∪{p qe }, both have M q0 (p) = 0; in N q For any t∈T q ,| · t|=|t · |=1; if |p · |>1, then p is a branch place, where the part can choose its processing route; In FMS, the resource library is recorded as r i ; Let P R Represents all resource repositories; available r i The number of resources of the type is determined by the resource library. i It is expressed as the number of tokens in; C(r i ) is r i The initial number of identifications; Let R(p)∈R represent the resources required by the operation library p; in the PN model, add from R(p) to · The arc of each transition in p, and the arc from p · Each arc in transitions to R(p); let F R Represents a collection of arcs related to the resource library; the identifier PN can model the entire system: (N,M0)=(P∪P s ∪P f ∪P R ,T,F,M0) Where P = {P q |q∈Q},P s ={p qs |q∈Q},P f ={p qe |q∈Q},T={T q |q∈Q}, F=F Q ∪F R , F Q ={F q |q∈Q}; the initial identifier M0 is defined as qs ∈P s , both have For any p∈P∪P f , M0(p)=0; for any r i ∈P R , both have M0(r i )=C(r i ); Let M f Indicates the final mark when all parts are processed. All have M f (p qe )=M0(p qs );for All have M f (p) = 0; for All have M f (r i )=C(r i ); For p∈P, let o be the corresponding operation; let d(o) be the processing time of operation o; assign a time delay d(p)=d(o) to p, and for All have d(p) = 0; such a position timing PN model for flexible assembly system is called PN scheduling model PNS; Step 1.3: Deadlock controller of PNS; Let (C,μ C )=(P C ,T C ,F C ,μ C ) represents a PN deadlock controller; P C Each control place in can be regarded as a special resource, called control resource; the token in the control resource place represents the number of control resource instances, and the arcs related to the control resources represent their allocation and release; then, the controlled PNS, namely CPNS, can be modeled by an identifier PN, namely make Represents the set of control resources required to operate the library p; Step 2: Hybrid heuristic search algorithm; Step 2.1: Combined search graph; In FMS, a part may have multiple alternative processing routes; therefore, there may be multiple route selection schemes corresponding to different completion times for a part sequence; to distinguish different route selection schemes, a kind of CSG is defined, where the vertices of the graph are the combinations of part sequences and their corresponding route selection schemes; Let G(N C ,M C0 )=(V,E) represents the CSG of FMS, where V is the vertex set and E is the directed arc set; a vertex v=(S J ,S W ) contains a part sequence S J , in S J The i-th part in is S J [i]∈Z Φ , and for Both S J [k]≠S J [t]; also contains a J The route selection scheme, namely S W , where S W The i-th route in S W [i], is S J [i] The corresponding route; if S J [i] is a q-type part, then S W [i]∈Ω q ; If there is a part J i and a route w j ,satisfy w j ∈Ω is J i A route, S J2 =S J1 J i , and S W2 =S W1 w j , then there is a path from vertex v1 = (S J1 ,S W1 ) points to v2 = (S J2 ,S W2 ) arc; let dep(v)=|S J | indicates that v is in G(N C ,M C0 ) in depth; make represents the initial vertex, here is an empty string, v f =(S Jf ,S Wf ) represents the final vertex, indicating that all parts have been arranged; Step 2.2: New heuristic function; Assign a priority value to each vertex v∈V using the heuristic function f(v)=g(v)+h(v), where g(v) is the cost from v0 to v and h(v) is the cost from v to v. f the estimated cost of Let h*(v) denote the distance from v to v f The actual minimum cost of h(v)≤h*(v), then h(v) is admissible; The first heuristic function h1(v) estimates the remaining time that each resource is occupied by unscheduled parts based on g(v); h1(v) is calculated in two steps: first, it calculates the number of times r is needed to process all unscheduled parts at vertex v. i , i∈Z m The minimum total time of type resources; secondly, analyze each r i For each idle interval of the instance, the maximum time that all unscheduled parts can use a certain idle interval is calculated under the constraints of no waiting and no deadlock; Let J(q,v) denote the set of unarranged parts of type q at vertex v, w q(k) is the kth processing route of type q parts, where If the route w q(k) The lth operation in q(k)l , requires r i type of resource, let δ(r i ,o q(k)l )=1; otherwise, let δ(r i ,o q(k)l )=0, here And i∈Z m ; Let Ψ(r i ,v) represents the r required to process all unarranged parts under vertex v i Minimum total time for a resource of type; definition: Let α(v) denote the scheduling solution obtained for vertex v using the TA algorithm; due to the absence of deadlock, no waiting constraints, and priority constraints, there are idle intervals between the parts scheduled on the resource, which are identified as type 1 idle intervals; let τ(r ij ,v) means that in the Gantt chart of α(v), resource r ij The number of type 1 idle intervals; let δ(r ij ,v,l) and ε(r ij ,v,l) respectively represent the resource r ij The start and end time of the lth type 1 idle interval in, where l = 1, 2, …, τ(r ij ,v); then a type 1 idle interval is represented by {δ(r ij ,v,l),ε(r ij ,v,l)}; Let χ(r ij ,v) means that under vertex v, resource r ij The completion time of the last scheduled part on resource r ij Scheduling unscheduled parts after the last scheduled part may result in an idle interval, which is identified as a type 2 idle interval, that is, {χ(r ij ,v),X}, where X is a time variable, indicating that an unscheduled part will occupy resource r from time X ij ; For type 1 idle interval {δ(r ij ,v,l),ε(r ij ,v,l)}, using the time from its earliest available use to ε(r ij ,v,l) interval time to estimate the maximum time it can be used; for type 2 idle interval {χ(r ij ,v),X}, then use the ij ,v) The interval time to the earliest time it can be used is used to estimate the shortest time that will be generated; Step 2.2.1: Earliest start time algorithm; Given a vertex v and a resource r ij In the idle interval {a, b}, an earliest start time EST algorithm is proposed to calculate the earliest start time of the parts that can use {a, b} and meet the no-wait and no-deadlock constraints; the EST algorithm starts from the earliest time that the idle interval can be used Start searching and once you find one that can be From the moment {a,b} is used, the EST algorithm returns If no parts can be obtained from From now on, we use {a,b}, then Add 1; this process will be repeated until a part is found or until; EST algorithm: Input: (N C ,M C0 ) of vertex v and resource r ij And resources ij The idle interval {a,b}; Output: Initialization: Apply the TA algorithm to vertex v to obtain the scheduling plan α(v) and resource r ij {δ(r ij ,v,l),ε(r ij ,v,l)}, where i∈Z m , l∈{1,2,…,τ(r ij ,v)}; Step 2.2.1.1: Order Step 2.2.1.2: If Then execute steps 2.2.1.2.1 to 2.2.1.2.3, otherwise jump to step 2.2.1.3; Step 2.2.1.2.1: Let q = 1; Step 2.2.1.2.2: If q≤n and If yes, execute step 2.2.1.2.2.1 to step 2.2.1.2.2.2; otherwise, jump to step 2.2.1.2.3: Step 2.2.1.2.2.1: For each w q(k) ∈Ω q Execute step 2.2.1.2.2.1.1; Step 2.2.1.2.2.1.1: For each o xy ∈w q(k) and R(o xy )=r i Perform steps 2.2.1.2.2.1.1.1 and 2.2.1.2.2.1.1.2; Step 2.2.1.2.2.1.1.1: Assume o xy In r i The start time on And calculate and arrange a method using w q(k) When the processing route satisfies the q-type parts without waiting constraints, it is consistent with w q(k) Each resource involved and the intervals required to control it; Step 2.2.1.1.1.1.1.2: If w q(k) If the idle intervals of all related resources and control resources can meet the interval requirements calculated in step 2.2.1.2.2.1.1.1, jump to step 2.2.1.4; Step 2.2.1.2.2.2: Increment q by 1 and jump to Step 2.2.1.2.2; Step 2.2.1.2.3: Add 1 and jump to step 2.2.1.2; Step 2.2.1.3: Return make represents the earliest time when the lth type 1 idle interval can be used, where l = 1, 2, ..., τ (r ij ,v); Indicates that under vertex v, resource r ij The earliest time to schedule unscheduled parts after the last part is loaded; make Indicates resource r ij The total time that a type 1 idle interval can be occupied; the first heuristic function is defined as follows: Define Lemma 1: h1(v) is admissible; Two heuristic functions, denoted as h2(v) and h3(v), are used to estimate the J ,S W ) The remaining processing time for each type of part is developed; Let S Jq represents a permutation of the parts in J(q,v) in ascending order; h2(v) Jq The parts in Ω are assigned to q On each route in S Jq The lth part in selects Ω q The first {l mod|Ω q |} routes; let S Wq2 represents the route selection strategy generated by this route selection strategy for S Jq The route selection result; then, derive a vertex v from vertex v q2 =(S J S Jq ; S W S Wq2 ); Define as follows: Step 2.2.2: Greedy strategy; h3(v) is S through the following greedy strategy GS Jq Part selection in Ω q The route in Algorithm GS: Input: a vertex v = (S J ; S W ), and a part type q∈Z n ; Output: A new vertex v q3 =(S J S Jq ; S W S Wq3 ); Step 2.2.2.1: Let v q3 =v,v t =v; Step 2.2.2.2: Let i = 1; Step 2.2.2.3: If i is less than or equal to |J(q,v)|, execute Steps 2.2.2.3.1 to 2.2.2.3.5, otherwise jump to Step 2.2.2.5; Step 2.2.2.3.1: Let k be the i-th part in J(q,v); Step 2.2.2.3.2: Let g m =MAX; MAX is an infinite value Step 2.2.2.3.3: Let j = 1; Step 2.2.2.3.4: If j is less than or equal to |Ω q |, execute steps 2.2.2.3.4.1 to 2.2.2.3.4.5, otherwise jump to step 2.2.2.3.5; Step 2.2.2.3.4.1: Let w t Ω q The jth route in ; Step 2.2.2.3.4.2: Assume v q3 =(S J1 ; S W1 ), let g1=g(S J1 k;S W1 w t ); Step 2.2.2.3.4.3: If g1 <g m , then g m =g1,v t =(S J1 k;S W1 w t ); Step 2.2.2.3.4.4: v q3 =v t ; Step 2.2.2.3.4.5: Increment j by 1 and jump to Step 2.2.2.3.4; Step 2.2.2.3.5: Increment i by 1 and jump to Step 2.2.2.3; Step 2.2.2.5; return v q3 ; h3(v) is defined as follows: Step 2.3: Hybrid heuristic search HHS; Step 2.3.1: HHS algorithm; Command dep t and dep b dep respectively represent the maximum depth and minimum depth of the vertex, the distance between the maximum depth and the minimum depth is recorded as the height, which is a constant; the vertices in the current search window are composed of two categories: explored vertices and unexplored vertices; let ne(d) and nu(d) represent the number of explored vertices and unexplored vertices at a depth of d, let CLOSED and OPEN represent the set of explored vertices and the set of unexplored vertices, respectively; max_top is a parameter used to limit the maximum depth dep t A constant for the number of unexplored vertices at ; In the preparation phase, the explored vertex set CLOSED is initialized to an empty set, and the unexplored vertex set OPEN contains only the initial vertex v0; using the heuristic function, in each search step, the most promising vertex is selected from the set, that is, the vertex with the smallest f(v) value; the selected vertex will be explored and then moved to the CLOSED set; arranging the unarranged parts of the selected vertex will generate a new unexplored vertex, and some promising vertices will be placed in the OPEN set; at the same time, when the number of unexplored vertices at the minimum depth nu (dep b ) = 0 or the number of unexplored vertices at the maximum depth nu(dep t )>max_top, the dynamic window will move downward; this process will be repeated until all parts are arranged; the HHS algorithm is as follows: HHS algorithm: Input: height, max_top, (N C ,M C0 ); Input: A final vertex v and its corresponding scheduling scheme α(v); Initialization: dep b =0,dep t =height,OPEN={v0}, Step 2.3.1.1: If OPEN is not equal to Execute steps 2.3.1.1.1 to 2.3.1.1.5, otherwise execute step 2.3.1.6: Step 2.3.1.1.1: If nu(dep b )=0, then dep b Add 1, dep t Add 1, otherwise go to step 2.3.1.1.2; Step 2.3.1.1.2: Select an unexplored vertex v∈OPEN from OPEN, satisfying the minimum value of f(v) and dep(v) <dep t , let OPEN=OPEN\{v}, CLOSED=CLOSED∪{v}; Step 2.3.1.1.3: If v is a final vertex, return vertex v and its corresponding scheduling scheme α(v), otherwise execute Step 2.3.1.1.4; Step 2.3.1.1.4: For each q∈Z n For the unscheduled parts with J∈J(q,v)), execute steps 2.3.1.1.4.1 and 2.3.1.1.4.2; Step 2.3.1.1.4.1: For each processing route of J, w q(k) ( and w q(k) ∈Ω q ), execute steps 2.2.1.1.4.1.1 and 2.3.1.1.4.1.4; Step 2.3.1.1.4.1.1: Let v = (S o J,S r w q(k) ); Step 2.3.1.1.4.1.2: If there is a vertex v∈OPEN∪CLOSED, its path part S r YesS r w q(k) If there is one arrangement of , execute steps 2.3.1.1.4.1.2.1 to 2.3.1.1.4.1.2.3; otherwise, execute step 2.3.1.1.4.1.3; Step 2.3.1.1.4.1.2.1: OPEN = OPEN ∪ {v}; Step 2.3.1.1.4.1.2.2: If nu(dep t )>max_top, then the unexplored vertex set OPEN with a depth of dep is discarded b The vertex, dep b Add 1, dep t Add 1, otherwise jump to step 2.3.1.1.4.1; Step 2.3.1.1.4.1.2.3: Jump to Step 2.3.1.1.4.1; Step 2.3.1.1.4.1.3: If Its route part S r YesS r w q(k) a permutation of , and f(v)>f(v), then OPEN=OPEN\{v}∪{v}, otherwise jump to step 2.3.1.1.4.1; Step 2.3.1.1.4.1.4: Go to Step 2.3.1.1.4.1; Step 2.3.1.1.4.2: Go to Step 2.3.1.1.4; Step 2.3.1.1.5: Jump to Step 2.3.1.1; Step 2.3.1.1.6: Return vertex v and its corresponding scheduling scheme α(v); Step 2.4: One-step backtracking exchange strategy OBE; Step 2.4.1: OBE1: Given a vertex v, if v ≠ OBE1(v), then such a trigger of the strategy is called a valid trigger; otherwise, it is called an invalid trigger; Algorithm OBE1: Input: a vertex v = ((S J [1],S J [2],...,S J [i]); (S W [1],S W [2],...,S W [i])); Output: A vertex v1; Step 2.4.1.1: v1 = ((S J [1], S J [2],..., S J [i - 2], S J [i], S J [i - 1]); (S W [1], S W [2],..., S W [i - 2], S W [i], S W [i - 1])); Step 2.4.1.2: If f(v1) < f(v), then return v1, otherwise execute Step 2.4.1.3; Step 2.4.1.3: Return v; Give two rules: Rule 1: Given a vertex v = ((S J [1],S J [2],...,S J [i-1],S J [i]); (S W [1],S W [2],...,S W [i-1],S W [i])), if S W [i] = S W [i-1], then OBE1 is not triggered; Rule 2: Let v = ((S J [1],S J [2],...,S J [i-2],S J [i-1],S J [i]); (S W [1],S W [2],...,S W [i-2],S W [i-1],S W [i])), v1=((S J [1],S J [2],...,S J [i-2],S J [i],S J [i-1]); (S W [1],S W [2],...,S W [i-2],S W [i],S W [i-1])), v2=((S J [1],S J [2],...,S J [i-2],S J [i]); (S W [1],S W [2],...,S W [i-2],S W [i])), and v3=((S J [1],S J [2],...,S J [i-2],S J [i-1]); (S W [1],S W [2],...,S W [i-2],S W [i-1])); Let τ(v) be the start time of the last part in vertex v; if τ(v)-τ(v2)≤τ(v1)-τ(v3), the OBE1 strategy will not be triggered; Step 2.4.2: OBE2: Based on Rule 1 and Rule 2, the OBE2 strategy is proposed. Different from OBE1 which performs OBE operations on all vertices, OBE2 only performs OBE operations on vertices that meet the conditions in Rule 1 and Rule 2. Algorithm OBE2: Input: a vertex v = ((S J [1],S J [2],...,S J [i-1],S J [i]); (S W [1],S W [2],...,S W [i-1],S W [i])),(i∈Z Φ ); Output: a vertex v1; Step 2.4.2.1: Let v1 = ((S J [1], S J [2],..., S J [i - 2], S J [i], S J [i - 1]); (S W [1], S W [2],..., S W [i - 2], S W [i], S W [i - 1])), v2 = ((S J [1], S J [2],..., S J [i - 2], S J [i]); (S W [1], S W [2],..., S W [i - 2], S W [i])), v3 = ((S J [1], S J [2],..., S J [i - 2], S J [i - 1]); (S W [1], S W [2],..., S W [i - 2], S W [i - 1])); Step 2.4.2.2: If S W [i]≠S W [i-1], execute step 2.4.2.2.1, otherwise execute step 2.4.2.3; Step 2.4.2.2.1: If τ(v)-τ(v2))>τ(v1)-τ(v3), return the result of executing OBE1 on v, otherwise execute step 2.4.2.3; Step 2.4.2.3: Return v.

2. A computer program, characterized in that The computer program enables a computer to execute the method as claimed in claim 1.

3. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the method as claimed in claim 1 is implemented.

4. A chip, characterized in that: include: A processor, used to call and run a computer program from a memory, so that a device equipped with the chip executes the method as claimed in claim 1.

5. A computer program product, characterized in that The computer program product comprises a computer storage medium storing a computer program, wherein the computer program comprises instructions executable by at least one processor, and when the instructions are executed by the at least one processor, the method according to claim 1 is implemented.

6. An electronic device, characterized in that: include: Processor and memory; The memory is used to store a computer program, and the processor is used to execute the computer program stored in the memory, so that the electronic device executes the method as claimed in claim 1.

Images